feat(homeserver): add http server as well as https

pubky-homeserver/src/io/http.rs

@@ -13,22 +13,76 @@ use axum_server::{
 
 use crate::core::HomeserverCore;
 
-pub(crate) async fn start(core: HomeserverCore) -> Result<Handle> {
-    let listener = TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], core.config.port())))?;
-
-    let acceptor = RustlsAcceptor::new(RustlsConfig::from_config(Arc::new(
-        core.keypair().to_rpk_rustls_server_config(),
-    )));
-    let server = axum_server::from_tcp(listener).acceptor(acceptor);
-
-    let handle = Handle::new();
-
-    tokio::spawn(
-        server.handle(handle.clone()).serve(
-            core.router
-                .into_make_service_with_connect_info::<SocketAddr>(),
-        ),
-    );
-
-    Ok(handle)
+#[derive(Debug)]
+pub struct HttpServers {
+    /// Handle for the HTTP server
+    pub(crate) http_handle: Handle,
+    /// Handle for the HTTPS server using Pkarr TLS
+    pub(crate) https_handle: Handle,
+    // /// Handle for a mock relay used in testnet
+    // pub(crate) mock_pkarr_relay_handle: Handle,
+}
+
+impl HttpServers {
+    pub async fn start(core: &HomeserverCore) -> Result<Self> {
+        let http_listener =
+        // TODO: add config to http port
+            TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], 0)))?;
+
+        let http_handle = Handle::new();
+
+        tokio::spawn(
+            axum_server::from_tcp(http_listener)
+                .handle(http_handle.clone())
+                .serve(
+                    core.router
+                        .clone()
+                        .into_make_service_with_connect_info::<SocketAddr>(),
+                ),
+        );
+
+        let https_listener =
+            TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], core.config.port())))?;
+
+        let https_handle = Handle::new();
+
+        tokio::spawn(
+            axum_server::from_tcp(https_listener)
+                .acceptor(RustlsAcceptor::new(RustlsConfig::from_config(Arc::new(
+                    core.keypair().to_rpk_rustls_server_config(),
+                ))))
+                .handle(https_handle.clone())
+                .serve(
+                    core.router
+                        .clone()
+                        .into_make_service_with_connect_info::<SocketAddr>(),
+                ),
+        );
+
+        // let mock_pkarr_relay_listener = TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], 15411)))?;
+
+        Ok(Self {
+            http_handle,
+            https_handle,
+        })
+    }
+
+    pub async fn http_address(&self) -> Result<SocketAddr> {
+        match self.http_handle.listening().await {
+            Some(addr) => Ok(addr),
+            None => Err(anyhow::anyhow!("Failed to bind to http port")),
+        }
+    }
+
+    pub async fn https_address(&self) -> Result<SocketAddr> {
+        match self.https_handle.listening().await {
+            Some(addr) => Ok(addr),
+            None => Err(anyhow::anyhow!("Failed to bind to https port")),
+        }
+    }
+
+    pub fn shutdown(&self) {
+        self.http_handle.shutdown();
+        self.https_handle.shutdown();
+    }
 }

pubky-homeserver/src/io/mod.rs

@@ -1,6 +1,6 @@
 use ::pkarr::{mainline::Testnet, PublicKey};
 use anyhow::Result;
-use axum_server::Handle;
+use http::HttpServers;
 use pkarr::PkarrServer;
 use tracing::info;
 
@@ -12,7 +12,7 @@ mod pkarr;
 #[derive(Debug)]
 /// Homeserver [Core][HomeserverCore] + I/O (http server and pkarr publishing).
 pub struct Homeserver {
-    handle: Handle,
+    http_servers: HttpServers,
     core: HomeserverCore,
 }
 
@@ -24,24 +24,23 @@ impl Homeserver {
 
         let core = unsafe { HomeserverCore::new(&config)? };
 
-        let handle = http::start(core.clone()).await?;
+        let http_servers = HttpServers::start(&core).await?;
 
-        let port = handle
-            .listening()
-            .await
-            .expect("Homeserver listening")
-            .port();
-
-        info!("Homeserver listening on http://localhost:{port}");
+        info!(
+            "Homeserver listening on http://localhost:{}",
+            http_servers.http_address().await?.port()
+        );
 
         info!("Publishing Pkarr packet..");
 
         let pkarr_server = PkarrServer::new(config)?;
-        pkarr_server.publish_server_packet(port).await?;
+        pkarr_server
+            .publish_server_packet(http_servers.https_address().await?.port())
+            .await?;
 
         info!("Homeserver listening on https://{}", core.public_key());
 
-        Ok(Self { handle, core })
+        Ok(Self { http_servers, core })
     }
 
     /// Test version of [Homeserver::start], using mainline Testnet, and a temporary storage.
@@ -66,6 +65,6 @@ impl Homeserver {
 
     /// Send a shutdown signal to all open resources
     pub fn shutdown(&self) {
-        self.handle.shutdown();
+        self.http_servers.shutdown();
     }
 }