Fix/backups (#2659)

* fix master build (#2639)

* feat: Change ts to use rsync
Chore: Update the ts to use types over interface

* feat: Get the rust and the js to do a backup

* Wip: Got the backup working?

* fix permissions

* remove trixie list

* update tokio to fix timer bug

* fix error handling on backup

* wip

* remove idmap

* run restore before init, and init with own version on restore

---------

Co-authored-by: Aiden McClelland <3732071+dr-bonez@users.noreply.github.com>
Co-authored-by: Aiden McClelland <me@drbonez.dev>

core/startos/src/service/mod.rs

@@ -34,6 +34,7 @@ use crate::util::actor::concurrent::ConcurrentActor;
 use crate::util::actor::Actor;
 use crate::util::io::create_file;
 use crate::util::serde::Pem;
+use crate::util::Never;
 use crate::volume::data_dir;
 
 mod action;
@@ -220,12 +221,13 @@ impl Service {
                         tracing::error!("Error opening s9pk for install: {e}");
                         tracing::debug!("{e:?}")
                     }) {
-                        if let Ok(service) = Self::install(ctx.clone(), s9pk, None, None)
-                            .await
-                            .map_err(|e| {
-                                tracing::error!("Error installing service: {e}");
-                                tracing::debug!("{e:?}")
-                            })
+                        if let Ok(service) =
+                            Self::install(ctx.clone(), s9pk, None, None::<Never>, None)
+                                .await
+                                .map_err(|e| {
+                                    tracing::error!("Error installing service: {e}");
+                                    tracing::debug!("{e:?}")
+                                })
                         {
                             return Ok(Some(service));
                         }
@@ -257,6 +259,7 @@ impl Service {
                             ctx.clone(),
                             s9pk,
                             Some(s.as_manifest().as_version().de()?),
+                            None::<Never>,
                             None,
                         )
                         .await
@@ -334,13 +337,35 @@ impl Service {
     pub async fn install(
         ctx: RpcContext,
         s9pk: S9pk,
-        src_version: Option<models::VersionString>,
+        mut src_version: Option<models::VersionString>,
+        recovery_source: Option<impl GenericMountGuard>,
         progress: Option<InstallProgressHandles>,
     ) -> Result<ServiceRef, Error> {
         let manifest = s9pk.as_manifest().clone();
         let developer_key = s9pk.as_archive().signer();
         let icon = s9pk.icon_data_url().await?;
         let service = Self::new(ctx.clone(), s9pk, StartStop::Stop).await?;
+        if let Some(recovery_source) = recovery_source {
+            service
+                .actor
+                .send(
+                    Guid::new(),
+                    transition::restore::Restore {
+                        path: recovery_source.path().to_path_buf(),
+                    },
+                )
+                .await??;
+            recovery_source.unmount().await?;
+            src_version = Some(
+                service
+                    .seed
+                    .persistent_container
+                    .s9pk
+                    .as_manifest()
+                    .version
+                    .clone(),
+            );
+        }
         service
             .seed
             .persistent_container
@@ -382,26 +407,6 @@ impl Service {
         Ok(service)
     }
 
-    pub async fn restore(
-        ctx: RpcContext,
-        s9pk: S9pk,
-        backup_source: impl GenericMountGuard,
-        progress: Option<InstallProgressHandles>,
-    ) -> Result<ServiceRef, Error> {
-        let service = Service::install(ctx.clone(), s9pk, None, progress).await?;
-
-        service
-            .actor
-            .send(
-                Guid::new(),
-                transition::restore::Restore {
-                    path: backup_source.path().to_path_buf(),
-                },
-            )
-            .await??;
-        Ok(service)
-    }
-
     #[instrument(skip_all)]
     pub async fn backup(&self, guard: impl GenericMountGuard) -> Result<(), Error> {
         let id = &self.seed.id;
@@ -417,10 +422,11 @@ impl Service {
             .send(
                 Guid::new(),
                 transition::backup::Backup {
-                    path: guard.path().to_path_buf(),
+                    path: guard.path().join("data"),
                 },
             )
-            .await??;
+            .await??
+            .await?;
         Ok(())
     }
 
@@ -505,13 +511,21 @@ impl Actor for ServiceActor {
                         }
                         (Some(TransitionKind::Restarting), _, _) => MainStatus::Restarting,
                         (Some(TransitionKind::Restoring), _, _) => MainStatus::Restoring,
-                        (Some(TransitionKind::BackingUp), _, Some(status)) => {
+                        (Some(TransitionKind::BackingUp), StartStop::Stop, Some(status)) => {
+                            seed.persistent_container.stop().await?;
                             MainStatus::BackingUp {
                                 started: Some(status.started),
                                 health: status.health.clone(),
                             }
                         }
-                        (Some(TransitionKind::BackingUp), _, None) => MainStatus::BackingUp {
+                        (Some(TransitionKind::BackingUp), StartStop::Start, _) => {
+                            seed.persistent_container.start().await?;
+                            MainStatus::BackingUp {
+                                started: None,
+                                health: OrdMap::new(),
+                            }
+                        }
+                        (Some(TransitionKind::BackingUp), _, _) => MainStatus::BackingUp {
                             started: None,
                             health: OrdMap::new(),
                         },