tensorfs 0.3.45__tar.gz → 0.3.47__tar.gz

{tensorfs-0.3.45 → tensorfs-0.3.47}/Cargo.lock

@@ -421,7 +421,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.45"
+version = "0.3.47"
 dependencies = [
  "fs2",
  "libc",
@@ -435,7 +435,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.45"
+version = "0.3.47"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.45 → tensorfs-0.3.47}/Cargo.toml

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

{tensorfs-0.3.45 → tensorfs-0.3.47}/PKG-INFO

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

{tensorfs-0.3.45 → tensorfs-0.3.47}/crates/tensorfs-core/Cargo.toml

@@ -11,7 +11,7 @@ path = "src/bin/tfs/main.rs"
 fs2 = "0.4"
 minicbor = { version = "2.3.0", default-features = false, features = ["alloc"] }
 rusqlite = { version = "0.32", features = ["bundled"] }
-rustix = { version = "1.1.4", default-features = false, features = ["fs", "std"] }
+rustix = { version = "1.1.4", default-features = false, features = ["fs", "std", "net", "event"] }
 # tfs-049: the ONE transport (src/transport/). rustls is the one TLS stack, used only
 # there; scripts/fence.py refuses it anywhere else so a second mover cannot grow.
 rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }

{tensorfs-0.3.45 → tensorfs-0.3.47}/crates/tensorfs-core/src/asset_update.rs

@@ -23,6 +23,9 @@ pub enum Edit {
         source_path: String,
         media_type: String,
     },
+    /// Inherit one already-committed asset from the source checkpoint header.
+    /// The asset declaration and segment ObjectRefs are copied verbatim; no payload is read.
+    Inherit { name: String, source_name: String },
     /// Remove an asset by its exact header name.  Missing names are harmless, making
     /// retries deterministic.
     Drop { name: String },
@@ -72,6 +75,7 @@ pub fn update(
         detail: "asset update source has no CozyTensors header".into(),
     })?;
     let mut header = checkpoint::load_header(store, header_ref)?;
+    let source_assets: BTreeMap<String, Asset> = header.assets.iter().cloned().collect();
     let closure = checkpoint::load_closure(store, &header)?;
 
     let mut assets: BTreeMap<String, Asset> = header.assets.drain(..).collect();
@@ -80,6 +84,13 @@ pub fn update(
             Edit::Drop { name } => {
                 assets.remove(name);
             }
+            Edit::Inherit { name, source_name } => {
+                let asset = source_assets.get(source_name).ok_or_else(|| Refusal {
+                    code: Code::OBJECT_ABSENT,
+                    detail: format!("source asset {source_name:?} is absent"),
+                })?;
+                assets.insert(name.clone(), asset.clone());
+            }
             Edit::Copy {
                 name,
                 source_path,
@@ -129,6 +140,47 @@ pub fn update(
     })
 }
 
+/// Inherit selected runtime assets from one exact source checkpoint into another
+/// metadata-only derived checkpoint. Tensor and asset payloads are never opened.
+pub fn inherit(
+    store: &Store,
+    target_manifest: &ObjectRef,
+    source_manifest: &ObjectRef,
+    names: &[String],
+) -> Result<ResultSnapshot> {
+    let target = checkpoint::load_manifest(store, target_manifest)?;
+    let target_header_ref = target.header().ok_or_else(|| Refusal {
+        code: Code::ATTACHMENT_CARDINALITY,
+        detail: "asset inheritance target has no CozyTensors header".into(),
+    })?;
+    let source = checkpoint::load_manifest(store, source_manifest)?;
+    let source_header_ref = source.header().ok_or_else(|| Refusal {
+        code: Code::ATTACHMENT_CARDINALITY,
+        detail: "asset inheritance source has no CozyTensors header".into(),
+    })?;
+    let mut header = checkpoint::load_header(store, target_header_ref)?;
+    let source_header = checkpoint::load_header(store, source_header_ref)?;
+    let target_closure = checkpoint::load_closure(store, &header)?;
+    let source_assets: BTreeMap<String, Asset> = source_header.assets.into_iter().collect();
+    let mut assets: BTreeMap<String, Asset> = header.assets.drain(..).collect();
+    for name in names {
+        let asset = source_assets.get(name).ok_or_else(|| Refusal {
+            code: Code::OBJECT_ABSENT,
+            detail: format!("source asset {name:?} is absent"),
+        })?;
+        assets.insert(name.clone(), asset.clone());
+    }
+    header.assets = assets.into_iter().collect();
+    header.validate(&target_closure)?;
+    let header_object = checkpoint::put_doc(store, &header)?;
+    let manifest = checkpoint::build_manifest(&header, &header_object, &target_closure)?;
+    let manifest_object = store.put_manifest(&manifest)?.obj;
+    Ok(ResultSnapshot {
+        header: header_object,
+        manifest: manifest_object,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -290,4 +342,63 @@ mod tests {
         assert_eq!(one.manifest, two.manifest);
         std::fs::remove_dir_all(root).unwrap();
     }
+
+    #[test]
+    fn inherits_existing_asset_refs_without_payload_reads() {
+        let root = temp();
+        let store = Store::init(&root).unwrap();
+        let spec = registry::seeds().into_iter().next().unwrap().spec;
+        let payload = put(&store, b"tokenizer");
+        let header = Header {
+            configs: vec![],
+            assets: vec![(
+                "tokenizer/vocab.json".into(),
+                Asset {
+                    logical_sha256: payload.sha256.clone(),
+                    logical_length: payload.length,
+                    media_type: "application/json".into(),
+                    segments: vec![payload.clone()],
+                },
+            )],
+            encodings: vec![spec.clone()],
+            components: vec![(
+                "model".into(),
+                vec![(
+                    "w".into(),
+                    Tensor {
+                        dtype: Dtype::U8,
+                        shape: vec![1],
+                        encoding: spec.object_id(),
+                        parts: vec![(
+                            "value".into(),
+                            Part {
+                                dtype: Dtype::U8,
+                                shape: vec![1],
+                                body: Body::Inline(vec![0]),
+                            },
+                        )],
+                    },
+                )],
+            )],
+        };
+        let href = put(&store, &header.canonical_bytes().unwrap());
+        let source = Draft {
+            entries: vec![("model.cozytensors".into(), Entry::CozyTensors(href))],
+        }
+        .seal()
+        .unwrap();
+        let source_ref = store.put_manifest(&source).unwrap().obj;
+        let result = update(
+            &store,
+            &source_ref,
+            &[Edit::Inherit {
+                name: "tokenizer/vocab.json".into(),
+                source_name: "tokenizer/vocab.json".into(),
+            }],
+        )
+        .unwrap();
+        let output = checkpoint::load_header(&store, &result.header).unwrap();
+        assert_eq!(output.assets[0].1.segments, vec![payload]);
+        std::fs::remove_dir_all(root).unwrap();
+    }
 }

{tensorfs-0.3.45 → tensorfs-0.3.47}/crates/tensorfs-core/src/transport/http.rs

@@ -82,6 +82,7 @@ fn transfer_verdict(
     since: Instant,
     waiting_for: &str,
 ) -> Result<()> {
+    ledger.check_running()?;
     if judge != Judge::Transfer {
         return Ok(());
     }
@@ -131,6 +132,7 @@ fn transfer_verdict(
 /// its own window and advances only when transport bytes actually move; slow
 /// progress may span arbitrarily many windows without exhausting a wall budget.
 fn stream_verdict(judge: Judge, ledger: &Ledger, advanced: Instant, phase: &str) -> Result<()> {
+    ledger.check_running()?;
     if judge != Judge::Stream || advanced.elapsed() <= ledger.patience() {
         return Ok(());
     }
@@ -271,27 +273,86 @@ impl Wire {
     }
 }
 
-fn connect(checked: &CheckedUrl, deadline: Deadline, fail: Code) -> Result<TcpStream> {
+fn connect(
+    checked: &CheckedUrl,
+    deadline: Deadline,
+    ledger: &Ledger,
+    judge: Judge,
+    fail: Code,
+) -> Result<TcpStream> {
+    use rustix::event::{poll, PollFd, PollFlags, Timespec};
+    use rustix::net::{self, AddressFamily, SocketFlags, SocketType};
     let mut last: Option<std::io::Error> = None;
-    for addr in &checked.addrs {
-        let attempt = match deadline.remaining()? {
-            Some(left) => TcpStream::connect_timeout(addr, left),
-            None => TcpStream::connect(addr),
+    'addresses: for addr in &checked.addrs {
+        ledger.check_running()?;
+        let family = if addr.is_ipv4() {
+            AddressFamily::INET
+        } else {
+            AddressFamily::INET6
         };
-        match attempt {
-            Ok(sock) => {
-                let _ = sock.set_nodelay(true);
-                return Ok(sock);
+        let socket = match net::socket_with(
+            family,
+            SocketType::STREAM,
+            SocketFlags::NONBLOCK | SocketFlags::CLOEXEC,
+            Some(net::ipproto::TCP),
+        ) {
+            Ok(socket) => socket,
+            Err(error) => {
+                last = Some(error.into());
+                continue;
+            }
+        };
+        let since = Instant::now();
+        match net::connect(&socket, addr) {
+            Ok(()) => {}
+            Err(rustix::io::Errno::INPROGRESS) => loop {
+                // Poll one pending connection instead of restarting it at each
+                // sample. Cancellation and existing silence rules remain active
+                // without imposing a new total connection deadline.
+                transfer_verdict(judge, ledger, since, "a TCP connection")?;
+                stream_verdict(judge, ledger, since, "TCP connect")?;
+                let tick = deadline
+                    .remaining()?
+                    .map_or(ledger.sample(), |left| left.min(ledger.sample()));
+                let timeout = Timespec {
+                    tv_sec: tick.as_secs() as _,
+                    tv_nsec: tick.subsec_nanos() as _,
+                };
+                let mut descriptors = [PollFd::new(&socket, PollFlags::OUT)];
+                match poll(&mut descriptors, Some(&timeout)) {
+                    Ok(0) | Err(rustix::io::Errno::INTR) => continue,
+                    Ok(_) => match net::sockopt::socket_error(&socket) {
+                        Ok(Ok(())) => break,
+                        Ok(Err(error)) | Err(error) => {
+                            last = Some(error.into());
+                            continue 'addresses;
+                        }
+                    },
+                    Err(error) => {
+                        last = Some(error.into());
+                        continue 'addresses;
+                    }
+                }
+            },
+            Err(error) => {
+                last = Some(error.into());
+                continue;
             }
-            Err(error) => last = Some(error),
         }
+        let socket: TcpStream = socket.into();
+        socket.set_nonblocking(false).map_err(|error| Refusal {
+            code: fail,
+            detail: format!("configure connected socket: {error}"),
+        })?;
+        let _ = socket.set_nodelay(true);
+        return Ok(socket);
     }
     refuse(
         fail,
         format!(
             "{}: no checked address accepted a connection ({})",
             checked.host,
-            last.map(|e| e.to_string()).unwrap_or_default()
+            last.map(|error| error.to_string()).unwrap_or_default()
         ),
     )
 }
@@ -425,7 +486,11 @@ impl BodyReader<'_> {
     /// One raw read off the wire under the sampling rule: the socket timeout is the
     /// RESOLUTION; the deadline and (when judged) the measured patience carry the verdict.
     fn step(&mut self, buf: &mut [u8]) -> Result<usize> {
+        // Time spent by the consumer hashing or writing the prior chunk is not
+        // network silence. This wait starts when it asks for another chunk.
+        self.advanced = Instant::now();
         loop {
+            self.ledger.check_running()?;
             let tick = match self.deadline.remaining()? {
                 Some(left) => left.min(self.ledger.sample()),
                 None => self.ledger.sample(),
@@ -435,7 +500,9 @@ impl BodyReader<'_> {
                 Ok(n) => {
                     if n > 0 {
                         let now = Instant::now();
-                        self.ledger.taught(now - self.advanced);
+                        if self.judge == Judge::Stream {
+                            self.ledger.taught(now - self.advanced);
+                        }
                         self.advanced = now;
                     }
                     return Ok(n);
@@ -645,8 +712,9 @@ pub fn request<'l>(
     write_silence: Option<Duration>,
     fail: Code,
 ) -> Result<Response<'l>> {
+    ledger.check_running()?;
     let opened = Instant::now();
-    let sock = connect(checked, deadline, fail)?;
+    let sock = connect(checked, deadline, ledger, judge, fail)?;
     let mut wire = if checked.https {
         let name = ServerName::try_from(checked.host.clone()).map_err(|_| Refusal {
             code: Code::SOURCE_NOT_ALLOWED,
@@ -697,7 +765,9 @@ pub fn request<'l>(
 
     let (status, response_headers, spill) =
         read_head(&mut wire, deadline, ledger, judge, opened, fail)?;
-    ledger.taught(opened.elapsed());
+    if judge == Judge::Stream {
+        ledger.taught(opened.elapsed());
+    }
     // A HEAD THAT ARRIVED IS PROGRESS. Without this, the second page of a paginated closure
     // would be judged from the start of the first, and a pull whose hub is merely slow
     // would condemn its own second call for the first call's honest latency.

{tensorfs-0.3.45 → tensorfs-0.3.47}/crates/tensorfs-core/src/transport/ledger.rs

@@ -31,6 +31,7 @@
 //! paid H100s sat at exactly zero for fifteen minutes with neither plane complaining.
 
 use crate::err::{refuse, Code, Result};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
@@ -134,6 +135,7 @@ pub struct Still {
 
 /// The one liveness ledger a pull shares across its streams.
 pub struct Ledger {
+    cancelled: AtomicBool,
     sample: Duration,
     worst_gap: Mutex<Duration>,
     progress: Mutex<Progress>,
@@ -150,6 +152,7 @@ impl Ledger {
     /// in milliseconds and judge by exactly the production rule.
     pub fn with_resolution(sample: Duration) -> Ledger {
         Ledger {
+            cancelled: AtomicBool::new(false),
             sample: sample.max(Duration::from_millis(1)),
             worst_gap: Mutex::new(Duration::ZERO),
             progress: Mutex::new(Progress {
@@ -181,6 +184,23 @@ impl Ledger {
         Instant::now()
     }
 
+    /// A terminal object failure stops the whole pull, including already-open
+    /// HTTP streams. Completed objects remain admitted for the next pull.
+    pub(crate) fn cancel(&self) {
+        self.cancelled.store(true, Ordering::Release);
+    }
+
+    pub(crate) fn check_running(&self) -> Result<()> {
+        if self.cancelled.load(Ordering::Acquire) {
+            refuse(
+                Code::TRANSFER_FAILED,
+                "the pull stopped after another object failed",
+            )
+        } else {
+            Ok(())
+        }
+    }
+
     pub fn sample(&self) -> Duration {
         self.sample
     }

{tensorfs-0.3.45 → tensorfs-0.3.47}/crates/tensorfs-core/src/transport/pull.rs

@@ -207,6 +207,7 @@ pub fn fetch_authorized(
     // declared life, which is the only place that question can be answered.
     let mut stale: Option<u16> = None;
     for attempt in 1..=FETCH_ATTEMPTS {
+        ledger.check_running()?;
         let last = attempt == FETCH_ATTEMPTS;
         // A refused re-authorization must still name the origin's answer. It is the whole
         // diagnosis: "403, and re-minting was not honest" and "403, and the hub would not
@@ -604,6 +605,7 @@ pub(super) struct Leases<'a> {
 
 impl ObjectUrls for Leases<'_> {
     fn url_for(&self, at: usize, object: &ObjectRef, stale: bool) -> Result<String> {
+        self.ledger.check_running()?;
         if stale && !self.retire(&object.sha256)? {
             // The refused lease was NOT spent: the hub's own declared life still had more
             // than half of it left, so the origin's refusal is not about time and asking to
@@ -623,6 +625,7 @@ impl ObjectUrls for Leases<'_> {
             return Ok(url);
         }
         let _minting = self.minting.lock().unwrap();
+        self.ledger.check_running()?;
         // Another stream may have minted this window while this one waited for the right
         // to call. Asking again before calling is what makes one window cost one call.
         if let Some(url) = self.fresh(&object.sha256) {
@@ -773,7 +776,7 @@ pub struct WalkOutcome {
 
 /// Walk `plan.wanted` with `streams` objects in flight. One is the serial walk and it
 /// stays reachable, because a link where concurrency does not help is a real link. The
-/// first refusal wins; streams already moving finish their object and stop.
+/// first refusal wins and cancels in-flight network waits. Verified objects remain local.
 ///
 /// **`cache` is the source order, and it is the whole reason a second pod is cheap.** The
 /// order is local Store, then the optional mounted cache, then the origin — the Store half
@@ -885,11 +888,14 @@ pub fn fetch_wanted(
                         }
                     }
                     Err(refusal) => {
-                        stop.store(true, Ordering::Relaxed);
                         let mut slot = first.lock().unwrap();
                         if slot.is_none() {
+                            // Keep the actual failure before waking peers, so their
+                            // cancellation errors cannot replace its diagnosis.
                             *slot = Some(refusal);
+                            ledger.cancel();
                         }
+                        stop.store(true, Ordering::Relaxed);
                         return;
                     }
                 }