sliftutils 1.7.54 → 1.7.56

package/storage/remoteStorage/sourceWrapper.d.ts

@@ -37,11 +37,11 @@ export declare class SourceWrapper {
     private pings;
     private pingTimer;
     private loggedConnected;
-    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted remotes are pinged; our own local server counts as 0, everything else as Infinity. */
+    /** Starts measuring this source's latency, which decides which hosts reads and variable-shard writes prefer. Hosted remotes ping over their API connection; URL-only sources (read-only mode, backblaze without credentials) probe over plain HTTPS instead - the client NEEDS their latency too, or it cannot rank the hosts it reads from. Our own local server counts as 0; only sources with neither form stay Infinity. */
     startPinging(): void;
     /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing fetch), so variable-shard picking has something immediately. Real pings take over from the first measurement on. */
     seedLatency(ms: number): void;
-    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our own in-process server, which is the best possible target (0). */
+    /** Median of the recent pings (API or URL-form, whichever this source measures). Sources with no measurements yet sort last (Infinity), except our own in-process server, which is the best possible target (0). */
     getLatency(): number;
     /** Writes always go through the API, so a permission error throws to the caller on every write (and access granted in the meantime is picked up automatically). */
     write<T>(run: (archives: IArchives) => Promise<T>): Promise<T>;

package/storage/remoteStorage/sourceWrapper.ts

@@ -204,16 +204,30 @@ export class SourceWrapper {
     private pingTimer: ReturnType<typeof setInterval> | undefined;
     private loggedConnected = false;
 
-    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted remotes are pinged; our own local server counts as 0, everything else as Infinity. */
+    /** Starts measuring this source's latency, which decides which hosts reads and variable-shard writes prefer. Hosted remotes ping over their API connection; URL-only sources (read-only mode, backblaze without credentials) probe over plain HTTPS instead - the client NEEDS their latency too, or it cannot rank the hosts it reads from. Our own local server counts as 0; only sources with neither form stay Infinity. */
     public startPinging(): void {
-        const remote = this.remote;
-        if (!remote || this.pingTimer || this.disposed) return;
-        // Latency only decides which shard a variable-shard write materializes into, and a source whose window has passed never receives writes - so measuring it is pointless traffic
+        if (this.pingTimer || this.disposed) return;
+        // A source whose window has passed never receives reads or writes - measuring it is pointless traffic
         if (this.config.validWindow[1] <= Date.now()) return;
+        const remote = this.remote;
+        const url = this.url;
+        let probe: () => Promise<void>;
+        if (remote) {
+            probe = async () => {
+                await remote.ping();
+            };
+        } else if (url) {
+            // A 1-byte ranged read of the routing file transfers essentially nothing, and unlike an explicit OPTIONS request it needs no CORS preflight (backblaze's CORS rules only allow download operations) - so it works from the browser, which is exactly where URL-only mode runs
+            probe = async () => {
+                await url.getInfo(ROUTING_FILE);
+            };
+        } else {
+            return;
+        }
         let measure = async () => {
             let start = Date.now();
             try {
-                await remote.ping();
+                await probe();
             } catch {
                 // A failed ping is also our earliest down-detection
                 this.noteFailure();
@@ -241,12 +255,10 @@ export class SourceWrapper {
         this.pings.push(ms);
     }
 
-    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our own in-process server, which is the best possible target (0). */
+    /** Median of the recent pings (API or URL-form, whichever this source measures). Sources with no measurements yet sort last (Infinity), except our own in-process server, which is the best possible target (0). */
     public getLatency(): number {
-        if (!this.remote) {
-            if (this.config.type === "remote" && this.api) return 0;
-            return Infinity;
-        }
+        // Our own in-process server: hosted (type remote), api present, but no remote connection - it IS us
+        if (!this.remote && this.config.type === "remote" && this.api) return 0;
         if (!this.pings.length) return Infinity;
         let sorted = [...this.pings];
         sort(sorted, x => x);

package/storage/remoteStorage/storageController.ts

@@ -59,10 +59,11 @@ export type AccessState = {
 
 const sessions = new Map<string, string>();
 
+// We must never serve anything that can be evaluated as code (html, js - and svg, which can embed <script> and runs it when visited as a document). Otherwise a user could host a file and, by visiting it, run it on our domain - giving them access to all of our keys and cookies. PDF stays: browser PDF viewers run any embedded PDF scripting in a sandbox with no access to the serving origin's cookies or DOM.
 const CONTENT_TYPES: { [ext: string]: string } = {
-    html: "text/html; charset=utf-8", js: "text/javascript; charset=utf-8", css: "text/css; charset=utf-8", json: "application/json; charset=utf-8",
+    css: "text/css; charset=utf-8", json: "application/json; charset=utf-8",
     txt: "text/plain; charset=utf-8", png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif",
-    svg: "image/svg+xml", webp: "image/webp", mp4: "video/mp4", webm: "video/webm",
+    webp: "image/webp", mp4: "video/mp4", webm: "video/webm",
     mp3: "audio/mpeg", wav: "audio/wav", pdf: "application/pdf",
 };
 

package/storage/remoteStorage/storageServerState.ts

@@ -510,6 +510,7 @@ function buildBucket(account: string, bucketName: string, routing: RemoteConfig,
             validWindow: spec.validWindow,
             route: spec.route,
             noFullSync: spec.noFullSync,
+            intermediate: spec.sourceConfig?.intermediate,
             identity: sourceIdentity(spec.sourceConfig),
         }));
         store = new BlobStore(folder, sources, {
@@ -609,6 +610,7 @@ async function checkRoutingChanged(account: string, bucketName: string, config?:
                 validWindow: spec.validWindow,
                 route: spec.route,
                 noFullSync: spec.noFullSync,
+                intermediate: sourceConfig.intermediate,
                 create: () => createApiArchives(sourceConfig),
             };
         }));