tensorfs 0.3.57__tar.gz → 0.3.59__tar.gz

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

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

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

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

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

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

{tensorfs-0.3.57 → tensorfs-0.3.59}/crates/tensorfs-core/src/catalog.rs

@@ -911,9 +911,14 @@ impl Catalog {
         object: &crate::ids::ObjectRef,
         publish: impl FnOnce() -> Result<Option<crate::store::VRecord>>,
     ) -> Result<bool> {
+        // One admission at a time per catalog in this process, holding the write lock from
+        // before publication: streams landing objects together queue here instead of in
+        // SQLite's busy timeout, where a lost race refused bytes already verified.
+        let turn = admissions(&self.path);
+        let _turn = turn.lock().unwrap_or_else(|error| error.into_inner());
         let mut connection = self.connection()?;
         let transaction = connection
-            .transaction()
+            .transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)
             .map_err(|error| sql("begin blob admission", error))?;
         if let Some(operation) = operation {
             hold_on(
@@ -1079,6 +1084,17 @@ impl Catalog {
     }
 }
 
+fn admissions(path: &Path) -> Arc<Mutex<()>> {
+    static TURNS: OnceLock<Mutex<HashMap<PathBuf, Arc<Mutex<()>>>>> = OnceLock::new();
+    TURNS
+        .get_or_init(Default::default)
+        .lock()
+        .unwrap_or_else(|error| error.into_inner())
+        .entry(path.to_path_buf())
+        .or_default()
+        .clone()
+}
+
 fn hold_on(connection: &Connection, operation: &str, key: &str, length: u64) -> Result<()> {
     let kind = if key.starts_with("blobs/") {
         "blob"

{tensorfs-0.3.57 → tensorfs-0.3.59}/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.59}/crates/tensorfs-core/src/transport/http.rs

@@ -60,6 +60,11 @@ pub enum Judge {
     /// which is the owner's rule read literally: the lack of measured progress, never a
     /// number of seconds.
     Transfer,
+    /// An UPLOAD. Every wait — connect, handshake, each write, and the answer after the
+    /// last body byte — is judged by this exchange's own silence against the ledger's
+    /// patience. Nothing it moves lands here, so it neither counts as progress nor teaches
+    /// the pace.
+    Silence,
     /// Neither. The caller's deadline is the only bound, which is what a foreign-source
     /// read with its own per-part retry loop above it already had.
     Deadline,
@@ -133,7 +138,7 @@ fn transfer_verdict(
 /// 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() {
+    if !judge.silent_is_stall() || advanced.elapsed() <= ledger.patience() {
         return Ok(());
     }
     refuse(
@@ -147,6 +152,12 @@ fn stream_verdict(judge: Judge, ledger: &Ledger, advanced: Instant, phase: &str)
     )
 }
 
+impl Judge {
+    fn silent_is_stall(self) -> bool {
+        matches!(self, Judge::Stream | Judge::Silence)
+    }
+}
+
 pub struct Client {
     tls: Arc<rustls::ClientConfig>,
     idle: IdlePool,
@@ -157,20 +168,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 +544,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 +592,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 },
@@ -652,7 +723,7 @@ impl BodyReader<'_> {
                 Err(e) if would_block(&e) => {
                     transfer_verdict(self.judge, self.ledger, self.since, "a response body")?;
                     let silent = self.advanced.elapsed();
-                    if self.judge == Judge::Stream && silent > self.ledger.patience() {
+                    if self.judge.silent_is_stall() && silent > self.ledger.patience() {
                         self.stalled = true;
                         let _ = self
                             .wire

{tensorfs-0.3.57 → tensorfs-0.3.59}/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.59}/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.59/crates/tensorfs-core/src/transport/memory.rs

@@ -0,0 +1,92 @@
+//! How many transfer streams fit in the memory this process can actually use. There is no
+//! assumed host: a 4 GB pod runs the same pull, source download or upload window with fewer
+//! streams, never with N × buffers it does not have.
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// The most memory one transfer stream holds, whatever its object's size: one 1 MiB body
+/// chunk (the read, write, hash or upload buffer), the 64 KiB framing buffer, and rustls's
+/// bounded record buffers, rounded up to a whole 2 MiB.
+pub const STREAM_MEMORY: u64 = 2 << 20;
+
+/// Bytes this process can still use now: the tightest of its cgroup's limit less the usage
+/// that cannot be reclaimed (v2 at every ancestor, else v1) and the host's `MemAvailable`.
+/// `None` when none of them is readable.
+pub fn memory_available() -> Option<u64> {
+    [cgroup_v2(), cgroup_v1(), mem_available()]
+        .into_iter()
+        .flatten()
+        .min()
+}
+
+/// Concurrent transfer streams the memory available now allows: at most `wanted`, at
+/// least one.
+pub fn transfer_streams(wanted: usize) -> usize {
+    streams_within(wanted, memory_available())
+}
+
+/// `transfer_streams` against a stated budget.
+pub fn streams_within(wanted: usize, available: Option<u64>) -> usize {
+    let fits = available.map_or(usize::MAX, |bytes| {
+        usize::try_from(bytes / STREAM_MEMORY).unwrap_or(usize::MAX)
+    });
+    wanted.min(fits).max(1)
+}
+
+fn number(path: &Path) -> Option<u64> {
+    fs::read_to_string(path).ok()?.trim().parse().ok()
+}
+
+/// `limit − (usage − page cache)`: page cache is reclaimed under pressure, so bytes a
+/// download has written do not count against the next stream.
+fn headroom(dir: &Path, limit: &str, usage: &str, cache: &str) -> Option<u64> {
+    let limit = number(&dir.join(limit))?;
+    let usage = number(&dir.join(usage))?;
+    let cached = fs::read_to_string(dir.join("memory.stat"))
+        .ok()
+        .and_then(|stat| {
+            stat.lines()
+                .find_map(|line| line.strip_prefix(cache)?.strip_prefix(' ')?.parse().ok())
+        })
+        .unwrap_or(0);
+    Some(limit.saturating_sub(usage.saturating_sub(cached)))
+}
+
+fn cgroup_v2() -> Option<u64> {
+    let root = Path::new("/sys/fs/cgroup");
+    let own = fs::read_to_string("/proc/self/cgroup").ok()?;
+    let own = own.lines().find_map(|line| line.strip_prefix("0::"))?;
+    let mut dir = root.join(own.trim().trim_start_matches('/'));
+    let mut tightest: Option<u64> = None;
+    loop {
+        if let Some(left) = headroom(&dir, "memory.max", "memory.current", "file") {
+            tightest = Some(tightest.map_or(left, |held| held.min(left)));
+        }
+        if dir == root || !dir.pop() || !dir.starts_with(root) {
+            return tightest;
+        }
+    }
+}
+
+fn cgroup_v1() -> Option<u64> {
+    let dir = PathBuf::from("/sys/fs/cgroup/memory");
+    headroom(
+        &dir,
+        "memory.limit_in_bytes",
+        "memory.usage_in_bytes",
+        "total_cache",
+    )
+}
+
+fn mem_available() -> Option<u64> {
+    let text = fs::read_to_string("/proc/meminfo").ok()?;
+    let kib: u64 = text
+        .lines()
+        .find_map(|line| line.strip_prefix("MemAvailable:"))?
+        .trim()
+        .strip_suffix("kB")?
+        .trim()
+        .parse()
+        .ok()?;
+    kib.checked_mul(1024)
+}

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

@@ -35,6 +35,7 @@ mod api;
 mod http;
 mod hub;
 mod ledger;
+mod memory;
 mod policy;
 pub(crate) mod prefix;
 mod pull;
@@ -55,6 +56,7 @@ pub use ledger::{
     Deadline, Ledger, PullCancellation, FETCH_ATTEMPTS, SAMPLE_SECONDS, STALL_FACTOR,
     STILL_SAMPLES, STREAMS,
 };
+pub use memory::{memory_available, streams_within, transfer_streams, STREAM_MEMORY};
 pub use policy::{base_host, blocked, is_loopback_origin, resolve, CheckedUrl, SourcePolicy};
 pub use pull::{
     fetch_authorized, fetch_url, fetch_wanted, pull, FetchObserver, Fetched, ObjectSource,
@@ -63,4 +65,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.59}/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.