File: prepare migration out of flatenned kind

Cargo.lock

@@ -161,9 +161,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc"
-version = "1.2.62"
+version = "1.2.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
+checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -218,9 +218,9 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.6.5"
+version = "4.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7a9bfdb35811f9e59832f0f05975114d2251b415fb534108e6f34060fd772"
+checksum = "660c0520455b1013b9bcb0393d5f643d7e4454fb69c915b8d6d2aa0e9a45acc3"
 dependencies = [
  "clap",
  "clap_lex",
@@ -324,7 +324,6 @@ dependencies = [
  "fastrand",
  "futures",
  "futures-util",
- "getrandom 0.4.2",
  "glob",
  "hex",
  "human-units",
@@ -573,9 +572,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.17.1"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
 
 [[package]]
 name = "heck"
@@ -842,7 +841,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
  "equivalent",
- "hashbrown 0.17.1",
+ "hashbrown 0.17.0",
  "serde",
  "serde_core",
 ]
@@ -853,6 +852,16 @@ version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
+[[package]]
+name = "iri-string"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
 [[package]]
 name = "is_executable"
 version = "1.0.5"
@@ -910,9 +919,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.98"
+version = "0.3.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67df7112613f8bfd9150013a0314e196f4800d3201ae742489d999db2f979f08"
+checksum = "a1840c94c045fbcf8ba2812c95db44499f7c64910a912551aaaa541decebcacf"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -1005,9 +1014,9 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.31.3"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"
+checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3"
 dependencies = [
  "bitflags",
  "cfg-if",
@@ -1038,14 +1047,15 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "openssl"
-version = "0.10.80"
+version = "0.10.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
+checksum = "f38c4372413cdaaf3cc79dd92d29d7d9f5ab09b51b10dded508fb90bb70b9222"
 dependencies = [
  "bitflags",
  "cfg-if",
  "foreign-types",
  "libc",
+ "once_cell",
  "openssl-macros",
  "openssl-sys",
 ]
@@ -1069,9 +1079,9 @@ checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.116"
+version = "0.9.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
+checksum = "13ce1245cd07fcc4cfdb438f7507b0c7e4f3849a69fd84d52374c66d83741bb6"
 dependencies = [
  "cc",
  "libc",
@@ -1279,9 +1289,9 @@ dependencies = [
 
 [[package]]
 name = "rpassword"
-version = "7.5.2"
+version = "7.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ac5b223d9738ef56e0b98305410be40fa0941bf6036c56f1506751e43552d64"
+checksum = "2501c67132bd19c3005b0111fba298907ef002c8c1cf68e25634707e38bf66fe"
 dependencies = [
  "libc",
  "rtoolbox",
@@ -1607,9 +1617,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.52.3"
+version = "1.52.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
 dependencies = [
  "bytes",
  "libc",
@@ -1672,20 +1682,20 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.11"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
  "bitflags",
  "bytes",
  "futures-util",
  "http",
  "http-body",
+ "iri-string",
  "pin-project-lite",
  "tower",
  "tower-layer",
  "tower-service",
- "url",
 ]
 
 [[package]]
@@ -1814,9 +1824,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.121"
+version = "0.2.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49ace1d07c165b0864824eee619580c4689389afa9dc9ed3a4c75040d82e6790"
+checksum = "df52b6d9b87e0c74c9edfa1eb2d9bf85e5d63515474513aa50fa181b3c4f5db1"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1827,9 +1837,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.71"
+version = "0.4.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96492d0d3ffba25305a7dc88720d250b1401d7edca02cc3bcd50633b424673b8"
+checksum = "af934872acec734c2d80e6617bbb5ff4f12b052dd8e6332b0817bce889516084"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1837,9 +1847,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.121"
+version = "0.2.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e68e6f4afd367a562002c05637acb8578ff2dea1943df76afb9e83d177c8578"
+checksum = "78b1041f495fb322e64aca85f5756b2172e35cd459376e67f2a6c9dffcedb103"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1847,9 +1857,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.121"
+version = "0.2.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d95a9ec35c64b2a7cb35d3fead40c4238d0940c86d107136999567a4703259f2"
+checksum = "9dcd0ff20416988a18ac686d4d4d0f6aae9ebf08a389ff5d29012b05af2a1b41"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -1860,9 +1870,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.121"
+version = "0.2.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4e0100b01e9f0d03189a92b96772a1fb998639d981193d7dbab487302513441"
+checksum = "49757b3c82ebf16c57d69365a142940b384176c24df52a087fb748e2085359ea"
 dependencies = [
  "unicode-ident",
 ]
@@ -1916,9 +1926,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.98"
+version = "0.3.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b572dff8bcf38bad0fa19729c89bb5748b2b9b1d8be70cf90df697e3a8f32aa"
+checksum = "2eadbac71025cd7b0834f20d1fe8472e8495821b4e9801eb0a60bd1f19827602"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -2286,9 +2296,9 @@ dependencies = [
 
 [[package]]
 name = "zerofrom"
-version = "0.1.8"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
 dependencies = [
  "zerofrom-derive",
 ]

Cargo.toml

@@ -23,7 +23,6 @@ eyre = "0.6.12"
 fastrand = "2.3.0"
 futures = "0.3.31"
 futures-util = "0.3.31"
-getrandom = "0.4.2"
 glob = "0.3.2"
 hex = "0.4.3"
 human-units = "0.5.3"

src/apply.rs

@@ -3,75 +3,101 @@ use log::info;
 use std::path::Path;
 use tokio::fs;
 
-use crate::File;
+use crate::{base64_decode, File};
 
 pub async fn files(files: &[File], root: &str, dry_run: bool) -> Result<()> {
     for f in files {
         if let Err(e) = file(f, root, dry_run).await {
-            return Err(format_err!("{}: {e}", f.path));
+            return Err(format_err!("{}: {e}", f.path))
         }
     }
     Ok(())
 }
 
 pub async fn file(file: &File, root: &str, dry_run: bool) -> Result<()> {
-    let path = chroot(root, &file.path);
+        let path = chroot(root, &file.path);
-    let path = Path::new(&path);
+        let path = Path::new(&path);
 
-    if !dry_run && let Some(parent) = path.parent() {
+        if !dry_run && let Some(parent) = path.parent() {
-        fs::create_dir_all(parent).await?;
+            fs::create_dir_all(parent).await?;
-    }
+        }
 
-    let kind = file.kind();
+        use crate::{FileKind as K, FilePart as P};
-    let content = kind.content()?;
+        match file.kind().as_ref() {
+            K::Skip => {
+                info!("{}: kind is skip", file.path);
+                return Ok(())
+            },
+            K::Content(content) => {
+                if dry_run {
+                    info!(
+                        "would create {} ({} bytes from content)",
+                        file.path,
+                        content.len()
+                    );
+                } else {
+                    fs::write(path, content.as_bytes()).await?;
+                }
+            }
+            K::Content64(content) => {
+                let content = base64_decode(content)?;
+                if dry_run {
+                    info!(
+                        "would create {} ({} bytes from content64)",
+                        file.path,
+                        content.len()
+                    );
+                } else {
+                    fs::write(path, content).await?
+                }
+            }
+            K::Parts(parts) => {
+                let mut assembly = Vec::new();
+                for part in parts {
+                    match part {
+                        P::Content(content) => assembly.extend(content.as_bytes()),
+                        P::Content64(content) => assembly.extend(base64_decode(content)?),
+                    }
+                }
+                if dry_run {
+                    info!(
+                        "would create {} ({} bytes from parts)",
+                        file.path,
+                        assembly.len()
+                    );
+                } else {
+                    fs::write(path, assembly).await?
+                }
+            }
+            K::Dir => {
+                if dry_run {
+                    info!("would create {} (directory)", file.path);
+                } else {
+                    fs::create_dir(path).await?;
+                }
+            }
+            K::Symlink(tgt) => {
+                if dry_run {
+                    info!("would create {} (symlink to {})", file.path, tgt);
+                } else {
+                    let _ = fs::remove_file(path).await; // we're ln --force
+                    fs::symlink(tgt, path).await?;
+                }
+            }
+        }
 
-    use crate::{FileKind as K};
+        if dry_run {
-    match kind.as_ref() {
-        K::Skip => {
-            info!("{}: kind is skip", file.path);
             return Ok(());
         }
-        K::Content(_) | K::Content64(_) | K::Parts(_) => {
-            let content = content.expect("this file kind should have content");
-            if dry_run {
-                info!(
-                    "would create {} ({} bytes)",
-                    file.path,
-                    content.len()
-                );
-            } else {
-                fs::write(path, &content).await?;
-            }
-        }
-        K::Dir => {
-            if dry_run {
-                info!("would create {} (directory)", file.path);
-            } else {
-                fs::create_dir(path).await?;
-            }
-        }
-        K::Symlink(tgt) => {
-            if dry_run {
-                info!("would create {} (symlink to {})", file.path, tgt);
-            } else {
-                let _ = fs::remove_file(path).await; // we're ln --force
-                fs::symlink(tgt, path).await?;
-            }
-        }
-    }
 
-    if dry_run {
+        if file.is_symlink() {
-        return Ok(());
+             set_perms(path, file.mode).await?;
-    }
+        }
 
-    if !file.is_symlink() {
+        info!("created {}", file.path);
-        set_perms(path, file.mode).await?;
+        Ok(())
     }
 
-    info!("created {}", file.path);
-    Ok(())
-}
-
 pub async fn set_perms(path: impl AsRef<Path>, mode: Option<u32>) -> std::io::Result<()> {
     if let Some(mode) = mode.filter(|m| *m != 0) {
         use std::os::unix::fs::PermissionsExt;

src/bin/dkl.rs

@@ -1,5 +1,5 @@
 use clap::{CommandFactory, Parser, Subcommand};
-use eyre::{Result, format_err};
+use eyre::{format_err, Result};
 use human_units::Duration;
 use log::{debug, error};
 use std::net::SocketAddr;

src/bin/dls.rs

@@ -3,7 +3,6 @@ use clap::{CommandFactory, Parser, Subcommand};
 use eyre::format_err;
 use futures_util::Stream;
 use futures_util::StreamExt;
-use std::path::PathBuf;
 use std::time::{Duration, SystemTime};
 use tokio::fs;
 use tokio::io::{AsyncWrite, AsyncWriteExt};
@@ -41,11 +40,6 @@ enum Command {
     Hash {
         salt: String,
     },
-    Store {
-        store_path: PathBuf,
-        #[command(subcommand)]
-        op: StoreOp,
-    },
 }
 
 #[derive(Subcommand)]
@@ -102,12 +96,6 @@ enum ClusterCommand {
     },
 }
 
-#[derive(Subcommand)]
-enum StoreOp {
-    Get { data_path: PathBuf },
-    Set { data_path: PathBuf, value: String },
-}
-
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> eyre::Result<()> {
     clap_complete::CompleteEnv::with_factory(Cli::command).complete();
@@ -243,18 +231,6 @@ async fn main() -> eyre::Result<()> {
             println!("hash (hex):    {}", hex::encode(&hash));
             println!("hash (base64): {}", dkl::base64_encode(&hash));
         }
-        C::Store { store_path, op } => {
-            let mut s = dls::store::Store::new(store_path);
-            s.unlock(&std::env::var("DLS_STORE_PW").unwrap()).await?;
-
-            match op {
-                StoreOp::Get { data_path } => {
-                    let mut data = std::io::Cursor::new(s.read(data_path).await?);
-                    tokio::io::copy(&mut data, &mut tokio::io::stdout()).await?;
-                }
-                StoreOp::Set { data_path, value } => s.write(data_path, value.as_bytes()).await?,
-            }
-        }
     };
 
     Ok(())

src/cgroup.rs

@@ -64,8 +64,8 @@ pub async fn ls(
     }
 
     use tabled::settings::{
-        Alignment, Modify,
         object::{Column, Row},
+        Alignment, Modify,
     };
     let mut table = table.build();
     table.with(tabled::settings::Style::psql());

src/dls.rs

@@ -23,18 +23,6 @@ impl Client {
         }
     }
 
-    pub fn new_with_http_client(
-        base_url: String,
-        token: String,
-        http_client: reqwest::Client,
-    ) -> Self {
-        Self {
-            base_url,
-            token,
-            http_client,
-        }
-    }
-
     pub fn with_proxy(self, proxy: String) -> reqwest::Result<Self> {
         let proxy = reqwest::Proxy::all(proxy)?;
         Ok(Self {
@@ -166,7 +154,7 @@ impl<'t> Host<'t> {
     pub async fn asset(
         &self,
         asset_name: &str,
-    ) -> Result<impl Stream<Item = reqwest::Result<Bytes>> + use<>> {
+    ) -> Result<impl Stream<Item = reqwest::Result<Bytes>>> {
         let req = self.dls.get(format!("hosts/{}/{asset_name}", self.name))?;
         let resp = do_req(req, &self.dls.token).await?;
         Ok(resp.bytes_stream())

src/dls/store.rs

@@ -1,13 +1,4 @@
-use openssl::symm::Mode;
+pub fn hash_password(salt: &[u8], passphrase: &str) -> argon2::Result<[u8; 32]> {
-use std::borrow::Cow;
-use std::path::{Path, PathBuf};
-use tokio::{fs, io::AsyncWriteExt};
-
-pub type Salt = [u8; 16];
-pub type Key = [u8; 32];
-pub type Hash = Vec<u8>;
-
-pub fn hash_password(salt: &[u8], passphrase: &str) -> Result<Key> {
     let hash = argon2::hash_raw(
         passphrase.as_bytes(),
         salt,
@@ -15,191 +6,12 @@ pub fn hash_password(salt: &[u8], passphrase: &str) -> Result<Key> {
             variant: argon2::Variant::Argon2id,
             hash_length: 32,
             time_cost: 1,
-            mem_cost: 64 << 10,
+            mem_cost: 65536,
             thread_mode: argon2::ThreadMode::Parallel,
             lanes: 4,
             ..Default::default()
         },
-    )
+    )?;
-    .map_err(Error::Hash)?;
 
-    Ok(hash.try_into().unwrap())
+    unsafe { Ok(hash.try_into().unwrap_unchecked()) }
-}
-
-pub struct Store {
-    path: PathBuf,
-    key: Option<Key>,
-}
-
-impl Store {
-    pub fn new(path: impl Into<PathBuf>) -> Self {
-        Self {
-            path: path.into(),
-            key: None,
-        }
-    }
-
-    pub async fn unlock(&mut self, passphrase: &str) -> Result<()> {
-        let keys = self.read_keys().await?;
-
-        let salt = keys.salt;
-
-        let user_key = hash_password(&salt, passphrase)?;
-        let user_hash = openssl::sha::sha512(&user_key);
-
-        for nk in keys.keys {
-            if nk.hash != user_hash {
-                continue;
-            }
-
-            // build iv+data from salt
-            let mut enc_data = Vec::with_capacity(salt.len() + nk.enc_key.len());
-            enc_data.extend_from_slice(&salt);
-            enc_data.extend_from_slice(&nk.enc_key);
-
-            let key = crypt(&enc_data, &user_key, Mode::Decrypt)?;
-            let key = key.try_into().map_err(|_| Error::InvalidKey)?;
-
-            self.key = Some(key);
-            return Ok(());
-        }
-
-        Err(Error::KeyNotFound)
-    }
-
-    pub async fn read(&self, path: impl AsRef<Path>) -> Result<Vec<u8>> {
-        let enc_data = self.read_file(path.as_ref().with_extension("data")).await?;
-        self.decrypt(&enc_data)
-    }
-    pub async fn read_to_string(&self, path: impl AsRef<Path>) -> Result<String> {
-        let path = path.as_ref();
-        String::from_utf8(self.read(path).await?).map_err(|_| Error::InvalidUtf8(path.into()))
-    }
-
-    pub async fn write(&self, path: impl AsRef<Path>, data: &[u8]) -> Result<()> {
-        let enc_data = self.encrypt(data)?;
-        safe_write(self.path.join(&path).with_extension("data"), &enc_data).await
-    }
-
-    async fn read_keys(&self) -> Result<Keys<'_>> {
-        let keys = self.read_file(".keys").await?;
-        let Some(keys) = keys.strip_prefix(b"{json}") else {
-            return Err(Error::InvalidKeys);
-        };
-
-        serde_json::from_slice(keys).map_err(Error::KeysParse)
-    }
-
-    async fn read_file(&self, subpath: impl AsRef<Path>) -> Result<Vec<u8>> {
-        let path = self.path.join(subpath);
-        fs::read(&path).await.map_err(|e| Error::Read(path, e))
-    }
-
-    fn encrypt(&self, src: &[u8]) -> Result<Vec<u8>> {
-        self.crypt(src, Mode::Encrypt)
-    }
-    fn decrypt(&self, src: &[u8]) -> Result<Vec<u8>> {
-        self.crypt(src, Mode::Decrypt)
-    }
-    fn crypt(&self, src: &[u8], mode: Mode) -> Result<Vec<u8>> {
-        let key = self.key.as_ref().ok_or(Error::NotUnlocked)?;
-        crypt(src, key, mode)
-    }
-}
-
-async fn safe_write(path: impl AsRef<Path>, contents: &[u8]) -> Result<()> {
-    let path = path.as_ref();
-    let tmp = path.with_added_extension("new");
-
-    let tmp_err = |e| Error::Write(tmp.clone(), e);
-
-    let mut file = fs::OpenOptions::new()
-        .create(true)
-        .truncate(true)
-        .write(true)
-        .open(&tmp)
-        .await
-        .map_err(tmp_err)?;
-
-    file.write_all(contents).await.map_err(tmp_err)?;
-    file.sync_all().await.map_err(tmp_err)?;
-    file.shutdown().await.map_err(tmp_err)?;
-
-    fs::rename(tmp, &path)
-        .await
-        .map_err(|e| Error::Write(path.into(), e))
-}
-
-fn crypt(mut src: &[u8], key: &Key, mode: Mode) -> Result<Vec<u8>> {
-    use openssl::symm::{Cipher, Crypter};
-
-    let mut iv = [0u8; 16];
-    let mut dst: Vec<u8>;
-    let crypt_dst: &mut [u8];
-
-    match mode {
-        Mode::Encrypt => {
-            getrandom::fill(&mut iv).unwrap();
-            dst = vec![0u8; iv.len() + src.len()];
-            dst[..iv.len()].copy_from_slice(&iv);
-            crypt_dst = &mut dst[iv.len()..];
-        }
-        Mode::Decrypt => {
-            iv = src[..iv.len()]
-                .try_into()
-                .map_err(|_| Error::DecryptInputToSmall)?;
-            src = &src[iv.len()..];
-            dst = vec![0u8; src.len()];
-            crypt_dst = &mut dst;
-        }
-    }
-
-    let cipher = Cipher::aes_256_cfb128();
-    Crypter::new(cipher, mode, key, Some(&iv))
-        .expect("Failed to init AES")
-        .update(src, crypt_dst)
-        .expect("AES CFB encrypt/decrypt failed");
-
-    Ok(dst)
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("hash error: {0}")]
-    Hash(argon2::Error),
-    #[error("read {0} failed: {1}")]
-    Read(PathBuf, std::io::Error),
-    #[error("write {0} failed: {1}")]
-    Write(PathBuf, std::io::Error),
-    #[error("read {0} failed: invalid UTF-8")]
-    InvalidUtf8(PathBuf),
-    #[error("invalid keys data")]
-    InvalidKeys,
-    #[error("invalid key")]
-    InvalidKey,
-    #[error("keys parse error: {0}")]
-    KeysParse(serde_json::Error),
-    #[error("key not found")]
-    KeyNotFound,
-    #[error("store not unlocked")]
-    NotUnlocked,
-    #[error("decrypt input too small")]
-    DecryptInputToSmall,
-}
-
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "PascalCase")]
-struct Keys<'t> {
-    salt: Salt,
-    keys: Vec<NamedKey<'t>>,
-}
-
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "PascalCase")]
-struct NamedKey<'t> {
-    name: Cow<'t, str>,
-    hash: Hash,
-    enc_key: Key,
 }

src/dynlay.rs

@@ -1,4 +1,4 @@
-use eyre::{Result, format_err};
+use eyre::{format_err, Result};
 use log::{debug, error, info, warn};
 use std::path::PathBuf;
 use tokio::{fs, io::AsyncWriteExt, process::Command};

src/lib.rs

@@ -148,34 +148,3 @@ impl<'t> File {
         }
     }
 }
-
-impl FileKind {
-    pub fn content<'t>(&'t self) -> Result<Option<Cow<'t, [u8]>>, base64::DecodeError> {
-        use FileKind::*;
-        Ok(match self {
-            Content(content) => Some(Cow::Borrowed(content.as_bytes())),
-            Content64(content) => {
-                let content = base64_decode(content)?;
-                Some(Cow::Owned(content))
-            }
-            Parts(parts) => {
-                let mut assembly = Vec::new();
-                for part in parts {
-                    assembly.extend(part.content()?.into_iter());
-                }
-                Some(Cow::Owned(assembly))
-            }
-            _ => None,
-        })
-    }
-}
-
-impl FilePart {
-    pub fn content(&self) -> Result<Cow<'_, [u8]>, base64::DecodeError> {
-        use FilePart::*;
-        Ok(match self {
-            Content(content) => Cow::Borrowed(content.as_bytes()),
-            Content64(content) => Cow::Owned(base64_decode(content)?),
-        })
-    }
-}

src/logger.rs

@@ -1,6 +1,6 @@
 use async_compression::tokio::write::{ZstdDecoder, ZstdEncoder};
 use chrono::{DurationRound, TimeDelta, Utc};
-use eyre::{Result, format_err};
+use eyre::{format_err, Result};
 use log::{debug, error, warn};
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
@@ -10,7 +10,7 @@ use tokio::{
     io::{self, AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt, BufReader, BufWriter},
     process::{Child, Command},
     sync::mpsc,
-    time::{Duration, sleep},
+    time::{sleep, Duration},
 };
 
 use crate::{cgroup, fs};
@@ -220,7 +220,7 @@ impl Logger {
 
 fn forward_signals_to(pid: i32) {
     use nix::{
-        sys::signal::{Signal, kill},
+        sys::signal::{kill, Signal},
         unistd::Pid,
     };
     use signal_hook::{consts::*, low_level::register};

src/rc.rs

@@ -5,9 +5,9 @@ use std::collections::{BTreeMap as Map, BTreeSet as Set};
 use std::path::PathBuf;
 use std::sync::LazyLock;
 use tokio::{
-    io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader, copy},
+    io::{copy, AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader},
     net::{UnixListener, UnixStream},
-    sync::{RwLock, mpsc, watch},
+    sync::{mpsc, watch, RwLock},
 };
 
 use crate::{cgroup, fs};
@@ -185,7 +185,7 @@ async fn handle(mut conn: UnixStream) {
 }
 
 async fn wait_terminate() {
-    use tokio::signal::unix::{SignalKind, signal};
+    use tokio::signal::unix::{signal, SignalKind};
     let Ok(mut sig) = signal(SignalKind::terminate())
         .inspect_err(|e| error!("failed to listen to SIGTERM (will be ignored): {e}"))
     else {
@@ -203,7 +203,7 @@ async fn wait_terminate() {
 }
 
 async fn wait_reload() {
-    use tokio::signal::unix::{SignalKind, signal};
+    use tokio::signal::unix::{signal, SignalKind};
     let Ok(mut sig) = signal(SignalKind::hangup())
         .inspect_err(|e| error!("failed to listen to SIGHUP (will be ignored): {e}"))
     else {

src/rc/runner.rs

@@ -1,13 +1,13 @@
 use log::{error, warn};
 use nix::{
-    sys::signal::{Signal, kill},
+    sys::signal::{kill, Signal},
     unistd::Pid,
 };
 use std::num::NonZero;
 use tokio::{
     process, select,
     sync::{mpsc, watch},
-    time::{Duration, Instant, sleep, sleep_until},
+    time::{sleep, sleep_until, Duration, Instant},
 };
 
 use super::{Error, Result, Service};