e2e-tests:rust-server:fix

Author: Voldemat

e2e-tests/rust-server/Cargo.toml

@@ -8,7 +8,7 @@ libgql = { path = "../../rust/libgql" }
 serde = { version = "1.0.228", features = ["derive", "serde_derive"], default-features = false }
 libgqlcodegen = { path = "../../rust/gqlcodegen" }
 hyper = { version = "1", features = ["server", "http1"], default-features = false }
-tokio = { version = "1", features = ["net", "macros"], default-features = false }
+tokio = { version = "1", features = ["net", "macros", "rt-multi-thread"], default-features = false }
 http-body-util = "0.1"
 hyper-util = { version = "0.1", features = ["server", "http1", "tokio"], default-features = false }
 serde_json = { version = "1.0.149", default-features = false }

e2e-tests/rust-server/src/api/state.rs

@@ -1,5 +1,5 @@
 pub struct APIState {
-    pub graphql_registry: libgql::parsers::schema::type_registry::TypeRegistry,
+    pub graphql_registry: libgql::parsers::schema::server::type_registry::TypeRegistry,
     pub graphql_resolvers_map:
         libgql::executor::Resolvers<'static, super::scalar::Scalar, super::context::Context>,
     pub graphql_parse_registry: libgql::executor::HashMapRegistry<super::scalar::Scalar>,

e2e-tests/rust-server/src/main.rs

@@ -4,48 +4,43 @@ mod api;
 
 const GRAPHQL_SERVER_SCHEMA: &str = include_str!("../../graphql/server-schema.json");
 
-#[tokio::main(flavor = "current_thread")]
+#[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let local = tokio::task::LocalSet::new();
-    local
-        .run_until(async {
-            let port = std::env::var("PORT").unwrap().parse().unwrap();
-            let addr = std::net::SocketAddr::from(([0, 0, 0, 0], port));
-            let listener = tokio::net::TcpListener::bind(addr).await?;
-            let state = Arc::new(api::state::APIState {
-                graphql_resolvers_map: api::generated::create_resolvers_map(),
-                graphql_parse_registry: api::generated::create_parse_registry(),
-                graphql_registry: {
-                    let mut registry = libgql::parsers::schema::type_registry::TypeRegistry::new();
-                    libgql::json::parsers::schema::parse_server_schema(
-                        &mut registry,
-                        serde_json::from_str::<serde_json::Value>(GRAPHQL_SERVER_SCHEMA).unwrap(),
-                    )
-                    .unwrap();
-                    registry
-                },
-            });
-            loop {
-                let (stream, _) = listener.accept().await?;
+    let port = std::env::var("PORT").unwrap().parse().unwrap();
+    let addr = std::net::SocketAddr::from(([0, 0, 0, 0], port));
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    let state = Arc::new(api::state::APIState {
+        graphql_resolvers_map: api::generated::create_resolvers_map(),
+        graphql_parse_registry: api::generated::create_parse_registry(),
+        graphql_registry: {
+            let mut registry = libgql::parsers::schema::server::type_registry::TypeRegistry::new();
+            libgql::json::parsers::schema::parse_server_schema(
+                &mut registry,
+                serde_json::from_str::<serde_json::Value>(GRAPHQL_SERVER_SCHEMA).unwrap(),
+            )
+            .unwrap();
+            registry
+        },
+    });
+    loop {
+        let (stream, _) = listener.accept().await?;
 
-                let io = hyper_util::rt::TokioIo::new(stream);
-                let local_state = state.clone();
+        let io = hyper_util::rt::TokioIo::new(stream);
+        let local_state = state.clone();
 
-                tokio::task::spawn_local(async move {
-                    let s = local_state;
-                    if let Err(err) = hyper::server::conn::http1::Builder::new()
-                        .serve_connection(
-                            io,
-                            hyper::service::service_fn(async |request| {
-                                api::root_handler(&s, request).await
-                            }),
-                        )
-                        .await
-                    {
-                        eprintln!("Error serving connection: {:?}", err);
-                    }
-                });
+        tokio::task::spawn(async move {
+            let s = local_state;
+            if let Err(err) = hyper::server::conn::http1::Builder::new()
+                .serve_connection(
+                    io,
+                    hyper::service::service_fn(async |request| {
+                        api::root_handler(&s, request).await
+                    }),
+                )
+                .await
+            {
+                eprintln!("Error serving connection: {:?}", err);
             }
-        })
-        .await
+        });
+    }
 }