sliftutils 1.7.118 → 1.7.119

package/storage/remoteStorage/intermediateManagement.ts

@@ -188,11 +188,9 @@ async function maintainIntermediates(): Promise<void> {
         let key = `${account}/${bucketName}`;
         let newest = await readNewestRoutingFile(account, bucketName);
         if (!newest) continue;
-        let routing: RemoteConfig;
-        try {
-            routing = parseRoutingData(newest.data);
-        } catch (e) {
-            console.error(`Skipping switchover maintenance for bucket ${key}: its routing config could not be parsed (${(e as Error).message})`);
+        let routing = parseRoutingData(newest.data);
+        if (!routing) {
+            console.error(`Skipping switchover maintenance for bucket ${key}: its routing config could not be parsed`);
             continue;
         }
         let expired = expireIntermediateSources(routing, Date.now());

package/storage/remoteStorage/remoteConfig.d.ts

@@ -60,5 +60,6 @@ export declare function assertValidRemoteConfig(config: RemoteConfig): void;
 export declare function sourceIdentity(sourceConfig: SourceConfig | undefined): string;
 /** What an index entry records as the holder of its bytes (see ArchivesSource.url), so it must name the endpoint FOREVER. An intermediate is a switchover's temporary alternate port onto another source, and that port is gone for good once its window passes - so it is recorded as the source it was split out of, which holds the same bucket and outlives it. */
 export declare function sourcePersistentUrl(sourceConfig: SourceConfig | undefined, folder: string): string;
-export declare function parseRoutingData(data: Buffer): RemoteConfig;
+/** Reads a stored routing config. NEVER throws: this runs on every READ of a stored config, and a torn/corrupt file must not brick the paths that would fix it - above all writeRoutingConfig, where throwing while reading the OLD config blocks the write of the NEW one forever. Unreadable data is logged and read as undefined - the same as the file not existing. Judging a config on its way IN is the writer's job (see assertValidRemoteConfig at the write entry points), where rejecting bad data with a throw is correct. */
+export declare function parseRoutingData(data: Buffer): RemoteConfig | undefined;
 export declare function serializeRemoteConfig(config: RemoteConfig): Buffer;

package/storage/remoteStorage/remoteConfig.ts

@@ -288,16 +288,19 @@ function storeIdentity(source: SourceConfig): string {
     return `${source.intermediate || source.url}|${source.name}`;
 }
 
-export function parseRoutingData(data: Buffer): RemoteConfig {
+/** Reads a stored routing config. NEVER throws: this runs on every READ of a stored config, and a torn/corrupt file must not brick the paths that would fix it - above all writeRoutingConfig, where throwing while reading the OLD config blocks the write of the NEW one forever. Unreadable data is logged and read as undefined - the same as the file not existing. Judging a config on its way IN is the writer's job (see assertValidRemoteConfig at the write entry points), where rejecting bad data with a throw is correct. */
+export function parseRoutingData(data: Buffer): RemoteConfig | undefined {
     let text = data.toString();
     let parsed: RemoteConfig;
     try {
         parsed = JSON.parse(text) as RemoteConfig;
     } catch (e) {
-        throw new Error(`Routing config is not valid JSON (${String(e)}). Data: ${text.slice(0, 500)}`);
+        console.error(`Ignoring a stored routing config - it is not valid JSON (${String(e)}). Data: ${JSON.stringify(text).slice(0, 500)}`);
+        return undefined;
     }
     if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.sources)) {
-        throw new Error(`Routing config must be { version?, sources: [...] }, was ${text.slice(0, 500)}`);
+        console.error(`Ignoring a stored routing config - it must be { version?, sources: [...] }, was ${text.slice(0, 500)}`);
+        return undefined;
     }
     return normalizeRemoteConfig(parsed);
 }

package/storage/remoteStorage/storageServerState.ts

@@ -193,6 +193,9 @@ export async function writeRoutingConfig(account: string, bucketName: string, na
     assertWritesAllowed();
     let store = getStore(account, bucketName, name);
     let incoming = parseRoutingData(data);
+    if (!incoming) {
+        throw new Error(`Routing config write rejected - not a parseable config. The data written for ${account}/${bucketName} (store ${JSON.stringify(name)}) is not a valid { version?, sources: [...] } JSON config (${data.length} bytes)`);
+    }
     let current = await readRoutingFromDisk(account, bucketName);
     let stored = reinjectIntermediates(current, incoming);
     let storedData = Buffer.from(serializeRemoteConfig(stored));

package/storage/remoteStorage/storeSync.ts

@@ -127,7 +127,9 @@ export class StoreSync {
             try {
                 let theirs = await source.get2(ROUTING_FILE, { internal: true });
                 if (!theirs || !theirs.data || !theirs.data.length) continue;
-                let version = getConfigVersion(parseRoutingData(theirs.data));
+                let theirRouting = parseRoutingData(theirs.data);
+                if (!theirRouting) continue;
+                let version = getConfigVersion(theirRouting);
                 if (version <= this.store.routingVersion()) continue;
                 console.log(`Routing config version ${version} found on ${source.getDebugName()} (we have ${this.store.routingVersion()}, store ${this.store.folder}): taking it`);
                 // Stamped NOW, not with their write time: configs are ordered by version, and this one is newer by that ordering. Their file can easily be older by write time (ours was rewritten locally more recently), and the store's only-take-the-latest rule would then drop it - leaving us finding the same newer version on every poll and never adopting it.