tensorfs 0.3.71__tar.gz → 0.3.74__tar.gz

{tensorfs-0.3.71 → tensorfs-0.3.74}/Cargo.lock

@@ -439,7 +439,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.71"
+version = "0.3.74"
 dependencies = [
  "fs2",
  "libc",
@@ -454,7 +454,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.71"
+version = "0.3.74"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.71 → tensorfs-0.3.74}/Cargo.toml

@@ -3,5 +3,5 @@ resolver = "2"
 members = ["crates/tensorfs-core", "crates/tensorfs-py"]
 
 [workspace.package]
-version = "0.3.71"
+version = "0.3.74"
 edition = "2021"

{tensorfs-0.3.71 → tensorfs-0.3.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfs
-Version: 0.3.71
+Version: 0.3.74
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/bin/tfs/fetch.rs

@@ -192,9 +192,8 @@ fn deadline_of(flags: &Flags) -> Deadline {
 
 /// The ONE credential spelling, reaching the child explicitly (tfs-050): `--credential-file
 /// <path>` or the deliberately-set `TFS_CREDENTIAL` — never argv (world-readable in /proc),
-/// never the inherited environment at large. The value is `bearer <token>`, scoped to
-/// exactly the named hosts, or empty for anonymous — which is what a rented pod passes,
-/// the hub's closure and presign routes taking no credential at all.
+/// never the inherited environment at large. The value is `bearer <token>` or
+/// `worker <id> <token>`, scoped to exactly the named hosts, or empty for anonymous.
 fn credential_of(
     flags: &Flags,
     hosts: Vec<String>,

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/bin/tfs/main.rs

@@ -22,7 +22,6 @@
 //!   tfs store prepare-readers [<root>]
 //!   tfs store complete-cozytensors [<root>]
 //!   tfs home                     print TENSORFS_HOME or ~/.tensorfs
-//!   tfs home migrate <old-root> [--to <new-root>]
 //!   tfs store rebuild <census> --rows <jsonl> [--sqlite <tensorfs.sqlite>]
 //!   tfs store admit-file <store> blob|manifest <id> <length> <source>
 //!   tfs repo-cache admit <cache> <store> blob|manifest <id> <length>
@@ -40,8 +39,8 @@
 //!   tfs fill <root> <plan>       resumable fill: skip only verified objects
 //!
 //! The ONE transport (tfs-048/tfs-049/tfs-050). The credential is `--credential-file` or
-//! TFS_CREDENTIAL (`bearer <token>`, or empty for anonymous), never bare argv; a
-//! URL of `-` arrives on stdin. Flags: --hub <base> --lane --session --streams <n>
+//! TFS_CREDENTIAL (`bearer <token>`, `worker <id> <token>`, or empty for anonymous), never
+//! bare argv; a URL of `-` arrives on stdin. Flags: --hub <base> --lane --session --streams <n>
 //! --streams-start <n> --timeout <s> --allow-hosts a,b,.c --allow-local --max-redirects <n>.
 //! `--streams` is the most objects in flight (default 128, memory-bounded); the walk starts
 //! at `--streams-start` (default 16) and doubles while measured goodput follows.
@@ -208,7 +207,6 @@ fn main() -> ExitCode {
     match a.as_slice() {
         ["version"] => cmd_version(),
         ["home"] => cmd_home(None),
-        ["home", "migrate", source] => cmd_home_migrate(Path::new(source), &flags),
         ["home", r] => cmd_home(Some(Path::new(r))),
         ["store", "init"] => cmd_store_default("init", &flags),
         ["store", "info"] => cmd_store_default("info", &flags),
@@ -817,17 +815,6 @@ fn cmd_home(explicit: Option<&Path>) -> ExitCode {
     ExitCode::SUCCESS
 }
 
-fn cmd_home_migrate(source: &Path, flags: &Flags) -> ExitCode {
-    let destination = flag(flags, "to").map(Path::new);
-    let report = ok!(tensorfs_core::home::move_store(source, destination));
-    println!(
-        "moved {} -> {} (device/inode/mtime preserved by same-filesystem rename)",
-        report.source.display(),
-        report.destination.display(),
-    );
-    ExitCode::SUCCESS
-}
-
 /// The no-root spelling of a `store` verb. It uses `TENSORFS_HOME`, or an existing
 /// `$HOME/.tensorfs` — never a Store it would have to invent (tfs-053).
 fn cmd_store_default(verb: &str, flags: &Flags) -> ExitCode {

tensorfs-0.3.74/crates/tensorfs-core/src/derived/history_cost_tests.rs

@@ -0,0 +1,149 @@
+//! A derivation costs the same however many derivations the Store already retains (finding
+//! 50): proving its source rooted walked every retained checkpoint chain, so each lane on a
+//! conversion pod took longer than the one before.
+
+use std::time::{Duration, Instant};
+
+use super::tests::created_declaration;
+use super::*;
+use crate::repository::{Mutation, RepositoryName};
+use crate::store::Fault;
+
+const PARTS: usize = 32;
+const CONVERSIONS: usize = 60;
+const WINDOW: usize = 10;
+
+/// A source-inheriting derivation that adds PARTS tensors and checkpoints after each, as a
+/// quantization lane does: its source inspection, writer, chain and pending root.
+fn convert(store: &Store, meta: &Meta, index: usize, source: &ObjectRef) -> Duration {
+    let started = Instant::now();
+    inspect_source(
+        store,
+        meta,
+        source.clone(),
+        vec!["model".into()],
+        Vec::new(),
+    )
+    .unwrap();
+    let prototype = created_declaration().components.remove(0).add.remove(0);
+    let add: Vec<_> = (0..PARTS)
+        .map(|part| TensorDeclaration {
+            key: format!("added_{part}"),
+            ..prototype.clone()
+        })
+        .collect();
+    let mut order = vec![("model".to_string(), "weight".to_string())];
+    order.extend(
+        add.iter()
+            .map(|tensor| ("model".to_string(), tensor.key.clone())),
+    );
+    let declaration = Declaration {
+        sources: vec![Source {
+            alias: "source".into(),
+            manifest: source.clone(),
+        }],
+        components: vec![ComponentDeclaration {
+            target: "model".into(),
+            source: Some("source".into()),
+            source_component: Some("model".into()),
+            drop: Vec::new(),
+            add,
+        }],
+        order,
+        max_new_bytes: (PARTS * 2048) as u64,
+        ..created_declaration()
+    };
+    let transaction = format!("sha256:{:064x}", index + 1);
+    let writer = begin(store, meta, &transaction, 1, declaration, None).unwrap();
+    let (mut cursor, mut head) = (None, None);
+    for part in 0..PARTS {
+        add_indexed_part(
+            store,
+            meta,
+            &transaction,
+            1,
+            &writer.additions,
+            cursor.as_mut(),
+            ("model", &format!("added_{part}"), "value"),
+            &mut [(index * PARTS + part) as u8; 2048].as_slice(),
+        )
+        .unwrap();
+        let (_, next) = checkpoint_indexed(
+            store,
+            meta,
+            &transaction,
+            1,
+            "lane",
+            "model",
+            head.as_ref(),
+            &mut cursor,
+        )
+        .unwrap();
+        head = next.head;
+    }
+    commit(store, meta, &transaction, 1).unwrap();
+    release_guards(meta, Some(writer.writer_hold), writer.source_leases);
+    started.elapsed()
+}
+
+#[test]
+fn a_conversion_costs_the_same_after_many_retained_conversions() {
+    let scratch = std::path::Path::new("/dev/shm");
+    let root = if scratch.is_dir() {
+        scratch.to_path_buf()
+    } else {
+        std::env::temp_dir()
+    }
+    .join(format!(
+        "tensorfs-history-cost-{}-{}",
+        std::process::id(),
+        crate::meta::now_nanos_unique()
+    ));
+    let store = Store::init(&root).unwrap();
+    let meta = Meta::open(&store).unwrap();
+
+    // The source is a model checkpoint, rooted by its repository as a pulled model is.
+    let source_id = format!("sha256:{}", "5a".repeat(32));
+    let writer = begin(&store, &meta, &source_id, 1, created_declaration(), None).unwrap();
+    add_part(
+        &store,
+        &meta,
+        &source_id,
+        1,
+        ("model", "weight", "value"),
+        &mut [0x21; 2048].as_slice(),
+    )
+    .unwrap();
+    let source = commit(&store, &meta, &source_id, 1).unwrap().manifest;
+    release_guards(&meta, Some(writer.writer_hold), writer.source_leases);
+    store
+        .apply_repository(
+            None,
+            &Mutation::PutCheckpoint {
+                repo: RepositoryName::new("org", "source").unwrap(),
+                manifest: source.clone(),
+            },
+            &Fault::default(),
+        )
+        .unwrap();
+
+    let costs: Vec<Duration> = (0..CONVERSIONS)
+        .map(|index| convert(&store, &meta, index, &source))
+        .collect();
+    let median = |window: &[Duration]| {
+        let mut sorted = window.to_vec();
+        sorted.sort();
+        sorted[sorted.len() / 2]
+    };
+    let (first, last) = (
+        median(&costs[..WINDOW]),
+        median(&costs[CONVERSIONS - WINDOW..]),
+    );
+    let _ = std::fs::remove_dir_all(&root);
+    // Retained history grew six-fold between the windows; the cost of one conversion may
+    // not follow it. Before the fix the last window cost several times the first.
+    assert!(
+        last.as_secs_f64() < 2.0 * first.as_secs_f64(),
+        "conversion cost grew with retained history: first {first:?}, last {last:?}"
+    );
+}

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/derived/part_rows_tests.rs

@@ -333,40 +333,23 @@ fn a_digest_receipt_names_the_declaration_the_intent_bound() {
     for (index, key) in ["weight_0", "weight_1", "weight_2"].into_iter().enumerate() {
         add(&store, &meta, &id, &writer, key, index as u8 + 1).unwrap();
     }
-    let receipt = commit(&store, &meta, &id, 1).unwrap();
-    let inline = receipt.value(ReceiptDeclaration::Inline);
-    let digest = receipt.value(ReceiptDeclaration::Digest);
-    assert_eq!(inline, receipt.to_value());
-    let field = |value: &Value, name: &str| {
-        as_obj("receipt", "facts", value)
+    let receipt = commit(&store, &meta, &id, 1).unwrap().to_value();
+    let field = |name: &str| {
+        as_obj("receipt", "facts", &receipt)
             .unwrap()
             .iter()
             .find(|(key, _)| key == name)
             .map(|(_, value)| value.clone())
     };
+    assert!(field("declaration").is_none());
     assert_eq!(
-        crate::canon::write(&field(&inline, "declaration").unwrap()),
-        intent
-    );
-    assert!(field(&digest, "declaration").is_none());
-    assert_eq!(
-        field(&digest, "declaration_digest"),
+        field("declaration_digest"),
         Some(Value::str(ObjectRef::of(&intent).id()))
     );
     assert_eq!(
-        field(&digest, "declaration_length"),
+        field("declaration_length"),
         Some(Value::uint(intent.len() as u64))
     );
-    // Every other fact is identical in both forms.
-    let others = |value: &Value| {
-        as_obj("receipt", "facts", value)
-            .unwrap()
-            .iter()
-            .filter(|(key, _)| !key.starts_with("declaration"))
-            .cloned()
-            .collect::<Vec<_>>()
-    };
-    assert_eq!(others(&inline), others(&digest));
     let _ = fence(&meta, &id, 1);
     release_guards(&meta, Some(writer.writer_hold), writer.source_leases);
     std::fs::remove_dir_all(store.root()).unwrap();

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/derived/retention.rs

@@ -5,8 +5,7 @@ use std::io::{Read, Write};
 use std::path::PathBuf;
 
 use super::{
-    checkpoint, receipt_from, require_payload_record, roots, Disposition, ReceiptDeclaration,
-    TransactionState,
+    checkpoint, receipt_from, require_payload_record, roots, Disposition, TransactionState,
 };
 use crate::canon::{Fields, Value};
 use crate::catalog::WriterGuard;
@@ -218,12 +217,7 @@ pub fn retain_result(
         );
     }
     let facts = receipt_from(store, row)?;
-    // A receipt's identity is the digest of whichever form its caller was handed.
-    let forms = [ReceiptDeclaration::Inline, ReceiptDeclaration::Digest];
-    if !forms
-        .iter()
-        .any(|form| object_id(&crate::canon::write(&facts.value(*form))) == receipt)
-    {
+    if object_id(&crate::canon::write(&facts.to_value())) != receipt {
         return refuse(
             Code::OBJECT_ID_MISMATCH,
             "retained result receipt differs from committed computation",
@@ -376,20 +370,9 @@ mod tests {
     }
 
     #[test]
-    fn a_result_is_retained_under_either_receipt_form_and_nothing_else() {
+    fn a_result_is_retained_under_its_receipt_and_nothing_else() {
         let f = fixture();
-        let facts = derived::lookup(&f.store, &f.meta, &f.transaction).unwrap();
-        let derived::Lookup::Committed(committed) = facts else {
-            panic!("committed result expected")
-        };
-        let digest_form = object_id(&crate::canon::write(
-            &committed.receipt().value(ReceiptDeclaration::Digest),
-        ));
-        assert_ne!(digest_form, f.receipt);
-        let retained =
-            retain_result(&f.store, &f.meta, &f.transaction, &digest_form, &id("b1")).unwrap();
-        assert_eq!(retained.receipt_digest, digest_form);
-        retain_result(&f.store, &f.meta, &f.transaction, &f.receipt, &id("b2")).unwrap();
+        retain_result(&f.store, &f.meta, &f.transaction, &f.receipt, &id("b1")).unwrap();
         assert_eq!(
             retain_result(&f.store, &f.meta, &f.transaction, &id("99"), &id("b3"))
                 .unwrap_err()

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/derived.rs

@@ -1690,22 +1690,21 @@ fn require_payload_record(store: &Store, object: &ObjectRef, what: &str) -> Resu
 }
 
 fn require_source_roots(store: &Store, declaration: &Declaration) -> Result<()> {
-    if declaration.sources.is_empty() {
-        return Ok(());
-    }
-    let retained = crate::gc::retained_manifests(store)?;
-    for declared in &declaration.sources {
-        if !retained.contains(&declared.manifest) {
-            return refuse(
-                Code::ROOT_ABSENT,
-                format!(
-                    "source {} has no exact retained filesystem root",
-                    declared.manifest.id()
-                ),
-            );
-        }
+    let wanted: Vec<ObjectRef> = declaration
+        .sources
+        .iter()
+        .map(|source| source.manifest.clone())
+        .collect();
+    match crate::gc::unretained_manifests(store, &wanted)?.first() {
+        Some(missing) => refuse(
+            Code::ROOT_ABSENT,
+            format!(
+                "source {} has no exact retained filesystem root",
+                missing.id()
+            ),
+        ),
+        None => Ok(()),
     }
-    Ok(())
 }
 
 fn load_sources(store: &Store, declaration: &Declaration) -> Result<Vec<SourceData>> {
@@ -3126,6 +3125,22 @@ pub(crate) fn retain_restore(
     roots::write(store, &root)
 }
 
+/// The manifests private roots name themselves, without walking their checkpoint chains.
+pub(crate) fn rooted_manifests(store: &Store) -> Result<Vec<ObjectRef>> {
+    let mut named: Vec<ObjectRef> = retention::held_objects(store)?
+        .into_iter()
+        .map(|hold| ObjectRef {
+            sha256: hold.sha256,
+            length: hold.length,
+        })
+        .collect();
+    for root in roots::all(store)? {
+        named.extend(root.sources);
+        named.extend(root.manifest);
+    }
+    Ok(named)
+}
+
 pub(crate) fn retained_objects(store: &Store) -> Result<Vec<crate::storage::HeldKey>> {
     let mut holds = retention::held_objects(store)?;
     for object in roots::journaled(store)? {
@@ -3482,44 +3497,29 @@ pub struct ReceiptFacts {
     pub inherited_payload_bytes: u64,
 }
 
-/// How a receipt names its declaration: the whole document, or its digest and length.
-/// The whole document grows with the tensors declared; a digest keeps receipts constant.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub enum ReceiptDeclaration {
-    #[default]
-    Inline,
-    Digest,
-}
-
 impl ReceiptFacts {
+    /// The receipt names its declaration by digest and length: the declaration grows with the
+    /// tensors declared, and the receipt stays constant.
     pub fn to_value(&self) -> Value {
-        self.value(ReceiptDeclaration::Inline)
-    }
-
-    pub fn value(&self, form: ReceiptDeclaration) -> Value {
-        let mut value = self.inline_value();
-        if form == ReceiptDeclaration::Digest {
-            if let Value::Obj(fields) = &mut value {
-                let bytes = crate::canon::write(&self.declaration.to_value());
-                fields.retain(|(key, _)| key != "declaration");
-                fields.push((
-                    "declaration_digest".into(),
-                    Value::str(ObjectRef::of(&bytes).id()),
-                ));
-                fields.push(("declaration_length".into(), Value::uint(bytes.len() as u64)));
-                fields.sort_by(|left, right| left.0.cmp(&right.0));
-            }
-        }
-        value
+        let bytes = crate::canon::write(&self.declaration.to_value());
+        let Value::Obj(mut fields) = self.facts() else {
+            unreachable!("receipt facts are an object")
+        };
+        fields.push((
+            "declaration_digest".into(),
+            Value::str(ObjectRef::of(&bytes).id()),
+        ));
+        fields.push(("declaration_length".into(), Value::uint(bytes.len() as u64)));
+        fields.sort_by(|left, right| left.0.cmp(&right.0));
+        Value::Obj(fields)
     }
 
-    fn inline_value(&self) -> Value {
+    fn facts(&self) -> Value {
         Value::obj(vec![
             (
                 "added_objects",
                 Value::arr(self.added_objects.iter().map(ObjectRef::to_value).collect()),
             ),
-            ("declaration", self.declaration.to_value()),
             ("header", self.header.to_value()),
             (
                 "inherit_observation",
@@ -4666,3 +4666,6 @@ mod part_rows_tests;
 
 #[cfg(test)]
 mod group_commit_tests;
+
+#[cfg(test)]
+mod history_cost_tests;

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/gc.rs

@@ -29,6 +29,7 @@ use std::path::Path;
 
 use crate::catalog::{Catalog, WriterGuard};
 use crate::err::{Code, Refusal, Result};
+use crate::ids::ObjectRef;
 use crate::ingest::transaction as tx;
 use crate::storage::{self, Census, GcDelete, HeldKey};
 use crate::store::Store;
@@ -158,30 +159,48 @@ pub fn session_holds(store: &Store) -> Result<(Vec<HeldKey>, Vec<String>)> {
     Ok((holds, sessions))
 }
 
-/// The same exact manifest roots used by reclamation, without a payload census.
-/// Membership is retention, not caller authorization. A consumer must acquire its
-/// live hold before checking roots so GC cannot remove bytes during admission.
-pub(crate) fn retained_manifests(store: &Store) -> Result<Vec<crate::ids::ObjectRef>> {
-    let mut roots = Vec::new();
-    for (repository, _) in storage::read_repositories(store.root())? {
-        roots.extend(
-            repository
-                .checkpoints
-                .into_iter()
-                .map(|checkpoint| checkpoint.manifest),
-        );
-    }
-    let (holds, _) = session_holds(store)?;
-    roots.extend(
+/// The `wanted` manifests that no root reclamation keeps names. Roots are read cheapest
+/// first and the search stops once every wanted manifest is found, so a rooted source costs
+/// the roots that name it rather than every checkpoint chain and parts journal the Store
+/// has retained, which grow with its history (finding 50). Membership is retention, not
+/// caller authorization. A consumer must acquire its live hold before checking roots so
+/// GC cannot remove bytes during admission.
+pub(crate) fn unretained_manifests(store: &Store, wanted: &[ObjectRef]) -> Result<Vec<ObjectRef>> {
+    let manifests = |holds: Vec<HeldKey>| {
         holds
             .into_iter()
-            .filter(|hold| hold.is_manifest())
-            .map(|hold| crate::ids::ObjectRef {
+            .filter(HeldKey::is_manifest)
+            .map(|hold| ObjectRef {
                 sha256: hold.sha256,
                 length: hold.length,
-            }),
-    );
-    Ok(roots)
+            })
+    };
+    let repositories = || -> Result<Vec<ObjectRef>> {
+        Ok(storage::read_repositories(store.root())?
+            .into_iter()
+            .flat_map(|(repository, _)| repository.checkpoints)
+            .map(|checkpoint| checkpoint.manifest)
+            .collect())
+    };
+    let named_roots = || -> Result<Vec<ObjectRef>> {
+        let mut named = crate::derived::rooted_manifests(store)?;
+        named.extend(manifests(crate::source_artifact::held_objects(store)?));
+        named.extend(manifests(crate::checkpoint_root::held_objects(store)?));
+        Ok(named)
+    };
+    let everything =
+        || -> Result<Vec<ObjectRef>> { Ok(manifests(session_holds(store)?.0).collect()) };
+    let passes: [&dyn Fn() -> Result<Vec<ObjectRef>>; 3] =
+        [&repositories, &named_roots, &everything];
+    let mut missing = wanted.to_vec();
+    for pass in passes {
+        if missing.is_empty() {
+            break;
+        }
+        let named = pass()?;
+        missing.retain(|manifest| !named.contains(manifest));
+    }
+    Ok(missing)
 }
 
 /// One complete pass: exclusivity, orphan temps, census, plan, delete, catalog repair.

{tensorfs-0.3.71 → tensorfs-0.3.74}/crates/tensorfs-core/src/home.rs

@@ -9,22 +9,12 @@
 //! (tfs-053). Creation stays with the verbs that say so, `tfs store init` and `tfs store ensure`,
 //! over a root that was named.
 
-use std::fs;
-use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 
-use crate::catalog::WriterGuard;
 use crate::err::{refuse, Code, Result};
-use crate::store::{self, Store};
 
 pub const ENV: &str = "TENSORFS_HOME";
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MoveReport {
-    pub source: PathBuf,
-    pub destination: PathBuf,
-}
-
 /// Where a resolved root came from. `Named` roots were asked for; `Fallback` is a guess.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Origin {
@@ -98,98 +88,6 @@ fn nonempty(source: &str, root: &Path) -> Result<PathBuf> {
     Ok(root.to_path_buf())
 }
 
-/// Move one stopped Store into the resolved TensorFS home without copying or rehashing it.
-///
-/// The destination must not exist and both parents must be on the same filesystem. The Store's
-/// recovery lock refuses already-active readers and writers. This is still an offline operator
-/// command: possible Store openers must be stopped so none can recreate the retired pathname
-/// after the rename. No redirect or reservation is left at the old path.
-pub fn move_store(source: &Path, explicit_destination: Option<&Path>) -> Result<MoveReport> {
-    let source_metadata = fs::symlink_metadata(source).map_err(|error| io("stat source", error))?;
-    if source_metadata.file_type().is_symlink() || !source_metadata.is_dir() {
-        return refuse(
-            Code::STORE_ERA,
-            format!("{} is not a TensorFS Store directory", source.display()),
-        );
-    }
-    let source = fs::canonicalize(source).map_err(|error| io("resolve source", error))?;
-    Store::open(&source)?;
-
-    let requested_destination = resolve(explicit_destination)?;
-    match fs::symlink_metadata(&requested_destination) {
-        Ok(_) => {
-            return refuse(
-                Code::IO_FAILED,
-                format!(
-                    "destination {} already exists; remove the conflict or choose another root",
-                    requested_destination.display()
-                ),
-            )
-        }
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
-        Err(error) => return Err(io("stat destination", error)),
-    }
-    let destination_name =
-        requested_destination
-            .file_name()
-            .ok_or_else(|| crate::err::Refusal {
-                code: Code::IO_FAILED,
-                detail: format!(
-                    "destination {} has no final path component",
-                    requested_destination.display()
-                ),
-            })?;
-    let destination_parent = requested_destination
-        .parent()
-        .filter(|path| !path.as_os_str().is_empty())
-        .unwrap_or_else(|| Path::new("."));
-    let destination_parent = fs::canonicalize(destination_parent)
-        .map_err(|error| io("resolve destination parent", error))?;
-    let destination = destination_parent.join(destination_name);
-    if source == destination {
-        return refuse(Code::IO_FAILED, "source and destination are the same Store");
-    }
-    let source_parent = source.parent().ok_or_else(|| crate::err::Refusal {
-        code: Code::IO_FAILED,
-        detail: format!("source {} has no parent", source.display()),
-    })?;
-    let source_device = fs::metadata(&source)
-        .map_err(|error| io("stat source", error))?
-        .dev();
-    let destination_device = fs::metadata(&destination_parent)
-        .map_err(|error| io("stat destination parent", error))?
-        .dev();
-    if source_device != destination_device {
-        return refuse(
-            Code::IO_FAILED,
-            format!(
-                "source {} and destination {} are on different filesystems; a hardcut requires an atomic rename",
-                source.display(),
-                destination.display()
-            ),
-        );
-    }
-
-    let _exclusive = WriterGuard::lock_rebuild(&source)?;
-    fs::rename(&source, &destination).map_err(|error| io("rename Store", error))?;
-    store::fsync_dir(&destination_parent)?;
-    if source_parent != destination_parent {
-        store::fsync_dir(source_parent)?;
-    }
-    Store::open(&destination)?;
-    Ok(MoveReport {
-        source,
-        destination,
-    })
-}
-
-fn io(what: &str, error: std::io::Error) -> crate::err::Refusal {
-    crate::err::Refusal {
-        code: Code::IO_FAILED,
-        detail: format!("{what}: {error}"),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;