init, shutdown and restart

appmgr/src/context/mod.rs

@@ -1,16 +1,30 @@
 pub mod cli;
+pub mod recovery;
 pub mod rpc;
+pub mod setup;
 
 pub use cli::CliContext;
+pub use recovery::RecoveryContext;
 pub use rpc::RpcContext;
+pub use setup::SetupContext;
 
 impl From<CliContext> for () {
     fn from(_: CliContext) -> Self {
         ()
     }
 }
+impl From<RecoveryContext> for () {
+    fn from(_: RecoveryContext) -> Self {
+        ()
+    }
+}
 impl From<RpcContext> for () {
     fn from(_: RpcContext) -> Self {
         ()
     }
 }
+impl From<SetupContext> for () {
+    fn from(_: SetupContext) -> Self {
+        ()
+    }
+}

appmgr/src/context/recovery.rs

@@ -0,0 +1,73 @@
+use std::net::{IpAddr, SocketAddr};
+use std::ops::Deref;
+use std::path::Path;
+use std::sync::Arc;
+
+use rpc_toolkit::Context;
+use serde::Deserialize;
+use tokio::fs::File;
+use tokio::sync::broadcast::Sender;
+use url::Host;
+
+use crate::util::{from_toml_async_reader, AsyncFileExt};
+use crate::{Error, ResultExt};
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct RecoveryContextConfig {
+    pub bind_rpc: Option<SocketAddr>,
+}
+impl RecoveryContextConfig {
+    pub async fn load<P: AsRef<Path>>(path: Option<P>) -> Result<Self, Error> {
+        let cfg_path = path
+            .as_ref()
+            .map(|p| p.as_ref())
+            .unwrap_or(Path::new(crate::CONFIG_PATH));
+        if let Some(f) = File::maybe_open(cfg_path)
+            .await
+            .with_ctx(|_| (crate::ErrorKind::Filesystem, cfg_path.display().to_string()))?
+        {
+            from_toml_async_reader(f).await
+        } else {
+            Ok(Self::default())
+        }
+    }
+}
+
+pub struct RecoveryContextSeed {
+    pub bind_rpc: SocketAddr,
+    pub shutdown: Sender<()>,
+}
+
+#[derive(Clone)]
+pub struct RecoveryContext(Arc<RecoveryContextSeed>);
+impl RecoveryContext {
+    pub async fn init<P: AsRef<Path>>(path: Option<P>) -> Result<Self, Error> {
+        let cfg = RecoveryContextConfig::load(path).await?;
+
+        let (shutdown, _) = tokio::sync::broadcast::channel(1);
+
+        Ok(Self(Arc::new(RecoveryContextSeed {
+            bind_rpc: cfg.bind_rpc.unwrap_or(([127, 0, 0, 1], 5959).into()),
+            shutdown,
+        })))
+    }
+}
+
+impl Context for RecoveryContext {
+    fn host(&self) -> Host<&str> {
+        match self.0.bind_rpc.ip() {
+            IpAddr::V4(a) => Host::Ipv4(a),
+            IpAddr::V6(a) => Host::Ipv6(a),
+        }
+    }
+    fn port(&self) -> u16 {
+        self.0.bind_rpc.port()
+    }
+}
+impl Deref for RecoveryContext {
+    type Target = RecoveryContextSeed;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}

appmgr/src/context/rpc.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::net::{IpAddr, SocketAddr};
 use std::ops::Deref;
@@ -29,6 +30,7 @@ pub struct RpcContextConfig {
     pub bind_ws: Option<SocketAddr>,
     pub tor_control: Option<SocketAddr>,
     pub revision_cache_size: Option<usize>,
+    pub zfs_pool_name: Option<String>,
     pub datadir: Option<PathBuf>,
 }
 impl RpcContextConfig {
@@ -43,14 +45,20 @@ impl RpcContextConfig {
         {
             from_toml_async_reader(f).await
         } else {
-            Ok(RpcContextConfig::default())
+            Ok(Self::default())
         }
     }
-    pub fn datadir(&self) -> &Path {
+    pub fn zfs_pool_name(&self) -> &str {
+        self.zfs_pool_name
+            .as_ref()
+            .map(|s| s.as_str())
+            .unwrap_or("embassy-data")
+    }
+    pub fn datadir(&self) -> Cow<'_, Path> {
         self.datadir
             .as_ref()
-            .map(|a| a.as_path())
-            .unwrap_or_else(|| Path::new("/embassy-data"))
+            .map(|a| Cow::Borrowed(a.as_path()))
+            .unwrap_or_else(|| Cow::Owned(Path::new("/").join(self.zfs_pool_name())))
     }
     pub async fn db(&self) -> Result<PatchDb, Error> {
         PatchDb::open(self.datadir().join("main").join("embassy.db"))
@@ -78,6 +86,7 @@ pub struct RpcContextSeed {
     pub bind_rpc: SocketAddr,
     pub bind_ws: SocketAddr,
     pub datadir: PathBuf,
+    pub zfs_pool_name: Arc<String>,
     pub db: PatchDb,
     pub secret_store: SqlitePool,
     pub docker: Docker,
@@ -92,11 +101,9 @@ pub struct RpcContextSeed {
 #[derive(Clone)]
 pub struct RpcContext(Arc<RpcContextSeed>);
 impl RpcContext {
-    pub async fn init<P: AsRef<Path>>(
-        cfg_path: Option<P>,
-        shutdown: Sender<Option<Shutdown>>,
-    ) -> Result<Self, Error> {
+    pub async fn init<P: AsRef<Path>>(cfg_path: Option<P>) -> Result<Self, Error> {
         let base = RpcContextConfig::load(cfg_path).await?;
+        let (shutdown, _) = tokio::sync::broadcast::channel(1);
         let db = base.db().await?;
         let secret_store = base.secret_store().await?;
         let docker = Docker::connect_with_unix_defaults()?;
@@ -112,6 +119,7 @@ impl RpcContext {
             bind_rpc: base.bind_rpc.unwrap_or(([127, 0, 0, 1], 5959).into()),
             bind_ws: base.bind_ws.unwrap_or(([127, 0, 0, 1], 5960).into()),
             datadir: base.datadir().to_path_buf(),
+            zfs_pool_name: Arc::new(base.zfs_pool_name().to_owned()),
             db,
             secret_store,
             docker,

appmgr/src/context/setup.rs

@@ -0,0 +1,71 @@
+use std::net::{IpAddr, SocketAddr};
+use std::ops::Deref;
+use std::path::Path;
+use std::sync::Arc;
+
+use rpc_toolkit::Context;
+use serde::Deserialize;
+use tokio::fs::File;
+use tokio::sync::broadcast::Sender;
+use url::Host;
+
+use crate::util::{from_toml_async_reader, AsyncFileExt};
+use crate::{Error, ResultExt};
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct SetupContextConfig {
+    pub bind_rpc: Option<SocketAddr>,
+}
+impl SetupContextConfig {
+    pub async fn load<P: AsRef<Path>>(path: Option<P>) -> Result<Self, Error> {
+        let cfg_path = path
+            .as_ref()
+            .map(|p| p.as_ref())
+            .unwrap_or(Path::new(crate::CONFIG_PATH));
+        if let Some(f) = File::maybe_open(cfg_path)
+            .await
+            .with_ctx(|_| (crate::ErrorKind::Filesystem, cfg_path.display().to_string()))?
+        {
+            from_toml_async_reader(f).await
+        } else {
+            Ok(Self::default())
+        }
+    }
+}
+
+pub struct SetupContextSeed {
+    pub bind_rpc: SocketAddr,
+    pub shutdown: Sender<()>,
+}
+
+#[derive(Clone)]
+pub struct SetupContext(Arc<SetupContextSeed>);
+impl SetupContext {
+    pub async fn init<P: AsRef<Path>>(path: Option<P>) -> Result<Self, Error> {
+        let cfg = SetupContextConfig::load(path).await?;
+        let (shutdown, _) = tokio::sync::broadcast::channel(1);
+        Ok(Self(Arc::new(SetupContextSeed {
+            bind_rpc: cfg.bind_rpc.unwrap_or(([127, 0, 0, 1], 5959).into()),
+            shutdown,
+        })))
+    }
+}
+
+impl Context for SetupContext {
+    fn host(&self) -> Host<&str> {
+        match self.0.bind_rpc.ip() {
+            IpAddr::V4(a) => Host::Ipv4(a),
+            IpAddr::V6(a) => Host::Ipv6(a),
+        }
+    }
+    fn port(&self) -> u16 {
+        self.0.bind_rpc.port()
+    }
+}
+impl Deref for SetupContext {
+    type Target = SetupContextSeed;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}