chore: global cleanup

src/apply.rs

@@ -3,101 +3,75 @@ use log::info;
 use std::path::Path;
 use tokio::fs;
 
-use crate::{base64_decode, File};
+use crate::{File, base64_decode};
 
 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 = Path::new(&path);
+    let path = chroot(root, &file.path);
+    let path = Path::new(&path);
 
-        if !dry_run && let Some(parent) = path.parent() {
-            fs::create_dir_all(parent).await?;
-        }
+    if !dry_run && let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).await?;
+    }
 
-        use crate::{FileKind as K, FilePart as P};
-        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?;
-                }
-            }
-        }
+    let kind = file.kind();
+    let content = kind.content()?;
 
-        if dry_run {
+    use crate::{FileKind as K};
+    match kind.as_ref() {
+        K::Skip => {
+            info!("{}: kind is skip", file.path);
             return Ok(());
         }
-
-        if !file.is_symlink() {
-             set_perms(path, file.mode).await?;
+        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?;
+            }
         }
-
-        info!("created {}", file.path);
-        Ok(())
     }
 
+    if dry_run {
+        return Ok(());
+    }
+
+    if !file.is_symlink() {
+        set_perms(path, file.mode).await?;
+    }
+
+    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::{format_err, Result};
+use eyre::{Result, format_err};
 use human_units::Duration;
 use log::{debug, error};
 use std::net::SocketAddr;

src/cgroup.rs

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

src/dynlay.rs

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

src/lib.rs

@@ -148,3 +148,34 @@ 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::{format_err, Result};
+use eyre::{Result, format_err};
 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::{sleep, Duration},
+    time::{Duration, sleep},
 };
 
 use crate::{cgroup, fs};
@@ -220,7 +220,7 @@ impl Logger {
 
 fn forward_signals_to(pid: i32) {
     use nix::{
-        sys::signal::{kill, Signal},
+        sys::signal::{Signal, kill},
         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::{copy, AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader},
+    io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader, copy},
     net::{UnixListener, UnixStream},
-    sync::{mpsc, watch, RwLock},
+    sync::{RwLock, mpsc, watch},
 };
 
 use crate::{cgroup, fs};
@@ -185,7 +185,7 @@ async fn handle(mut conn: UnixStream) {
 }
 
 async fn wait_terminate() {
-    use tokio::signal::unix::{signal, SignalKind};
+    use tokio::signal::unix::{SignalKind, signal};
     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::{signal, SignalKind};
+    use tokio::signal::unix::{SignalKind, signal};
     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::{kill, Signal},
+    sys::signal::{Signal, kill},
     unistd::Pid,
 };
 use std::num::NonZero;
 use tokio::{
     process, select,
     sync::{mpsc, watch},
-    time::{sleep, sleep_until, Duration, Instant},
+    time::{Duration, Instant, sleep, sleep_until},
 };
 
 use super::{Error, Result, Service};