tensorfs 0.3.57__tar.gz → 0.3.58__tar.gz

{tensorfs-0.3.57 → tensorfs-0.3.58}/Cargo.lock

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

{tensorfs-0.3.57 → tensorfs-0.3.58}/Cargo.toml

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

{tensorfs-0.3.57 → tensorfs-0.3.58}/PKG-INFO

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

{tensorfs-0.3.57 → tensorfs-0.3.58}/crates/tensorfs-core/src/providers.rs

@@ -793,6 +793,7 @@ pub fn content_manifest(resolution: &Resolution) -> Result<crate::manifest::Mani
 }
 
 /// Materialize precisely an accepted selection; never re-list or broaden its roster.
+/// `progress` hears (present bytes, total bytes) of the selection's distinct objects.
 #[allow(clippy::too_many_arguments)]
 pub fn materialize_selected(
     store: &Store,
@@ -801,7 +802,7 @@ pub fn materialize_selected(
     policy: &SourcePolicy,
     credentials: &dyn CredentialProvider,
     deadline: Deadline,
-    progress: &mut dyn FnMut(&str, u64),
+    progress: crate::transport::SourceProgress<'_>,
 ) -> Result<(crate::source_artifact::TreeRoot, Vec<Pulled>)> {
     materialize_selected_with_options(
         store,
@@ -815,7 +816,7 @@ pub fn materialize_selected(
     )
 }
 
-/// Native development fault points and checkpoint sizing for source qualification.
+/// Stream count, checkpoint sizing, cancellation and development fault points.
 #[allow(clippy::too_many_arguments)]
 pub fn materialize_selected_with_options(
     store: &Store,
@@ -824,7 +825,7 @@ pub fn materialize_selected_with_options(
     policy: &SourcePolicy,
     credentials: &dyn CredentialProvider,
     deadline: Deadline,
-    progress: &mut dyn FnMut(&str, u64),
+    progress: crate::transport::SourceProgress<'_>,
     options: &crate::transport::SourceDownload,
 ) -> Result<(crate::source_artifact::TreeRoot, Vec<Pulled>)> {
     use crate::ids::Doc;
@@ -833,35 +834,54 @@ pub fn materialize_selected_with_options(
     let mut writer = crate::source_artifact::Writer::open(store, owner, tree.object_ref())?;
     let objects = resolution.objects();
     let (plan, _) = FetchPlan::of_objects(store, "selected-source", &objects)?;
-    let ledger = Ledger::new();
-    let mut pulled = vec![];
+    let mut ledger = Ledger::new();
+    if let Some(cancellation) = &options.cancellation {
+        ledger = ledger.with_cancellation(cancellation.clone());
+    }
+    // Every member's liveness is published before any of their bytes move.
+    let mut jobs: Vec<crate::transport::prefix::SourceJob> = vec![];
+    let (mut seen, mut held_bytes) = (std::collections::BTreeSet::new(), 0);
     for member in &resolution.members {
         writer.hold_expected(&member.object)?;
-        let held = matches!(store.record_valid(&member.object.sha256), Ok(row) if row.length == member.object.length);
-        let transferred = if held {
-            0
-        } else {
-            let grant = DeliveryGrant::mint(&plan, &member.object)?;
-            crate::transport::prefix::fetch_source(
-                store,
-                owner,
-                &grant,
-                &member.url,
-                policy,
-                credentials,
-                deadline,
-                &ledger,
-                options,
-                Some(&mut |bytes| progress(&member.member, bytes)),
-            )?
-            .transferred
-        };
+        let object = &member.object;
+        if !seen.insert(&object.sha256) {
+            continue;
+        }
+        if matches!(store.record_valid(&object.sha256), Ok(row) if row.length == object.length) {
+            held_bytes += object.length;
+            continue;
+        }
+        jobs.push(crate::transport::prefix::SourceJob {
+            grant: DeliveryGrant::mint(&plan, object)?,
+            url: member.url.clone(),
+        });
+    }
+    let transferred = crate::transport::prefix::fetch_sources(
+        store,
+        owner,
+        &jobs,
+        policy,
+        credentials,
+        deadline,
+        &ledger,
+        options,
+        held_bytes,
+        progress,
+    )?;
+    let mut pulled = vec![];
+    let mut counted = std::collections::BTreeSet::new();
+    for member in &resolution.members {
         writer.landed(&member.object)?;
+        let first = counted.insert(&member.object.sha256);
+        let fetched = jobs
+            .iter()
+            .position(|job| job.grant.object == member.object)
+            .filter(|_| first);
         pulled.push(Pulled {
             member: member.member.clone(),
             object: member.object.clone(),
-            transferred,
-            held,
+            transferred: fetched.map_or(0, |at| transferred[at]),
+            held: fetched.is_none(),
         });
     }
     plan.complete(store)?;
@@ -2475,7 +2495,7 @@ mod tests {
             &endpoints.policy(&uri),
             &Anonymous,
             Deadline::none(),
-            &mut |_, _| {},
+            &|_, _| {},
         )
         .unwrap();
         assert_eq!(
@@ -2492,7 +2512,7 @@ mod tests {
             &endpoints.policy(&uri),
             &Anonymous,
             Deadline::none(),
-            &mut |_, _| {},
+            &|_, _| {},
         )
         .unwrap();
         assert_eq!(warm, cold);
@@ -2646,7 +2666,7 @@ mod tests {
             &endpoints.policy(&uri),
             &Anonymous,
             Deadline::none(),
-            &mut |_, _| {},
+            &|_, _| {},
         )
         .unwrap_err();
         assert_eq!(error.code, Code::OBJECT_ID_MISMATCH);
@@ -2698,7 +2718,7 @@ mod tests {
             &endpoints.policy(&uri),
             &Anonymous,
             Deadline::none(),
-            &mut |_, _| {},
+            &|_, _| {},
         )
         .unwrap();
         assert!(retained.complete && !retained.released);

{tensorfs-0.3.57 → tensorfs-0.3.58}/crates/tensorfs-core/src/transport/http.rs

@@ -157,20 +157,21 @@ type IdlePool = Arc<Mutex<Vec<Idle>>>;
 // This bounds retained descriptors, not in-flight transfers (the caller owns those).
 const MAX_IDLE: usize = 8;
 
+/// A connection belongs to its origin and the credentials sent on it, never to one
+/// request target: a signed CDN URL changes per resolve, and keying on it meant the
+/// delivery hop never reused a socket.
 #[derive(PartialEq, Eq)]
 struct Scope {
     https: bool,
     host: String,
     port: u16,
-    // Do not retain signed targets or credentials in an idle connection's key.
+    // Do not retain credentials in an idle connection's key.
     request: [u8; 32],
 }
 
 impl Scope {
     fn ranged(checked: &CheckedUrl, headers: &[(String, String)]) -> Self {
         let mut hash = crate::sha256::Sha256::new();
-        hash.update(&(checked.target.len() as u64).to_le_bytes());
-        hash.update(checked.target.as_bytes());
         for (name, value) in headers
             .iter()
             .filter(|(name, _)| !name.eq_ignore_ascii_case("range"))
@@ -532,6 +533,34 @@ impl<'l> Response<'l> {
         self.body
     }
 
+    /// Drop a small non-artifact body (a redirect's, a refusal's) by reading it to its end,
+    /// so the connection can serve the next ask. Nothing read here is counted; a body
+    /// larger than a response head is simply left, and its connection closes.
+    pub fn discard(self) {
+        let mut body = self.body;
+        let mut buf = [0u8; 4096];
+        let mut left = HEAD_MAX_BYTES;
+        while left > 0 {
+            match body.read_framed(&mut buf[..left.min(4096)]) {
+                Ok(0) | Err(_) => return,
+                Ok(n) => left -= n,
+            }
+        }
+    }
+
+    /// The wait this answer states (`Retry-After`), read in the origin's own clock:
+    /// delta-seconds, or an HTTP-date against the answer's own `Date`. `None` when it
+    /// states nothing readable.
+    pub fn stated_wait(&self) -> Option<Duration> {
+        let value = self.header("retry-after")?.trim();
+        if let Ok(seconds) = value.parse::<u64>() {
+            return Some(Duration::from_secs(seconds));
+        }
+        let at = http_date(value)?;
+        let now = http_date(self.header("date")?)?;
+        Some(Duration::from_secs(at.saturating_sub(now)))
+    }
+
     /// The whole body, refused above `cap` rather than truncated.
     pub fn read_capped(mut self, cap: usize) -> Result<Vec<u8>> {
         let mut out = Vec::new();
@@ -552,6 +581,37 @@ impl<'l> Response<'l> {
     }
 }
 
+/// RFC 9110 IMF-fixdate (`Sun, 06 Nov 1994 08:49:37 GMT`) as Unix seconds.
+fn http_date(text: &str) -> Option<u64> {
+    const MONTHS: [&str; 12] = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ];
+    let mut parts = text.split_whitespace().skip(1);
+    let day: i64 = parts.next()?.parse().ok()?;
+    let month = parts.next()?;
+    let month = MONTHS.iter().position(|name| *name == month)? as i64 + 1;
+    let year: i64 = parts.next()?.parse().ok()?;
+    let clock: Vec<i64> = parts
+        .next()?
+        .split(':')
+        .map(|part| part.parse().ok())
+        .collect::<Option<_>>()?;
+    if parts.next()? != "GMT" || clock.len() != 3 {
+        return None;
+    }
+    // Days from the civil calendar (Hinnant).
+    let (y, m) = if month <= 2 {
+        (year - 1, month + 9)
+    } else {
+        (year, month - 3)
+    };
+    let era = y.div_euclid(400);
+    let yoe = y - era * 400;
+    let doe = yoe * 365 + yoe / 4 - yoe / 100 + (153 * m + 2) / 5 + day - 1;
+    let days = era * 146_097 + doe - 719_468;
+    u64::try_from(days * 86_400 + clock[0] * 3600 + clock[1] * 60 + clock[2]).ok()
+}
+
 #[derive(Clone, Copy)]
 enum Framing {
     Length { remaining: u64 },

{tensorfs-0.3.57 → tensorfs-0.3.58}/crates/tensorfs-core/src/transport/http_reuse_tests.rs

@@ -243,7 +243,7 @@ fn complete_ranged_http_and_tls_bodies_reuse_one_connection() {
 }
 
 #[test]
-fn cached_peer_must_remain_checked_and_credentials_and_signed_target_stay_scoped() {
+fn cached_peer_must_remain_checked_and_credentials_stay_scoped_but_signed_targets_share() {
     let origin = Origin::new(false, Duration::ZERO, |_, _| Reply::body(b"checked"));
     let client = origin.client();
     let checked = origin.checked("/object?signature=one");
@@ -260,8 +260,9 @@ fn cached_peer_must_remain_checked_and_credentials_and_signed_target_stay_scoped
     ask(&client, &checked, &headers).unwrap();
     headers[1].1 = "Bearer second".into();
     ask(&client, &checked, &headers).unwrap();
+    // A re-signed delivery URL on the same origin and credentials rides the same socket.
     ask(&client, &origin.checked("/object?signature=two"), &headers).unwrap();
-    assert_eq!(origin.count(), 4);
+    assert_eq!(origin.count(), 3);
     let calls = origin.asks.lock().unwrap();
     assert_eq!(
         calls
@@ -357,12 +358,9 @@ fn idle_descriptor_retention_is_bounded_and_non_range_gets_do_not_pool() {
     let origin = Origin::new(false, Duration::ZERO, |_, _| Reply::body(b"bytes"));
     let client = origin.client();
     for index in 0..32 {
-        ask(
-            &client,
-            &origin.checked(&format!("/object/{index}")),
-            &ranged(),
-        )
-        .unwrap();
+        let mut headers = ranged();
+        headers.push(("authorization".into(), format!("Bearer {index}")));
+        ask(&client, &origin.checked("/object"), &headers).unwrap();
     }
     assert_eq!(client.idle.lock().unwrap().len(), MAX_IDLE);
     assert_eq!(origin.count(), 32);
@@ -583,21 +581,25 @@ fn retained_source_redirect_ranges_reduce_connections_without_changing_asks_or_b
             &Origin::policy(),
             credentials,
             Deadline::none(),
-            &mut |_, _| {},
+            &|_, _| {},
             &SourceDownload {
                 checkpoint_bytes: 1 << 20,
+                streams: 1,
                 fault: Fault::default(),
+                ..Default::default()
             },
         )
         .unwrap();
         let elapsed = start.elapsed();
         assert_eq!(rows[0].transferred, bytes.len() as u64);
         assert!(store.record_valid(&object.sha256).is_ok());
-        assert_eq!(origin.asks.lock().unwrap().len(), 16);
-        assert_eq!(origin.count(), if close { 16 } else { 2 });
+        // One ask walks the redirect, one GET carries all eight checkpoints of the run,
+        // and the drained redirect's socket serves the delivery hop.
+        assert_eq!(origin.asks.lock().unwrap().len(), 2);
+        assert_eq!(origin.count(), if close { 2 } else { 1 });
         timings.push((close, elapsed.as_secs_f64(), origin.count()));
         drop(store);
         std::fs::remove_dir_all(root).unwrap();
     }
-    println!("retained source 8MiB, eight 1MiB ranges, one redirect/range, 30ms connection setup: {timings:?}");
+    println!("retained source 8MiB, one redirected ask, eight 1MiB checkpoints, 30ms connection setup: {timings:?}");
 }

{tensorfs-0.3.57 → tensorfs-0.3.58}/crates/tensorfs-core/src/transport/ledger.rs

@@ -135,7 +135,7 @@ pub struct Still {
 
 /// One caller's cooperative stop signal. Clones name the same pull intent;
 /// a resumed operation uses a new token and retains existing Store bytes.
-#[derive(Clone, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PullCancellation(Arc<AtomicBool>);
 
 impl PullCancellation {
@@ -357,6 +357,33 @@ impl Ledger {
         worst.mul_f64(STALL_FACTOR).max(self.patience())
     }
 
+    /// What a retryable answer costs before the re-ask: the origin's own stated wait,
+    /// which is not a failed attempt, or — when it states none — this pull's patience,
+    /// which is (`true`). The hub's rule, applied to every origin.
+    pub(crate) fn retry_wait(&self, stated: Option<Duration>) -> (Duration, bool) {
+        match stated.filter(|wait| !wait.is_zero()) {
+            Some(wait) => (wait, false),
+            None => (self.patience(), true),
+        }
+    }
+
+    /// Sleep `wait` in sampling ticks; cancellation and the caller's deadline end it.
+    pub(crate) fn pause(&self, wait: Duration, deadline: Deadline) -> Result<()> {
+        let until = Instant::now() + wait;
+        loop {
+            self.check_running()?;
+            let now = Instant::now();
+            if now >= until {
+                return Ok(());
+            }
+            let mut tick = (until - now).min(self.sample);
+            if let Some(left) = deadline.remaining()? {
+                tick = tick.min(left);
+            }
+            std::thread::sleep(tick);
+        }
+    }
+
     /// What this pull has moved and how long it has been still.
     pub fn still(&self) -> Still {
         let progress = self.progress.lock().unwrap();

{tensorfs-0.3.57 → tensorfs-0.3.58}/crates/tensorfs-core/src/transport/mod.rs

@@ -63,4 +63,4 @@ pub use pull::{
 pub use push::{push_object, Pushed, UploadGrant, MAX_GRANT_BYTES, PUT_ATTEMPTS};
 pub use ranged::{fetch_ranged, Ranged, PART_BYTES, RANGED_MIN_BYTES, SOURCE_STREAMS};
 
-pub use prefix::SourceDownload;
+pub use prefix::{SourceDownload, SourceProgress};

{tensorfs-0.3.57 → tensorfs-0.3.58}/crates/tensorfs-core/src/transport/policy.rs

@@ -145,6 +145,19 @@ pub struct CheckedUrl {
     pub addrs: Vec<SocketAddr>,
 }
 
+impl CheckedUrl {
+    /// The URL this check admitted, as a string a later ask can start from.
+    pub fn url(&self) -> String {
+        let scheme = if self.https { "https" } else { "http" };
+        let host = if self.host.contains(':') {
+            format!("[{}]", self.host)
+        } else {
+            self.host.clone()
+        };
+        format!("{scheme}://{host}:{}{}", self.port, self.target)
+    }
+}
+
 /// The deployment's declared egress bound. Carried by every caller that hands this module
 /// a URL; enforced on the first URL and on every redirect hop, because the hops are only
 /// visible here.