Strict null checks

.gitignore

@@ -8,3 +8,6 @@
 /product_key.txt
 /*_product_key.txt
 .vscode/settings.json
+deploy_web.sh
+libs/js_engine/src/artifacts/ARM_JS_SNAPSHOT.bin
+libs/js_engine/src/artifacts/JS_SNAPSHOT.bin

Makefile

@@ -29,8 +29,8 @@ clean:
 	rm -rf patch-db/client/node_modules
 	rm -rf patch-db/client/dist
 
-	rm libs/js_engine/src/artifacts/ARM_JS_SNAPSHOT.bin
-	rm libs/js_engine/src/artifacts/JS_SNAPSHOT.bin
+	rm -f libs/js_engine/src/artifacts/ARM_JS_SNAPSHOT.bin
+	rm -f libs/js_engine/src/artifacts/JS_SNAPSHOT.bin
 	touch libs/snapshot-creator/Cargo.toml
 
 eos.img: $(EMBASSY_SRC) system-images/compat/compat.tar system-images/utils/utils.tar $(EMBASSY_V8_SNAPSHOTS)

backend/src/backup/backup_bulk.rs

@@ -268,9 +268,11 @@ async fn perform_backup<Db: DbHandle>(
 
         main_status_model.lock(&mut tx, LockType::Write).await?;
         let (started, health) = match main_status_model.get(&mut tx, true).await?.into_owned() {
-            MainStatus::Starting => (Some(Utc::now()), Default::default()),
+            MainStatus::Starting { .. } => (Some(Utc::now()), Default::default()),
             MainStatus::Running { started, health } => (Some(started), health.clone()),
-            MainStatus::Stopped | MainStatus::Stopping => (None, Default::default()),
+            MainStatus::Stopped | MainStatus::Stopping | MainStatus::Restarting => {
+                (None, Default::default())
+            }
             MainStatus::BackingUp { .. } => {
                 backup_report.insert(
                     package_id,

backend/src/context/rpc.rs

@@ -335,12 +335,14 @@ impl RpcContext {
                         let main = match status.main {
                             MainStatus::BackingUp { started, .. } => {
                                 if let Some(_) = started {
-                                    MainStatus::Starting
+                                    MainStatus::Starting { restarting: false }
                                 } else {
                                     MainStatus::Stopped
                                 }
                             }
-                            MainStatus::Running { .. } => MainStatus::Starting,
+                            MainStatus::Running { .. } => {
+                                MainStatus::Starting { restarting: false }
+                            }
                             a => a.clone(),
                         };
                         let new_package = PackageDataEntry::Installed {

backend/src/control.rs

@@ -71,7 +71,10 @@ pub async fn start(
     let mut tx = db.begin().await?;
     let receipts = StartReceipts::new(&mut tx, &id).await?;
     let version = receipts.version.get(&mut tx).await?;
-    receipts.status.set(&mut tx, MainStatus::Starting).await?;
+    receipts
+        .status
+        .set(&mut tx, MainStatus::Starting { restarting: false })
+        .await?;
     heal_all_dependents_transitive(&ctx, &mut tx, &id, &receipts.dependency_receipt).await?;
 
     let revision = tx.commit(None).await?;
@@ -181,3 +184,33 @@ pub async fn stop_impl(ctx: RpcContext, id: PackageId) -> Result<WithRevision<()
         response: (),
     })
 }
+
+#[command(display(display_none))]
+pub async fn restart(
+    #[context] ctx: RpcContext,
+    #[arg] id: PackageId,
+) -> Result<WithRevision<()>, Error> {
+    let mut db = ctx.db.handle();
+    let mut tx = db.begin().await?;
+
+    let mut status = crate::db::DatabaseModel::new()
+        .package_data()
+        .idx_model(&id)
+        .and_then(|pde| pde.installed())
+        .map(|i| i.status().main())
+        .get_mut(&mut tx)
+        .await?;
+    if !matches!(&*status, Some(MainStatus::Running { .. })) {
+        return Err(Error::new(
+            eyre!("{} is not running", id),
+            crate::ErrorKind::InvalidRequest,
+        ));
+    }
+    *status = Some(MainStatus::Restarting);
+    status.save(&mut tx).await?;
+
+    Ok(WithRevision {
+        revision: tx.commit(None).await?,
+        response: (),
+    })
+}

backend/src/dependencies.rs

@@ -14,22 +14,19 @@ use rpc_toolkit::command;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
+use crate::config::action::{ConfigActions, ConfigRes};
 use crate::config::spec::PackagePointerSpec;
 use crate::config::{not_found, Config, ConfigReceipts, ConfigSpec};
 use crate::context::RpcContext;
 use crate::db::model::{CurrentDependencies, CurrentDependents, InstalledPackageDataEntry};
-use crate::procedure::{NoOutput, PackageProcedure};
+use crate::procedure::{NoOutput, PackageProcedure, ProcedureName};
 use crate::s9pk::manifest::{Manifest, PackageId};
 use crate::status::health_check::{HealthCheckId, HealthCheckResult};
 use crate::status::{MainStatus, Status};
 use crate::util::serde::display_serializable;
 use crate::util::{display_none, Version};
 use crate::volume::Volumes;
 use crate::Error;
-use crate::{
-    config::action::{ConfigActions, ConfigRes},
-    procedure::ProcedureName,
-};
 
 #[command(subcommands(configure))]
 pub fn dependency() -> Result<(), Error> {
@@ -339,7 +336,7 @@ impl DependencyError {
                                     .await?
                             }
                         }
-                        MainStatus::Starting => {
+                        MainStatus::Starting { .. } | MainStatus::Restarting => {
                             DependencyError::Transitive
                                 .try_heal(
                                     ctx,

backend/src/lib.rs

@@ -99,6 +99,7 @@ pub fn server() -> Result<(), RpcError> {
     config::config,
     control::start,
     control::stop,
+    control::restart,
     logs::logs,
     properties::properties,
     dependencies::dependency,

backend/src/manager/sync.rs

@@ -31,7 +31,10 @@ async fn synchronize_once(shared: &ManagerSharedState) -> Result<Status, Error>
             MainStatus::Stopping => {
                 *status = MainStatus::Stopped;
             }
-            MainStatus::Starting => {
+            MainStatus::Restarting => {
+                *status = MainStatus::Starting { restarting: true };
+            }
+            MainStatus::Starting { .. } => {
                 start(shared).await?;
             }
             MainStatus::Running { started, .. } => {
@@ -41,19 +44,19 @@ async fn synchronize_once(shared: &ManagerSharedState) -> Result<Status, Error>
             MainStatus::BackingUp { .. } => (),
         },
         Status::Starting => match *status {
-            MainStatus::Stopped | MainStatus::Stopping => {
+            MainStatus::Stopped | MainStatus::Stopping | MainStatus::Restarting => {
                 stop(shared).await?;
             }
-            MainStatus::Starting | MainStatus::Running { .. } => (),
+            MainStatus::Starting { .. } | MainStatus::Running { .. } => (),
             MainStatus::BackingUp { .. } => {
                 pause(shared).await?;
             }
         },
         Status::Running => match *status {
-            MainStatus::Stopped | MainStatus::Stopping => {
+            MainStatus::Stopped | MainStatus::Stopping | MainStatus::Restarting => {
                 stop(shared).await?;
             }
-            MainStatus::Starting => {
+            MainStatus::Starting { .. } => {
                 *status = MainStatus::Running {
                     started: Utc::now(),
                     health: BTreeMap::new(),
@@ -65,10 +68,10 @@ async fn synchronize_once(shared: &ManagerSharedState) -> Result<Status, Error>
             }
         },
         Status::Paused => match *status {
-            MainStatus::Stopped | MainStatus::Stopping => {
+            MainStatus::Stopped | MainStatus::Stopping | MainStatus::Restarting => {
                 stop(shared).await?;
             }
-            MainStatus::Starting | MainStatus::Running { .. } => {
+            MainStatus::Starting { .. } | MainStatus::Running { .. } => {
                 resume(shared).await?;
             }
             MainStatus::BackingUp { .. } => (),

backend/src/status/mod.rs

@@ -24,8 +24,11 @@ pub struct Status {
 #[serde(rename_all = "kebab-case")]
 pub enum MainStatus {
     Stopped,
+    Restarting,
     Stopping,
-    Starting,
+    Starting {
+        restarting: bool,
+    },
     Running {
         started: DateTime<Utc>,
         health: BTreeMap<HealthCheckId, HealthCheckResult>,
@@ -38,25 +41,26 @@ pub enum MainStatus {
 impl MainStatus {
     pub fn running(&self) -> bool {
         match self {
-            MainStatus::Starting
+            MainStatus::Starting { .. }
             | MainStatus::Running { .. }
             | MainStatus::BackingUp {
                 started: Some(_), ..
             } => true,
             MainStatus::Stopped
             | MainStatus::Stopping
+            | MainStatus::Restarting
             | MainStatus::BackingUp { started: None, .. } => false,
         }
     }
     pub fn stop(&mut self) {
         match self {
-            MainStatus::Starting | MainStatus::Running { .. } => {
+            MainStatus::Starting { .. } | MainStatus::Running { .. } => {
                 *self = MainStatus::Stopping;
             }
             MainStatus::BackingUp { started, .. } => {
                 *started = None;
             }
-            MainStatus::Stopped | MainStatus::Stopping => (),
+            MainStatus::Stopped | MainStatus::Stopping | MainStatus::Restarting => (),
         }
     }
 }

frontend/README.md

@@ -58,12 +58,12 @@ npm run start:diagnostic-ui
 
 This section enables you to run a local frontend with a remote backend (eg. hosted on a live Embassy). It assumes you have completed Step 1 and Step 2 in the [section above](#running-locally-with-mocks)
 
-1. Set `useMocks: true` in `config.json`
+1. Set `useMocks: false` in `config.json`
 
 2. Create a proxy configuration file from the sample:
 
 ```sh
-cp proxy.conf.json.sample proxy.conf.json
+cp proxy.conf-sample.json proxy.conf.json
 ```
 
 3. Change the target address to desired IP address in `proxy.conf.json`