workspace reshape

crates/server/src/http.rs

@@ -0,0 +1,86 @@
+use std::{convert::Infallible, error::Error, net::SocketAddr, sync::Arc};
+
+use bytes::Bytes;
+use http_body_util::Full;
+use hyper::{Request, Response, server::conn::http2, service::service_fn};
+use hyper_util::rt::{TokioExecutor, TokioIo};
+use serde::Serialize;
+use tokio::{
+    net::TcpListener,
+    sync::{
+        Mutex,
+        mpsc::{Receiver, Sender},
+    },
+};
+
+use crate::AppState;
+
+pub struct HttpServer {
+    pub offer_tx: Sender<(String, String)>,
+    pub accept_rx: Receiver<(String, String)>,
+    pub appstate: Arc<Mutex<AppState>>,
+}
+
+impl HttpServer {
+    pub fn start(&mut self) -> Result<(), Box<dyn Error>> {
+        let state = self.appstate.clone();
+        tokio::spawn(async move {
+            let socket = SocketAddr::from(([127, 0, 0, 1], 3000));
+            let listener = TcpListener::bind(socket).await.unwrap();
+            loop {
+                let (stream, _) = listener.accept().await.unwrap();
+                let tokio_io = TokioIo::new(stream);
+                let state = state.clone();
+                tokio::spawn(async move {
+                    let service = service_fn(move |req| {
+                        let state = state.clone();
+                        async move { handle_request(req, &state).await }
+                    });
+                    let hyper = http2::Builder::new(TokioExecutor::new());
+                    hyper.serve_connection(tokio_io, service).await.unwrap();
+                });
+            }
+        });
+        Ok(())
+    }
+}
+
+async fn handle_request(
+    request: Request<impl hyper::body::Body>,
+    appstate: &Arc<Mutex<AppState>>,
+) -> Result<Response<Full<Bytes>>, Infallible> {
+    match request.uri().path() {
+        "/api/catalog" => {
+            let catalog = catalog_from_state(appstate).await;
+            let body = serde_json::to_vec(&catalog).unwrap();
+            Ok(Response::builder()
+                .status(200)
+                .header("content-type", "application/json")
+                .body(Full::new(Bytes::from(body)))
+                .unwrap())
+        }
+        "/api/meow" => Ok(Response::builder()
+            .status(200)
+            .body(Full::new(Bytes::from("meow")))
+            .unwrap()),
+        _ => Ok(Response::builder()
+            .status(404)
+            .body(Full::new(Bytes::from("")))
+            .unwrap()),
+    }
+}
+
+#[derive(Serialize)]
+struct StreamCatalog {
+    active_streams: Vec<String>,
+}
+
+async fn catalog_from_state(state: &Arc<Mutex<AppState>>) -> StreamCatalog {
+    let app = state.lock().await;
+    let active_streams = app
+        .stream_sessions
+        .iter()
+        .map(|e| e.key().clone())
+        .collect();
+    StreamCatalog { active_streams }
+}