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/context/rpc.rs

@@ -0,0 +1,79 @@
+use std::net::{IpAddr, SocketAddr};
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use bollard::Docker;
+use patch_db::PatchDb;
+use rpc_toolkit::url::Host;
+use rpc_toolkit::Context;
+use serde::Deserialize;
+use sqlx::SqlitePool;
+use tokio::fs::File;
+
+use crate::util::{from_yaml_async_reader, AsyncFileExt};
+use crate::{Error, ResultExt};
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct RpcContextConfig {
+    pub bind: Option<SocketAddr>,
+    pub db: Option<PathBuf>,
+    pub secret_store: Option<PathBuf>,
+}
+pub struct RpcContextSeed {
+    pub bind: SocketAddr,
+    pub db: PatchDb,
+    pub secret_store: SqlitePool,
+    pub docker: Docker,
+}
+
+#[derive(Clone)]
+pub struct RpcContext(Arc<RpcContextSeed>);
+impl RpcContext {
+    pub async fn init() -> Result<Self, Error> {
+        let cfg_path = Path::new(crate::CONFIG_PATH);
+        let base = if let Some(f) = File::maybe_open(cfg_path)
+            .await
+            .with_ctx(|_| (crate::ErrorKind::Filesystem, cfg_path.display().to_string()))?
+        {
+            from_yaml_async_reader(f).await?
+        } else {
+            RpcContextConfig::default()
+        };
+        let seed = Arc::new(RpcContextSeed {
+            bind: base.bind.unwrap_or(([127, 0, 0, 1], 5959).into()),
+            db: PatchDb::open(
+                base.db
+                    .unwrap_or_else(|| Path::new("/mnt/embassy-os/embassy.db").to_owned()),
+            )
+            .await?,
+            secret_store: SqlitePool::connect(&format!(
+                "sqlite://{}",
+                base.secret_store
+                    .unwrap_or_else(|| Path::new("/mnt/embassy-os/secrets.db").to_owned())
+                    .display()
+            ))
+            .await?,
+            docker: Docker::connect_with_unix_defaults()?,
+        });
+        Ok(Self(seed))
+    }
+}
+impl Context for RpcContext {
+    fn host(&self) -> Host<&str> {
+        match self.0.bind.ip() {
+            IpAddr::V4(a) => Host::Ipv4(a),
+            IpAddr::V6(a) => Host::Ipv6(a),
+        }
+    }
+    fn port(&self) -> u16 {
+        self.0.bind.port()
+    }
+}
+impl Deref for RpcContext {
+    type Target = RpcContextSeed;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}