mid coding commit

core/archipelago/src/server.rs

@@ -0,0 +1,63 @@
+use crate::api::ApiHandler;
+use crate::config::Config;
+use anyhow::Result;
+use hyper_util::rt::TokioIo;
+use hyper_util::server::conn::auto::Builder as AutoBuilder;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::net::TcpListener;
+use hyper::service::service_fn;
+use tracing::{error, info};
+
+pub struct Server {
+    config: Config,
+    api_handler: Arc<ApiHandler>,
+}
+
+impl Server {
+    pub async fn new(config: Config) -> Result<Self> {
+        let api_handler = Arc::new(ApiHandler::new(config.clone()).await?);
+
+        Ok(Self {
+            config,
+            api_handler,
+        })
+    }
+
+    pub async fn serve(&self, addr: SocketAddr) -> Result<()> {
+        let listener = TcpListener::bind(addr).await?;
+
+        loop {
+            let (stream, peer_addr) = match listener.accept().await {
+                Ok(conn) => conn,
+                Err(e) => {
+                    error!("Failed to accept connection: {}", e);
+                    continue;
+                }
+            };
+
+            let io = TokioIo::new(stream);
+            let handler = self.api_handler.clone();
+
+            tokio::spawn(async move {
+                let service = service_fn(move |req| {
+                    let handler = handler.clone();
+                    async move {
+                        handler.handle_request(req).await
+                            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
+                    }
+                });
+
+                let builder = AutoBuilder::new(
+                    hyper_util::rt::TokioExecutor::new()
+                );
+                if let Err(e) = builder
+                    .serve_connection(io, service)
+                    .await
+                {
+                    error!("Error serving connection from {}: {}", peer_addr, e);
+                }
+            });
+        }
+    }
+}