wip: Service definition

Author: netrome

Cargo.lock

@@ -14,6 +14,7 @@ version = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 async-graphql = { workspace = true }
+axum = { workspace = true }
 derive_more = { workspace = true }
 fuel-core-global-merkle-root-storage = { workspace = true }
 fuel-core-services = { workspace = true }
@@ -23,6 +24,7 @@ fuel-core-types = { workspace = true, default-features = false, features = [
   "alloc",
 ] }
 hex = { workspace = true }
+hyper = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]

crates/proof_system/global_merkle_root/api/Cargo.toml

@@ -0,0 +1,135 @@
+use std::{
+    future::{
+        Future,
+        IntoFuture,
+    },
+    marker::PhantomData,
+    net::{
+        TcpListener,
+        ToSocketAddrs,
+    },
+    pin::Pin,
+};
+
+use async_graphql::http::GraphiQLSource;
+use axum::{
+    response::{
+        Html,
+        IntoResponse,
+    },
+    routing,
+    Router,
+};
+use fuel_core_services::{
+    RunnableService,
+    RunnableTask,
+    ServiceRunner,
+    StateWatcher,
+    TaskNextAction,
+};
+
+pub fn new_service<Storage>(
+    storage: Storage,
+    network_address: impl ToSocketAddrs,
+) -> anyhow::Result<ServiceRunner<StateRootApiService>> {
+    Ok(ServiceRunner::new(StateRootApiService::new(
+        storage,
+        network_address,
+    )?))
+}
+
+pub struct StateRootApiService {
+    router: Router<hyper::Body>,
+    listener: TcpListener,
+}
+
+impl StateRootApiService {
+    #[tracing::instrument(skip(storage, network_address))]
+    fn new<Storage>(
+        storage: Storage,
+        network_address: impl ToSocketAddrs,
+    ) -> anyhow::Result<Self> {
+        let graphql_endpoint = "/graphql";
+
+        let graphql_playground = || render_graphql_playground(graphql_endpoint);
+
+        // TODO: Create schema, and serve it
+
+        let router = Router::<hyper::Body>::new()
+            .route("/playground", routing::get(graphql_playground));
+
+        let listener = TcpListener::bind(network_address)?;
+
+        Ok(Self { router, listener })
+    }
+}
+
+#[async_trait::async_trait]
+impl RunnableService for StateRootApiService {
+    const NAME: &'static str = "StateRootGraphQL";
+
+    type SharedData = ();
+    type Task = StateRootApiTask;
+    type TaskParams = ();
+
+    fn shared_data(&self) -> Self::SharedData {}
+
+    #[tracing::instrument(skip(self, state, _params))]
+    async fn into_task(
+        self,
+        state: &StateWatcher,
+        _params: Self::TaskParams,
+    ) -> anyhow::Result<Self::Task> {
+        let mut state = state.clone();
+
+        let graceful_shutdown_signal = async move {
+            state.while_started().await.expect("unexpected termination");
+        };
+
+        let bound_address = self.listener.local_addr()?;
+        tracing::info!(%bound_address, "listening for GraphQL requests");
+
+        let server = Box::pin(
+            axum::Server::from_tcp(self.listener)?
+                .serve(self.router.into_make_service())
+                .with_graceful_shutdown(graceful_shutdown_signal),
+        );
+
+        Ok(StateRootApiTask { server })
+    }
+}
+
+pub struct StateRootApiTask {
+    server: Pin<Box<dyn Future<Output = hyper::Result<()>> + Send + 'static>>,
+}
+
+impl RunnableTask for StateRootApiTask {
+    async fn run(
+        &mut self,
+        watcher: &mut fuel_core_services::StateWatcher,
+    ) -> TaskNextAction {
+        match self.server.as_mut().await {
+            Ok(()) => {
+                // The `axum::Server` has stopped, and so should we
+                TaskNextAction::Stop
+            }
+            Err(error) => {
+                tracing::error!(%error, "state root axum server returned error");
+                TaskNextAction::Stop
+            }
+        }
+    }
+
+    async fn shutdown(self) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
+
+async fn render_graphql_playground(graphql_endpoint: &str) -> impl IntoResponse {
+    Html(
+        GraphiQLSource::build()
+            .endpoint(graphql_endpoint)
+            .title("Fuel Graphql Playground")
+            .finish(),
+    )
+}