appmgr 0.3.0 rewrite pt 1

appmgr: split bins

update cargo.toml and .gitignore

context

appmgr: refactor error module

appmgr: context

begin new s9pk format

appmgr: add fields to manifest

appmgr: start action abstraction

appmgr: volume abstraction

appmgr: improved volumes

appmgr: install wip

appmgr: health daemon

appmgr: health checks

appmgr: wip

config get

appmgr: secret store

wip

appmgr: config rewritten

appmgr: delete non-reusable code

appmgr: wip

appmgr: please the borrow-checker

appmgr: technically runs now

appmgr: cli

appmgr: clean up cli

appmgr: rpc-toolkit in action

appmgr: wrap up config

appmgr: account for updates during install

appmgr: fix: #308

appmgr: impl Display for Version

appmgr: cleanup

appmgr: set dependents on install

appmgr: dependency health checks

appmgr/src/migration.rs

@@ -0,0 +1,80 @@
+use anyhow::anyhow;
+use emver::VersionRange;
+use indexmap::{IndexMap, IndexSet};
+use patch_db::HasModel;
+use serde::{Deserialize, Serialize};
+
+use crate::action::ActionImplementation;
+use crate::net::host::Hosts;
+use crate::s9pk::manifest::PackageId;
+use crate::status::health_check::HealthCheckId;
+use crate::util::Version;
+use crate::volume::Volumes;
+use crate::Error;
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize, HasModel)]
+#[serde(rename_all = "kebab-case")]
+pub struct Migrations {
+    pub from: IndexMap<VersionRange, ActionImplementation>,
+    pub to: IndexMap<VersionRange, ActionImplementation>,
+}
+impl Migrations {
+    pub async fn from(
+        &self,
+        version: &Version,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        volumes: &Volumes,
+        hosts: &Hosts,
+    ) -> Result<Option<MigrationRes>, Error> {
+        Ok(
+            if let Some((_, migration)) = self
+                .from
+                .iter()
+                .find(|(range, _)| version.satisfies(*range))
+            {
+                Some(
+                    migration
+                        .execute(pkg_id, pkg_version, volumes, hosts, Some(version), false)
+                        .await?
+                        .map_err(|e| {
+                            Error::new(anyhow!("{}", e.1), crate::ErrorKind::MigrationFailed)
+                        })?,
+                )
+            } else {
+                None
+            },
+        )
+    }
+    pub async fn to(
+        &self,
+        version: &Version,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        volumes: &Volumes,
+        hosts: &Hosts,
+    ) -> Result<Option<MigrationRes>, Error> {
+        Ok(
+            if let Some((_, migration)) =
+                self.to.iter().find(|(range, _)| version.satisfies(*range))
+            {
+                Some(
+                    migration
+                        .execute(pkg_id, pkg_version, volumes, hosts, Some(version), false)
+                        .await?
+                        .map_err(|e| {
+                            Error::new(anyhow!("{}", e.1), crate::ErrorKind::MigrationFailed)
+                        })?,
+                )
+            } else {
+                None
+            },
+        )
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize, HasModel)]
+#[serde(rename_all = "kebab-case")]
+pub struct MigrationRes {
+    pub configured: bool,
+}