Feat/combine uis (#2633)

* wip

* restructure backend for new ui structure

* new patchdb bootstrap, single websocket api, local storage migration, more

* update db websocket

* init apis

* update patch-db

* setup progress

* feat: implement state service, alert and routing

Signed-off-by: waterplea <alexander@inkin.ru>

* update setup wizard for new types

* feat: add init page

Signed-off-by: waterplea <alexander@inkin.ru>

* chore: refactor message, patch-db source stream and connection service

Signed-off-by: waterplea <alexander@inkin.ru>

* fix method not found on state

* fix backend bugs

* fix compat assets

* address comments

* remove unneeded styling

* cleaner progress

* bugfixes

* fix init logs

* fix progress reporting

* fix navigation by getting state after init

* remove patch dependency from live api

* fix caching

* re-add patchDB to live api

* fix metrics values

* send close frame

* add bootId and fix polling

---------

Signed-off-by: waterplea <alexander@inkin.ru>
Co-authored-by: Aiden McClelland <me@drbonez.dev>
Co-authored-by: waterplea <alexander@inkin.ru>

core/startos/src/bins/registry.rs

@@ -14,7 +14,8 @@ use crate::util::logger::EmbassyLogger;
 async fn inner_main(config: &RegistryConfig) -> Result<(), Error> {
     let server = async {
         let ctx = RegistryContext::init(config).await?;
-        let server = WebServer::registry(ctx.listen, ctx.clone());
+        let mut server = WebServer::new(ctx.listen);
+        server.serve_registry(ctx.clone());
 
         let mut shutdown_recv = ctx.shutdown.subscribe();
 

core/startos/src/bins/start_init.rs

@@ -1,47 +1,56 @@
-use std::net::{Ipv6Addr, SocketAddr};
-use std::path::Path;
 use std::sync::Arc;
-use std::time::Duration;
 
-use helpers::NonDetachingJoinHandle;
 use tokio::process::Command;
 use tracing::instrument;
 
 use crate::context::config::ServerConfig;
-use crate::context::{DiagnosticContext, InstallContext, SetupContext};
-use crate::disk::fsck::{RepairStrategy, RequiresReboot};
+use crate::context::rpc::InitRpcContextPhases;
+use crate::context::{DiagnosticContext, InitContext, InstallContext, RpcContext, SetupContext};
+use crate::disk::fsck::RepairStrategy;
 use crate::disk::main::DEFAULT_PASSWORD;
 use crate::disk::REPAIR_DISK_PATH;
-use crate::firmware::update_firmware;
-use crate::init::STANDBY_MODE_PATH;
+use crate::firmware::{check_for_firmware_update, update_firmware};
+use crate::init::{InitPhases, InitResult, STANDBY_MODE_PATH};
 use crate::net::web_server::WebServer;
+use crate::prelude::*;
+use crate::progress::FullProgressTracker;
 use crate::shutdown::Shutdown;
-use crate::sound::{BEP, CHIME};
 use crate::util::Invoke;
-use crate::{Error, ErrorKind, ResultExt, PLATFORM};
+use crate::PLATFORM;
 
 #[instrument(skip_all)]
-async fn setup_or_init(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
-    let song = NonDetachingJoinHandle::from(tokio::spawn(async {
-        loop {
-            BEP.play().await.unwrap();
-            BEP.play().await.unwrap();
-            tokio::time::sleep(Duration::from_secs(30)).await;
-        }
-    }));
+async fn setup_or_init(
+    server: &mut WebServer,
+    config: &ServerConfig,
+) -> Result<Result<(RpcContext, FullProgressTracker), Shutdown>, Error> {
+    if let Some(firmware) = check_for_firmware_update()
+        .await
+        .map_err(|e| {
+            tracing::warn!("Error checking for firmware update: {e}");
+            tracing::debug!("{e:?}");
+        })
+        .ok()
+        .and_then(|a| a)
+    {
+        let init_ctx = InitContext::init(config).await?;
+        let handle = &init_ctx.progress;
+        let mut update_phase = handle.add_phase("Updating Firmware".into(), Some(10));
+        let mut reboot_phase = handle.add_phase("Rebooting".into(), Some(1));
 
-    match update_firmware().await {
-        Ok(RequiresReboot(true)) => {
-            return Ok(Some(Shutdown {
-                export_args: None,
-                restart: true,
-            }))
-        }
-        Err(e) => {
+        server.serve_init(init_ctx);
+
+        update_phase.start();
+        if let Err(e) = update_firmware(firmware).await {
             tracing::warn!("Error performing firmware update: {e}");
             tracing::debug!("{e:?}");
+        } else {
+            update_phase.complete();
+            reboot_phase.start();
+            return Ok(Err(Shutdown {
+                export_args: None,
+                restart: true,
+            }));
         }
-        _ => (),
     }
 
     Command::new("ln")
@@ -84,14 +93,7 @@ async fn setup_or_init(config: &ServerConfig) -> Result<Option<Shutdown>, Error>
 
         let ctx = InstallContext::init().await?;
 
-        let server = WebServer::install(
-            SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 80),
-            ctx.clone(),
-        )?;
-
-        drop(song);
-        tokio::time::sleep(Duration::from_secs(1)).await; // let the record state that I hate this
-        CHIME.play().await?;
+        server.serve_install(ctx.clone());
 
         ctx.shutdown
             .subscribe()
@@ -99,33 +101,23 @@ async fn setup_or_init(config: &ServerConfig) -> Result<Option<Shutdown>, Error>
             .await
             .expect("context dropped");
 
-        server.shutdown().await;
+        return Ok(Err(Shutdown {
+            export_args: None,
+            restart: true,
+        }));
+    }
 
-        Command::new("reboot")
-            .invoke(crate::ErrorKind::Unknown)
-            .await?;
-    } else if tokio::fs::metadata("/media/startos/config/disk.guid")
+    if tokio::fs::metadata("/media/startos/config/disk.guid")
         .await
         .is_err()
     {
         let ctx = SetupContext::init(config)?;
 
-        let server = WebServer::setup(
-            SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 80),
-            ctx.clone(),
-        )?;
-
-        drop(song);
-        tokio::time::sleep(Duration::from_secs(1)).await; // let the record state that I hate this
-        CHIME.play().await?;
+        server.serve_setup(ctx.clone());
 
         let mut shutdown = ctx.shutdown.subscribe();
         shutdown.recv().await.expect("context dropped");
 
-        server.shutdown().await;
-
-        drop(shutdown);
-
         tokio::task::yield_now().await;
         if let Err(e) = Command::new("killall")
             .arg("firefox-esr")
@@ -135,19 +127,40 @@ async fn setup_or_init(config: &ServerConfig) -> Result<Option<Shutdown>, Error>
             tracing::error!("Failed to kill kiosk: {}", e);
             tracing::debug!("{:?}", e);
         }
+
+        Ok(Ok(match ctx.result.get() {
+            Some(Ok((_, rpc_ctx))) => (rpc_ctx.clone(), ctx.progress.clone()),
+            Some(Err(e)) => return Err(e.clone_output()),
+            None => {
+                return Err(Error::new(
+                    eyre!("Setup mode exited before setup completed"),
+                    ErrorKind::Unknown,
+                ))
+            }
+        }))
     } else {
+        let init_ctx = InitContext::init(config).await?;
+        let handle = init_ctx.progress.clone();
+
+        let mut disk_phase = handle.add_phase("Opening data drive".into(), Some(10));
+        let init_phases = InitPhases::new(&handle);
+        let rpc_ctx_phases = InitRpcContextPhases::new(&handle);
+
+        server.serve_init(init_ctx);
+
+        disk_phase.start();
         let guid_string = tokio::fs::read_to_string("/media/startos/config/disk.guid") // unique identifier for volume group - keeps track of the disk that goes with your embassy
             .await?;
-        let guid = guid_string.trim();
+        let disk_guid = Arc::new(String::from(guid_string.trim()));
         let requires_reboot = crate::disk::main::import(
-            guid,
+            &**disk_guid,
             config.datadir(),
             if tokio::fs::metadata(REPAIR_DISK_PATH).await.is_ok() {
                 RepairStrategy::Aggressive
             } else {
                 RepairStrategy::Preen
             },
-            if guid.ends_with("_UNENC") {
+            if disk_guid.ends_with("_UNENC") {
                 None
             } else {
                 Some(DEFAULT_PASSWORD)
@@ -159,40 +172,31 @@ async fn setup_or_init(config: &ServerConfig) -> Result<Option<Shutdown>, Error>
                 .await
                 .with_ctx(|_| (crate::ErrorKind::Filesystem, REPAIR_DISK_PATH))?;
         }
-        if requires_reboot.0 {
-            crate::disk::main::export(guid, config.datadir()).await?;
-            Command::new("reboot")
-                .invoke(crate::ErrorKind::Unknown)
-                .await?;
-        }
+        disk_phase.complete();
         tracing::info!("Loaded Disk");
-        crate::init::init(config).await?;
-        drop(song);
-    }
 
-    Ok(None)
-}
-
-async fn run_script_if_exists<P: AsRef<Path>>(path: P) {
-    let script = path.as_ref();
-    if script.exists() {
-        match Command::new("/bin/bash").arg(script).spawn() {
-            Ok(mut c) => {
-                if let Err(e) = c.wait().await {
-                    tracing::error!("Error Running {}: {}", script.display(), e);
-                    tracing::debug!("{:?}", e);
-                }
-            }
-            Err(e) => {
-                tracing::error!("Error Running {}: {}", script.display(), e);
-                tracing::debug!("{:?}", e);
-            }
+        if requires_reboot.0 {
+            let mut reboot_phase = handle.add_phase("Rebooting".into(), Some(1));
+            reboot_phase.start();
+            return Ok(Err(Shutdown {
+                export_args: Some((disk_guid, config.datadir().to_owned())),
+                restart: true,
+            }));
         }
+
+        let InitResult { net_ctrl } = crate::init::init(config, init_phases).await?;
+
+        let rpc_ctx = RpcContext::init(config, disk_guid, Some(net_ctrl), rpc_ctx_phases).await?;
+
+        Ok(Ok((rpc_ctx, handle)))
     }
 }
 
 #[instrument(skip_all)]
-async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
+pub async fn main(
+    server: &mut WebServer,
+    config: &ServerConfig,
+) -> Result<Result<(RpcContext, FullProgressTracker), Shutdown>, Error> {
     if &*PLATFORM == "raspberrypi" && tokio::fs::metadata(STANDBY_MODE_PATH).await.is_ok() {
         tokio::fs::remove_file(STANDBY_MODE_PATH).await?;
         Command::new("sync").invoke(ErrorKind::Filesystem).await?;
@@ -200,16 +204,11 @@ async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
         futures::future::pending::<()>().await;
     }
 
-    crate::sound::BEP.play().await?;
-
-    run_script_if_exists("/media/startos/config/preinit.sh").await;
-
-    let res = match setup_or_init(config).await {
+    let res = match setup_or_init(server, config).await {
         Err(e) => {
             async move {
-                tracing::error!("{}", e.source);
-                tracing::debug!("{}", e.source);
-                crate::sound::BEETHOVEN.play().await?;
+                tracing::error!("{e}");
+                tracing::debug!("{e:?}");
 
                 let ctx = DiagnosticContext::init(
                     config,
@@ -229,44 +228,16 @@ async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
                     e,
                 )?;
 
-                let server = WebServer::diagnostic(
-                    SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 80),
-                    ctx.clone(),
-                )?;
+                server.serve_diagnostic(ctx.clone());
 
                 let shutdown = ctx.shutdown.subscribe().recv().await.unwrap();
 
-                server.shutdown().await;
-
-                Ok(shutdown)
+                Ok(Err(shutdown))
             }
             .await
         }
         Ok(s) => Ok(s),
     };
 
-    run_script_if_exists("/media/startos/config/postinit.sh").await;
-
     res
 }
-
-pub fn main(config: &ServerConfig) {
-    let res = {
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .expect("failed to initialize runtime");
-        rt.block_on(inner_main(config))
-    };
-
-    match res {
-        Ok(Some(shutdown)) => shutdown.execute(),
-        Ok(None) => (),
-        Err(e) => {
-            eprintln!("{}", e.source);
-            tracing::debug!("{:?}", e.source);
-            drop(e.source);
-            std::process::exit(e.kind as i32)
-        }
-    }
-}

core/startos/src/bins/startd.rs

@@ -1,6 +1,5 @@
 use std::ffi::OsString;
 use std::net::{Ipv6Addr, SocketAddr};
-use std::path::Path;
 use std::sync::Arc;
 
 use clap::Parser;
@@ -10,7 +9,8 @@ use tokio::signal::unix::signal;
 use tracing::instrument;
 
 use crate::context::config::ServerConfig;
-use crate::context::{DiagnosticContext, RpcContext};
+use crate::context::rpc::InitRpcContextPhases;
+use crate::context::{DiagnosticContext, InitContext, RpcContext};
 use crate::net::web_server::WebServer;
 use crate::shutdown::Shutdown;
 use crate::system::launch_metrics_task;
@@ -18,9 +18,31 @@ use crate::util::logger::EmbassyLogger;
 use crate::{Error, ErrorKind, ResultExt};
 
 #[instrument(skip_all)]
-async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
-    let (rpc_ctx, server, shutdown) = async {
-        let rpc_ctx = RpcContext::init(
+async fn inner_main(
+    server: &mut WebServer,
+    config: &ServerConfig,
+) -> Result<Option<Shutdown>, Error> {
+    let rpc_ctx = if !tokio::fs::metadata("/run/startos/initialized")
+        .await
+        .is_ok()
+    {
+        let (ctx, handle) = match super::start_init::main(server, &config).await? {
+            Err(s) => return Ok(Some(s)),
+            Ok(ctx) => ctx,
+        };
+        tokio::fs::write("/run/startos/initialized", "").await?;
+
+        server.serve_main(ctx.clone());
+        handle.complete();
+
+        ctx
+    } else {
+        let init_ctx = InitContext::init(config).await?;
+        let handle = init_ctx.progress.clone();
+        let rpc_ctx_phases = InitRpcContextPhases::new(&handle);
+        server.serve_init(init_ctx);
+
+        let ctx = RpcContext::init(
             config,
             Arc::new(
                 tokio::fs::read_to_string("/media/startos/config/disk.guid") // unique identifier for volume group - keeps track of the disk that goes with your embassy
@@ -28,13 +50,19 @@ async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
                     .trim()
                     .to_owned(),
             ),
+            None,
+            rpc_ctx_phases,
         )
         .await?;
+
+        server.serve_main(ctx.clone());
+        handle.complete();
+
+        ctx
+    };
+
+    let (rpc_ctx, shutdown) = async {
         crate::hostname::sync_hostname(&rpc_ctx.account.read().await.hostname).await?;
-        let server = WebServer::main(
-            SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 80),
-            rpc_ctx.clone(),
-        )?;
 
         let mut shutdown_recv = rpc_ctx.shutdown.subscribe();
 
@@ -74,8 +102,6 @@ async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
             .await
         });
 
-        crate::sound::CHIME.play().await?;
-
         metrics_task
             .map_err(|e| {
                 Error::new(
@@ -93,10 +119,9 @@ async fn inner_main(config: &ServerConfig) -> Result<Option<Shutdown>, Error> {
 
         sig_handler.abort();
 
-        Ok::<_, Error>((rpc_ctx, server, shutdown))
+        Ok::<_, Error>((rpc_ctx, shutdown))
     }
     .await?;
-    server.shutdown().await;
     rpc_ctx.shutdown().await?;
 
     tracing::info!("RPC Context is dropped");
@@ -109,24 +134,22 @@ pub fn main(args: impl IntoIterator<Item = OsString>) {
 
     let config = ServerConfig::parse_from(args).load().unwrap();
 
-    if !Path::new("/run/embassy/initialized").exists() {
-        super::start_init::main(&config);
-        std::fs::write("/run/embassy/initialized", "").unwrap();
-    }
-
     let res = {
         let rt = tokio::runtime::Builder::new_multi_thread()
             .enable_all()
             .build()
             .expect("failed to initialize runtime");
         rt.block_on(async {
-            match inner_main(&config).await {
-                Ok(a) => Ok(a),
+            let mut server = WebServer::new(SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 80));
+            match inner_main(&mut server, &config).await {
+                Ok(a) => {
+                    server.shutdown().await;
+                    Ok(a)
+                }
                 Err(e) => {
                     async {
-                        tracing::error!("{}", e.source);
-                        tracing::debug!("{:?}", e.source);
-                        crate::sound::BEETHOVEN.play().await?;
+                        tracing::error!("{e}");
+                        tracing::debug!("{e:?}");
                         let ctx = DiagnosticContext::init(
                             &config,
                             if tokio::fs::metadata("/media/startos/config/disk.guid")
@@ -145,10 +168,7 @@ pub fn main(args: impl IntoIterator<Item = OsString>) {
                             e,
                         )?;
 
-                        let server = WebServer::diagnostic(
-                            SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 80),
-                            ctx.clone(),
-                        )?;
+                        server.serve_diagnostic(ctx.clone());
 
                         let mut shutdown = ctx.shutdown.subscribe();
 
@@ -157,7 +177,7 @@ pub fn main(args: impl IntoIterator<Item = OsString>) {
 
                         server.shutdown().await;
 
-                        Ok::<_, Error>(shutdown)
+                        Ok::<_, Error>(Some(shutdown))
                     }
                     .await
                 }