Merge branch 'next/minor' of github.com:Start9Labs/start-os into next/major

core/startos/src/context/setup.rs

@@ -1,5 +1,5 @@
 use std::ops::Deref;
-use std::path::PathBuf;
+use std::path::Path;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -10,8 +10,6 @@ use josekit::jwk::Jwk;
 use patch_db::PatchDb;
 use rpc_toolkit::Context;
 use serde::{Deserialize, Serialize};
-use sqlx::postgres::PgConnectOptions;
-use sqlx::PgPool;
 use tokio::sync::broadcast::Sender;
 use tokio::sync::OnceCell;
 use tracing::instrument;
@@ -22,12 +20,13 @@ use crate::context::config::ServerConfig;
 use crate::context::RpcContext;
 use crate::disk::OsPartitionInfo;
 use crate::hostname::Hostname;
-use crate::init::init_postgres;
+use crate::net::web_server::{UpgradableListener, WebServer, WebServerAcceptorSetter};
 use crate::prelude::*;
 use crate::progress::FullProgressTracker;
 use crate::rpc_continuations::{Guid, RpcContinuation, RpcContinuations};
 use crate::setup::SetupProgress;
 use crate::util::net::WebSocketExt;
+use crate::MAIN_DATA;
 
 lazy_static::lazy_static! {
     pub static ref CURRENT_SECRET: Jwk = Jwk::generate_ec_key(josekit::jwk::alg::ec::EcCurve::P256).unwrap_or_else(|e| {
@@ -41,7 +40,7 @@ lazy_static::lazy_static! {
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 pub struct SetupResult {
-    pub tor_address: String,
+    pub tor_addresses: Vec<String>,
     #[ts(type = "string")]
     pub hostname: Hostname,
     #[ts(type = "string")]
@@ -52,7 +51,11 @@ impl TryFrom<&AccountInfo> for SetupResult {
     type Error = Error;
     fn try_from(value: &AccountInfo) -> Result<Self, Self::Error> {
         Ok(Self {
-            tor_address: format!("https://{}", value.tor_key.public().get_onion_address()),
+            tor_addresses: value
+                .tor_keys
+                .iter()
+                .map(|tor_key| format!("https://{}", tor_key.public().get_onion_address()))
+                .collect(),
             hostname: value.hostname.clone(),
             lan_address: value.hostname.lan_address(),
             root_ca: String::from_utf8(value.root_ca_cert.to_pem()?)?,
@@ -61,6 +64,7 @@ impl TryFrom<&AccountInfo> for SetupResult {
 }
 
 pub struct SetupContextSeed {
+    pub webserver: WebServerAcceptorSetter<UpgradableListener>,
     pub config: ServerConfig,
     pub os_partitions: OsPartitionInfo,
     pub disable_encryption: bool,
@@ -68,7 +72,6 @@ pub struct SetupContextSeed {
     pub task: OnceCell<NonDetachingJoinHandle<()>>,
     pub result: OnceCell<Result<(SetupResult, RpcContext), Error>>,
     pub shutdown: Sender<()>,
-    pub datadir: PathBuf,
     pub rpc_continuations: RpcContinuations,
 }
 
@@ -76,10 +79,13 @@ pub struct SetupContextSeed {
 pub struct SetupContext(Arc<SetupContextSeed>);
 impl SetupContext {
     #[instrument(skip_all)]
-    pub fn init(config: &ServerConfig) -> Result<Self, Error> {
+    pub fn init(
+        webserver: &WebServer<UpgradableListener>,
+        config: &ServerConfig,
+    ) -> Result<Self, Error> {
         let (shutdown, _) = tokio::sync::broadcast::channel(1);
-        let datadir = config.datadir().to_owned();
         Ok(Self(Arc::new(SetupContextSeed {
+            webserver: webserver.acceptor_setter(),
             config: config.clone(),
             os_partitions: config.os_partitions.clone().ok_or_else(|| {
                 Error::new(
@@ -92,13 +98,12 @@ impl SetupContext {
             task: OnceCell::new(),
             result: OnceCell::new(),
             shutdown,
-            datadir,
             rpc_continuations: RpcContinuations::new(),
         })))
     }
     #[instrument(skip_all)]
     pub async fn db(&self) -> Result<PatchDb, Error> {
-        let db_path = self.datadir.join("main").join("embassy.db");
+        let db_path = Path::new(MAIN_DATA).join("embassy.db");
         let db = PatchDb::open(&db_path)
             .await
             .with_ctx(|_| (crate::ErrorKind::Filesystem, db_path.display().to_string()))?;
@@ -161,21 +166,30 @@ impl SetupContext {
                         if let Err(e) = async {
                             let mut stream =
                                 progress_tracker.stream(Some(Duration::from_millis(100)));
-                            while let Some(progress) = stream.next().await {
-                                ws.send(ws::Message::Text(
-                                    serde_json::to_string(&progress)
-                                        .with_kind(ErrorKind::Serialization)?,
-                                ))
-                                .await
-                                .with_kind(ErrorKind::Network)?;
-                                if progress.overall.is_complete() {
-                                    break;
+                            loop {
+                                tokio::select! {
+                                    progress = stream.next() => {
+                                        if let Some(progress) = progress {
+                                            ws.send(ws::Message::Text(
+                                                serde_json::to_string(&progress)
+                                                    .with_kind(ErrorKind::Serialization)?,
+                                            ))
+                                            .await
+                                            .with_kind(ErrorKind::Network)?;
+                                            if progress.overall.is_complete() {
+                                                return ws.normal_close("complete").await;
+                                            }
+                                        } else {
+                                            return ws.normal_close("complete").await;
+                                        }
+                                    }
+                                    msg = ws.recv() => {
+                                        if msg.transpose().with_kind(ErrorKind::Network)?.is_none() {
+                                            return Ok(())
+                                        }
+                                    }
                                 }
                             }
-
-                            ws.normal_close("complete").await?;
-
-                            Ok::<_, Error>(())
                         }
                         .await
                         {