setup flow mvp complete

appmgr/src/disk/main.rs

@@ -3,49 +3,57 @@ use std::path::Path;
 use anyhow::anyhow;
 use tokio::process::Command;
 
-use crate::context::rpc::RpcContextConfig;
 use crate::util::Invoke;
 use crate::{Error, ResultExt};
 
 pub const PASSWORD_PATH: &'static str = "/etc/embassy/password";
+pub const DEFAULT_PASSWORD: &'static str = "password";
 
-pub async fn create(
-    cfg: &RpcContextConfig,
-    disks: &[&str],
+pub async fn create<I: IntoIterator<Item = P>, P: AsRef<Path>>(
+    pool_name: &str,
+    disks: I,
     password: &str,
 ) -> Result<String, Error> {
-    let guid = create_pool(cfg, disks).await?;
-    create_fs(cfg, password).await?;
-    export(cfg).await?;
+    let guid = create_pool(pool_name, disks).await?;
+    create_fs(pool_name, password).await?;
+    export(pool_name).await?;
     Ok(guid)
 }
 
-pub async fn load(cfg: &RpcContextConfig, guid: &str, password: &str) -> Result<(), Error> {
+pub async fn load<P: AsRef<Path>>(
+    guid: &str,
+    pool_name: &str,
+    datadir: P,
+    password: &str,
+) -> Result<(), Error> {
     import(guid).await?;
-    mount(cfg, password).await?;
+    mount(pool_name, datadir, password).await?;
     Ok(())
 }
 
-pub async fn create_pool(cfg: &RpcContextConfig, disks: &[&str]) -> Result<String, Error> {
-    Command::new("zpool")
-        .arg("create")
-        .arg(cfg.zfs_pool_name())
-        .args(disks)
-        .invoke(crate::ErrorKind::Zfs)
-        .await?;
+pub async fn create_pool<I: IntoIterator<Item = P>, P: AsRef<Path>>(
+    pool_name: &str,
+    disks: I,
+) -> Result<String, Error> {
+    let mut cmd = Command::new("zpool");
+    cmd.arg("create").arg(pool_name);
+    for disk in disks {
+        cmd.arg(disk.as_ref());
+    }
+    cmd.invoke(crate::ErrorKind::Zfs).await?;
     Ok(String::from_utf8(
         Command::new("zpool")
             .arg("get")
             .arg("-H")
             .arg("-ovalue")
             .arg("guid")
-            .arg(cfg.zfs_pool_name())
+            .arg(pool_name)
             .invoke(crate::ErrorKind::Zfs)
             .await?,
     )?)
 }
 
-pub async fn create_fs(cfg: &RpcContextConfig, password: &str) -> Result<(), Error> {
+pub async fn create_fs(pool_name: &str, password: &str) -> Result<(), Error> {
     tokio::fs::write(PASSWORD_PATH, password)
         .await
         .with_ctx(|_| (crate::ErrorKind::Filesystem, PASSWORD_PATH))?;
@@ -59,14 +67,14 @@ pub async fn create_fs(cfg: &RpcContextConfig, password: &str) -> Result<(), Err
         .arg("keylocation=file:///etc/embassy/password")
         .arg("-o")
         .arg("keyformat=passphrase")
-        .arg(format!("{}/main", cfg.zfs_pool_name()))
+        .arg(format!("{}/main", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
         .arg("create")
         .arg("-o")
         .arg("reservation=5G")
-        .arg(format!("{}/updates", cfg.zfs_pool_name()))
+        .arg(format!("{}/updates", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
@@ -77,7 +85,7 @@ pub async fn create_fs(cfg: &RpcContextConfig, password: &str) -> Result<(), Err
         .arg("keylocation=file:///etc/embassy/password")
         .arg("-o")
         .arg("keyformat=passphrase")
-        .arg(format!("{}/package-data", cfg.zfs_pool_name()))
+        .arg(format!("{}/package-data", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
@@ -88,7 +96,7 @@ pub async fn create_fs(cfg: &RpcContextConfig, password: &str) -> Result<(), Err
         .arg("keylocation=file:///etc/embassy/password")
         .arg("-o")
         .arg("keyformat=passphrase")
-        .arg(format!("{}/tmp", cfg.zfs_pool_name()))
+        .arg(format!("{}/tmp", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     tokio::fs::remove_file(PASSWORD_PATH)
@@ -97,7 +105,7 @@ pub async fn create_fs(cfg: &RpcContextConfig, password: &str) -> Result<(), Err
     Ok(())
 }
 
-pub async fn create_swap(cfg: &RpcContextConfig) -> Result<(), Error> {
+pub async fn create_swap(pool_name: &str) -> Result<(), Error> {
     let pagesize = String::from_utf8(
         Command::new("getconf")
             .arg("PAGESIZE")
@@ -121,32 +129,24 @@ pub async fn create_swap(cfg: &RpcContextConfig) -> Result<(), Error> {
         .await?;
     Command::new("mkswap")
         .arg("-f")
-        .arg(
-            Path::new("/dev/zvol")
-                .join(cfg.zfs_pool_name())
-                .join("swap"),
-        )
+        .arg(Path::new("/dev/zvol").join(pool_name).join("swap"))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Ok(())
 }
 
-pub async fn use_swap(cfg: &RpcContextConfig) -> Result<(), Error> {
+pub async fn use_swap(pool_name: &str) -> Result<(), Error> {
     Command::new("swapon")
-        .arg(
-            Path::new("/dev/zvol")
-                .join(cfg.zfs_pool_name())
-                .join("swap"),
-        )
+        .arg(Path::new("/dev/zvol").join(pool_name).join("swap"))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Ok(())
 }
 
-pub async fn export(cfg: &RpcContextConfig) -> Result<(), Error> {
+pub async fn export(pool_name: &str) -> Result<(), Error> {
     Command::new("zpool")
         .arg("export")
-        .arg(cfg.zfs_pool_name())
+        .arg(pool_name)
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Ok(())
@@ -178,22 +178,26 @@ pub async fn import(guid: &str) -> Result<(), Error> {
     Ok(())
 }
 
-pub async fn mount(cfg: &RpcContextConfig, password: &str) -> Result<(), Error> {
+pub async fn mount<P: AsRef<Path>>(
+    pool_name: &str,
+    datadir: P,
+    password: &str,
+) -> Result<(), Error> {
     let mountpoint = String::from_utf8(
         Command::new("zfs")
             .arg("get")
             .arg("-H")
             .arg("-ovalue")
             .arg("mountpoint")
-            .arg(cfg.zfs_pool_name())
+            .arg(pool_name)
             .invoke(crate::ErrorKind::Zfs)
             .await?,
     )?;
-    if Path::new(mountpoint.trim()) != &cfg.datadir() {
+    if Path::new(mountpoint.trim()) != datadir.as_ref() {
         Command::new("zfs")
             .arg("set")
-            .arg(format!("mountpoint={}", cfg.datadir().display()))
-            .arg(cfg.zfs_pool_name())
+            .arg(format!("mountpoint={}", datadir.as_ref().display()))
+            .arg(pool_name)
             .invoke(crate::ErrorKind::Zfs)
             .await?;
     }
@@ -203,17 +207,17 @@ pub async fn mount(cfg: &RpcContextConfig, password: &str) -> Result<(), Error>
         .with_ctx(|_| (crate::ErrorKind::Filesystem, PASSWORD_PATH))?;
     Command::new("zfs")
         .arg("load-key")
-        .arg(format!("{}/main", cfg.zfs_pool_name()))
+        .arg(format!("{}/main", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
         .arg("load-key")
-        .arg(format!("{}/package-data", cfg.zfs_pool_name()))
+        .arg(format!("{}/package-data", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
         .arg("load-key")
-        .arg(format!("{}/tmp", cfg.zfs_pool_name()))
+        .arg(format!("{}/tmp", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     tokio::fs::remove_file(PASSWORD_PATH)
@@ -222,17 +226,17 @@ pub async fn mount(cfg: &RpcContextConfig, password: &str) -> Result<(), Error>
 
     Command::new("zfs")
         .arg("mount")
-        .arg(format!("{}/main", cfg.zfs_pool_name()))
+        .arg(format!("{}/main", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
         .arg("mount")
-        .arg(format!("{}/package-data", cfg.zfs_pool_name()))
+        .arg(format!("{}/package-data", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Command::new("zfs")
         .arg("mount")
-        .arg(format!("{}/tmp", cfg.zfs_pool_name()))
+        .arg(format!("{}/tmp", pool_name))
         .invoke(crate::ErrorKind::Zfs)
         .await?;
     Ok(())