Add filepack server subcommand (#82)

Author: terror

Cargo.lock

@@ -13,8 +13,9 @@ repository = "https://github.com/casey/filepack"
 include = ["CHANGELOG.md", "CONTRIBUTING", "LICENSE", "README.md", "src", "tests"]
 
 [dependencies]
+axum = "0.8.4"
 blake3 = { version = "1.5.4", features = ["mmap", "rayon", "serde"] }
-boilerplate = "1.0.1"
+boilerplate = { version = "1.0.1", features = ["axum"] }
 camino = { version = "1.1.9", features = ["serde1"] }
 clap = { version = "4.5.16", features = ["derive"] }
 clap_mangen = "0.2.23"
@@ -31,14 +32,18 @@ serde_json = "1.0.127"
 serde_with = "3.11.0"
 serde_yaml = "0.9.34"
 snafu = "0.8.4"
+tokio = { version = "1.46.1", features = ["rt-multi-thread"] }
 walkdir = "2.5.0"
 
 [dev-dependencies]
 assert_cmd = { version = "2.0.16", features = ["color-auto"] }
 assert_fs = { version = "1.1.2", features = ["color-auto"] }
+axum-test = "17.3.0"
+executable-path = "1.0.0"
 predicates = "3.1.2"
 pretty_assertions = "1.4.1"
 regex = "1.10.6"
+reqwest = { version = "0.12.22", features = ["blocking"] }
 
 [lints.clippy]
 all = { level = "deny", priority = -1 }
@@ -49,6 +54,7 @@ needless-pass-by-value = "allow"
 pedantic = { level = "deny", priority = -1 }
 result-large-err = "allow"
 too-many-lines = "allow"
+unused-async = "allow"
 wildcard-imports = "allow"
 
 [profile.release]

Cargo.toml

@@ -1 +1 @@
-source-item-ordering = ['enum', 'struct', 'trait']
+source-item-ordering = ['enum', 'impl', 'struct', 'trait']

clippy.toml

@@ -0,0 +1,121 @@
+use super::*;
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct Archive {
+  pub(crate) manifest: Hash,
+}
+
+impl Archive {
+  pub(crate) const EXTENSION: &str = "filepack";
+  pub(crate) const FILE_SIGNATURE: &[u8] = b"FILEPACK";
+
+  pub(crate) fn load(path: &Utf8Path) -> Result<Self, ArchiveError> {
+    let mut reader = BufReader::new(File::open(path).context(archive_error::FilesystemIo)?);
+
+    let mut signature = [0u8; Self::FILE_SIGNATURE.len()];
+
+    match reader.read_exact(&mut signature) {
+      Ok(()) => {}
+      Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => {
+        return Err(archive_error::FileSignature.build());
+      }
+      Err(error) => {
+        return Err(archive_error::FilesystemIo.into_error(error));
+      }
+    }
+
+    if signature != Self::FILE_SIGNATURE {
+      return Err(archive_error::FileSignature.build());
+    }
+
+    let mut buffer = [0u8; Hash::LEN];
+
+    match reader.read_exact(&mut buffer) {
+      Ok(()) => {}
+      Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => {
+        return Err(archive_error::Truncated.build());
+      }
+      Err(error) => {
+        return Err(archive_error::FilesystemIo.into_error(error));
+      }
+    }
+
+    Ok(Self {
+      manifest: buffer.into(),
+    })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn file_signature_truncated_error() {
+    let tempdir = TempDir::new().unwrap();
+
+    tempdir.child("foo.archive").write_binary(b"foo").unwrap();
+
+    let path = decode_path(tempdir.path()).unwrap();
+
+    assert_matches! {
+      Archive::load(&path.join("foo.archive")),
+      Err(ArchiveError::FileSignature { .. }),
+    }
+  }
+
+  #[test]
+  fn file_signature_mismatch_error() {
+    let tempdir = TempDir::new().unwrap();
+
+    tempdir
+      .child("foo.archive")
+      .write_binary(b"aaaaaaaa")
+      .unwrap();
+
+    let path = decode_path(tempdir.path()).unwrap();
+
+    assert_matches! {
+      Archive::load(&path.join("foo.archive")),
+      Err(ArchiveError::FileSignature { .. }),
+    }
+  }
+
+  #[test]
+  fn truncated_error() {
+    let tempdir = TempDir::new().unwrap();
+
+    tempdir
+      .child("foo.archive")
+      .write_binary(b"FILEPACK")
+      .unwrap();
+
+    let path = decode_path(tempdir.path()).unwrap();
+
+    assert_matches! {
+      Archive::load(&path.join("foo.archive")),
+      Err(ArchiveError::Truncated { .. }),
+    }
+  }
+
+  #[test]
+  fn success() {
+    let tempdir = TempDir::new().unwrap();
+
+    let manifest = Hash::bytes(&[]);
+
+    let archive = Archive::FILE_SIGNATURE
+      .iter()
+      .chain(manifest.as_bytes())
+      .copied()
+      .collect::<Vec<u8>>();
+
+    tempdir.child("foo.archive").write_binary(&archive).unwrap();
+
+    let path = decode_path(tempdir.path()).unwrap();
+
+    let archive = Archive::load(&path.join("foo.archive")).unwrap();
+
+    assert_eq!(archive, Archive { manifest });
+  }
+}

src/archive.rs

@@ -0,0 +1,15 @@
+use super::*;
+
+#[derive(Debug, Snafu)]
+#[snafu(context(suffix(false)), visibility(pub(crate)))]
+pub(crate) enum ArchiveError {
+  #[snafu(display("invalid file signature"))]
+  FileSignature { backtrace: Option<Backtrace> },
+  #[snafu(display("I/O error"))]
+  FilesystemIo {
+    backtrace: Option<Backtrace>,
+    source: io::Error,
+  },
+  #[snafu(display("archive truncated"))]
+  Truncated { backtrace: Option<Backtrace> },
+}

src/archive_error.rs

@@ -3,6 +3,11 @@ use super::*;
 #[derive(Debug, Snafu)]
 #[snafu(context(suffix(false)), visibility(pub(crate)))]
 pub(crate) enum Error {
+  #[snafu(display("failed to load archive at `{path}`"))]
+  ArchiveLoad {
+    path: DisplayPath,
+    source: ArchiveError,
+  },
   #[snafu(display("failed to get current directory"))]
   CurrentDir { source: io::Error },
   #[snafu(display("failed to get local data directory"))]
@@ -43,6 +48,12 @@ pub(crate) enum Error {
     backtrace: Option<Backtrace>,
     path: DisplayPath,
   },
+  #[snafu(display("I/O error at `{path}`"))]
+  FilesystemIo {
+    backtrace: Option<Backtrace>,
+    path: DisplayPath,
+    source: io::Error,
+  },
   #[snafu(display("fingerprint mismatch"))]
   FingerprintMismatch { backtrace: Option<Backtrace> },
   #[snafu(display("file `{path}` hash {actual} does not match manifest hash {expected}"))]
@@ -52,12 +63,6 @@ pub(crate) enum Error {
     expected: Hash,
     path: DisplayPath,
   },
-  #[snafu(display("I/O error at `{path}`"))]
-  Io {
-    backtrace: Option<Backtrace>,
-    path: DisplayPath,
-    source: io::Error,
-  },
   #[snafu(display("public key `{public_key}` doesn't match private key `{private_key}`"))]
   KeyMismatch {
     backtrace: Option<Backtrace>,
@@ -136,6 +141,23 @@ pub(crate) enum Error {
     backtrace: Option<Backtrace>,
     path: DisplayPath,
   },
+  #[snafu(display("failed to bind server to `{address}:{port}`"))]
+  ServerBind {
+    address: String,
+    backtrace: Option<Backtrace>,
+    port: u16,
+    source: io::Error,
+  },
+  #[snafu(display("failed to run server"))]
+  ServerRun {
+    backtrace: Option<Backtrace>,
+    source: io::Error,
+  },
+  #[snafu(display("failed to initialize server runtime"))]
+  ServerRuntime {
+    backtrace: Option<Backtrace>,
+    source: io::Error,
+  },
   #[snafu(display("manifest has already been signed by public key `{public_key}`"))]
   SignatureAlreadyExists {
     backtrace: Option<Backtrace>,

src/error.rs

@@ -1,30 +1,30 @@
 use super::*;
 
 pub(crate) fn create_dir_all(path: &Utf8Path) -> Result<()> {
-  std::fs::create_dir_all(path).context(error::Io { path })
+  std::fs::create_dir_all(path).context(error::FilesystemIo { path })
 }
 
 pub(crate) fn exists(path: &Utf8Path) -> Result<bool> {
-  path.try_exists().context(error::Io { path })
+  path.try_exists().context(error::FilesystemIo { path })
 }
 
 pub(crate) fn metadata(path: &Utf8Path) -> Result<std::fs::Metadata> {
-  std::fs::metadata(path).context(error::Io { path })
+  std::fs::metadata(path).context(error::FilesystemIo { path })
 }
 
 pub(crate) fn read_to_string(path: impl AsRef<Utf8Path>) -> Result<String> {
-  std::fs::read_to_string(path.as_ref()).context(error::Io {
+  std::fs::read_to_string(path.as_ref()).context(error::FilesystemIo {
     path: path.as_ref(),
   })
 }
 
 pub(crate) fn read_to_string_opt(path: &Utf8Path) -> Result<Option<String>> {
   match std::fs::read_to_string(path) {
     Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(None),
-    result => result.map(Some).context(error::Io { path }),
+    result => result.map(Some).context(error::FilesystemIo { path }),
   }
 }
 
 pub(crate) fn write(path: &Utf8Path, contents: impl AsRef<[u8]>) -> Result {
-  std::fs::write(path, contents).context(error::Io { path })
+  std::fs::write(path, contents).context(error::FilesystemIo { path })
 }

src/filesystem.rs

@@ -4,7 +4,7 @@ use super::*;
 pub(crate) struct Hash(blake3::Hash);
 
 impl Hash {
-  const LEN: usize = blake3::OUT_LEN;
+  pub(crate) const LEN: usize = blake3::OUT_LEN;
 
   pub(crate) fn as_bytes(&self) -> &[u8; Self::LEN] {
     self.0.as_bytes()
@@ -27,6 +27,12 @@ impl From<Hash> for [u8; Hash::LEN] {
   }
 }
 
+impl From<[u8; Hash::LEN]> for Hash {
+  fn from(bytes: [u8; Hash::LEN]) -> Self {
+    Self(bytes.into())
+  }
+}
+
 impl FromStr for Hash {
   type Err = blake3::HexError;
 

src/hash.rs

@@ -1,11 +1,12 @@
 use {
   self::{
-    arguments::Arguments, bytes::Bytes, display_path::DisplayPath, display_secret::DisplaySecret,
-    entry::Entry, error::Error, hash::Hash, into_u64::IntoU64, lint::Lint, lint_group::LintGroup,
-    list::List, manifest::Manifest, metadata::Metadata, options::Options,
-    owo_colorize_ext::OwoColorizeExt, page::Page, private_key::PrivateKey, public_key::PublicKey,
-    relative_path::RelativePath, signature::Signature, signature_error::SignatureError,
-    style::Style, subcommand::Subcommand, template::Template, utf8_path_ext::Utf8PathExt,
+    archive::Archive, archive_error::ArchiveError, arguments::Arguments, bytes::Bytes,
+    display_path::DisplayPath, display_secret::DisplaySecret, entry::Entry, error::Error,
+    hash::Hash, into_u64::IntoU64, lint::Lint, lint_group::LintGroup, list::List,
+    manifest::Manifest, metadata::Metadata, options::Options, owo_colorize_ext::OwoColorizeExt,
+    page::Page, private_key::PrivateKey, public_key::PublicKey, relative_path::RelativePath,
+    signature::Signature, signature_error::SignatureError, style::Style, subcommand::Subcommand,
+    template::Template, utf8_path_ext::Utf8PathExt,
   },
   blake3::Hasher,
   boilerplate::Boilerplate,
@@ -17,7 +18,7 @@ use {
   owo_colors::Styled,
   serde::{Deserialize, Deserializer, Serialize, Serializer},
   serde_with::{DeserializeFromStr, SerializeDisplay},
-  snafu::{ensure, ErrorCompat, OptionExt, ResultExt, Snafu},
+  snafu::{ensure, ErrorCompat, IntoError, OptionExt, ResultExt, Snafu},
   std::{
     array::TryFromSliceError,
     backtrace::{Backtrace, BacktraceStatus},
@@ -26,17 +27,38 @@ use {
     env,
     fmt::{self, Display, Formatter},
     fs::{self, File},
-    io::{self, BufWriter, IsTerminal, Write},
+    io::{self, BufReader, BufWriter, IsTerminal, Read, Write},
     path::{Path, PathBuf},
     process,
     str::{self, FromStr},
+    sync::Arc,
   },
+  tokio::runtime::Runtime,
   walkdir::WalkDir,
 };
 
 #[cfg(test)]
-use assert_fs::TempDir;
+use assert_fs::{
+  fixture::{FileWriteBin, PathChild},
+  TempDir,
+};
+
+#[cfg(test)]
+macro_rules! assert_matches {
+  ($expression:expr, $( $pattern:pat_param )|+ $( if $guard:expr )? $(,)?) => {
+    match $expression {
+      $( $pattern )|+ $( if $guard )? => {}
+      left => panic!(
+        "assertion failed: (left ~= right)\n  left: `{:?}`\n right: `{}`",
+        left,
+        stringify!($($pattern)|+ $(if $guard)?)
+      ),
+    }
+  }
+}
 
+mod archive;
+mod archive_error;
 mod arguments;
 mod bytes;
 mod display_path;
@@ -75,6 +97,10 @@ fn current_dir() -> Result<Utf8PathBuf> {
     .map_err(|path| error::PathUnicode { path }.build())
 }
 
+fn decode_path(path: &Path) -> Result<&Utf8Path> {
+  Utf8Path::from_path(path).context(error::PathUnicode { path })
+}
+
 fn main() {
   if let Err(err) = Arguments::parse().run() {
     let style = Style::stderr();

src/main.rs

@@ -37,9 +37,7 @@ impl Options {
       path.into()
     } else {
       let path = dirs::data_local_dir().context(error::DataLocalDir)?;
-      Utf8Path::from_path(&path)
-        .context(error::PathUnicode { path: &path })?
-        .join("filepack")
+      decode_path(&path)?.join("filepack")
     };
 
     Ok(path.join("keys"))