@fluidframework/container-runtime 2.60.0 → 2.61.0-355516

package/lib/blobManager/blobManager.d.ts

@@ -39,7 +39,7 @@ export declare class BlobHandle extends FluidHandleBase<ArrayBufferLike> impleme
     readonly notifyFailed: (error: unknown) => void;
     attachGraph(): void;
 }
-export type IBlobManagerRuntime = Pick<IContainerRuntime, "attachState" | "connected" | "baseLogger" | "clientDetails" | "disposed"> & IEventProvider<IContainerRuntimeEvents>;
+export type IBlobManagerRuntime = Pick<IContainerRuntime, "attachState" | "baseLogger" | "disposed"> & IEventProvider<IContainerRuntimeEvents>;
 export interface IPendingBlobs {
     [localId: string]: {
         blob: string;
@@ -59,11 +59,10 @@ export declare class BlobManager {
     get events(): Listenable<IBlobManagerEvents>;
     private readonly internalEvents;
     /**
-     * Map of local IDs to storage IDs. Contains identity entries (storageId → storageId) for storage IDs. All requested IDs should
-     * be a key in this map. Blobs created while the container is detached are stored in IDetachedBlobStorage which
-     * gives local IDs; the storage IDs are filled in at attach time.
-     * Note: It contains mappings from all clients, i.e., from remote clients as well. local ID comes from the client
-     * that uploaded the blob but its mapping to storage ID is needed in all clients in order to retrieve the blob.
+     * Map of local IDs to storage IDs. Also includes identity mappings of storage ID to storage ID for all known
+     * storage IDs. All requested IDs must be a key in this map. Blobs created while the container is detached are
+     * stored in IDetachedBlobStorage which gives pseudo storage IDs; the real storage IDs are filled in at attach
+     * time via setRedirectTable().
      */
     private readonly redirectTable;
     /**
@@ -82,7 +81,7 @@ export declare class BlobManager {
     private readonly blobRequested;
     private readonly isBlobDeleted;
     private readonly runtime;
-    private readonly localBlobIdGenerator;
+    private readonly localIdGenerator;
     private readonly createBlobPayloadPending;
     constructor(props: {
         readonly routeContext: IFluidHandleContext;
@@ -103,20 +102,31 @@ export declare class BlobManager {
         readonly isBlobDeleted: (blobPath: string) => boolean;
         readonly runtime: IBlobManagerRuntime;
         stashedBlobs: IPendingBlobs | undefined;
-        readonly localBlobIdGenerator?: (() => string) | undefined;
+        readonly localIdGenerator?: (() => string) | undefined;
         readonly createBlobPayloadPending: boolean;
     });
     get allBlobsAttached(): boolean;
     get hasPendingBlobs(): boolean;
     private createAbortError;
-    hasBlob(blobId: string): boolean;
+    hasBlob(localId: string): boolean;
+    /**
+     * Lookup the blob storage ID for a given local blob id.
+     * @param localId - The local blob id. Likely coming from a handle.
+     * @returns The storage ID if found and the blob is not pending, undefined otherwise.
+     * @remarks
+     * For blobs with pending payloads (localId exists but upload hasn't finished), this is expected to return undefined.
+     * Consumers should use the observability APIs on the handle (handle.payloadState, payloadShared event)
+     * to understand/wait for storage ID availability.
+     * Similarly, when the runtime is detached, this will return undefined as no blobs have been uploaded to storage.
+     */
+    lookupTemporaryBlobStorageId(localId: string): string | undefined;
     /**
      * Retrieve the blob with the given local blob id.
-     * @param blobId - The local blob id.  Likely coming from a handle.
+     * @param localId - The local blob id.  Likely coming from a handle.
      * @param payloadPending - Whether we suspect the payload may be pending and not available yet.
      * @returns A promise which resolves to the blob contents
      */
-    getBlob(blobId: string, payloadPending: boolean): Promise<ArrayBufferLike>;
+    getBlob(localId: string, payloadPending: boolean): Promise<ArrayBufferLike>;
     private getBlobHandle;
     private createBlobDetached;
     createBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandleInternalPayloadPending<ArrayBufferLike>>;
@@ -163,16 +173,17 @@ export declare class BlobManager {
      * Delete blobs with the given routes from the redirect table.
      *
      * @remarks
-     * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<blobId>`. The blob ids are all local ids.
+     * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<localId>`.
      * Deleting the blobs involves 2 steps:
      *
      * 1. The redirect table entry for the local ids are deleted.
      *
-     * 2. If the storage ids corresponding to the deleted local ids are not in-use anymore, the redirect table entries
-     * for the storage ids are deleted as well.
+     * 2. If the storage ids corresponding to the deleted local ids are not referenced by any further local ids, the
+     * identity mappings in the redirect table are deleted as well.
      *
      * Note that this does not delete the blobs from storage service immediately. Deleting the blobs from redirect table
-     * will remove them the next summary. The service would them delete them some time in the future.
+     * will ensure we don't create an attachment blob for them at the next summary. The service would then delete them
+     * some time in the future.
      */
     private deleteBlobsFromRedirectTable;
     /**
@@ -180,7 +191,13 @@ export declare class BlobManager {
      * log an error and throw if necessary.
      */
     private verifyBlobNotDeleted;
-    setRedirectTable(table: Map<string, string>): void;
+    /**
+     * Called in detached state just prior to attaching, this will update the redirect table by
+     * converting the pseudo storage IDs into real storage IDs using the provided detachedStorageTable.
+     * The provided table must have exactly the same set of pseudo storage IDs as are found in the redirect table.
+     * @param detachedStorageTable - A map of pseudo storage IDs to real storage IDs.
+     */
+    readonly patchRedirectTable: (detachedStorageTable: Map<string, string>) => void;
     /**
      * To be used in getPendingLocalState flow. Get a serializable record of the blobs that are
      * pending upload and/or their BlobAttach op, which can be given to a new BlobManager to

package/lib/blobManager/blobManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blobManager.d.ts","sourceRoot":"","sources":["../../src/blobManager/blobManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"blobManager.d.ts","sourceRoot":"","sources":["../../src/blobManager/blobManager.ts"],"names":[],"mappings":"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"}

package/lib/blobManager/blobManager.js

@@ -74,20 +74,44 @@ export class BlobManager {
          * because we know that the server will not delete the blob corresponding to that storage ID.
          */
         this.opsInFlight = new Map();
-        const { routeContext, blobManagerLoadInfo, storage, sendBlobAttachOp, blobRequested, isBlobDeleted, runtime, localBlobIdGenerator, createBlobPayloadPending, } = props;
+        /**
+         * Called in detached state just prior to attaching, this will update the redirect table by
+         * converting the pseudo storage IDs into real storage IDs using the provided detachedStorageTable.
+         * The provided table must have exactly the same set of pseudo storage IDs as are found in the redirect table.
+         * @param detachedStorageTable - A map of pseudo storage IDs to real storage IDs.
+         */
+        this.patchRedirectTable = (detachedStorageTable) => {
+            assert(this.runtime.attachState === AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
+            // The values of the redirect table are the pseudo storage IDs, which are the keys of the
+            // detachedStorageTable. We expect to have a many:1 mapping from local IDs to pseudo
+            // storage IDs (many in the case that the storage dedupes the blob).
+            assert(new Set(this.redirectTable.values()).size === detachedStorageTable.size, 0x391 /* Redirect table size must match BlobManager's local ID count */);
+            // Taking a snapshot of the redirect table entries before iterating, because
+            // we will be adding identity mappings to the the redirect table as we iterate
+            // and we don't want to include those in the iteration.
+            const redirectTableEntries = [...this.redirectTable.entries()];
+            for (const [localId, detachedStorageId] of redirectTableEntries) {
+                const newStorageId = detachedStorageTable.get(detachedStorageId);
+                assert(newStorageId !== undefined, "Couldn't find a matching storage ID");
+                this.setRedirection(localId, newStorageId);
+                // set identity (id -> id) entry
+                this.setRedirection(newStorageId, newStorageId);
+            }
+        };
+        const { routeContext, blobManagerLoadInfo, storage, sendBlobAttachOp, blobRequested, isBlobDeleted, runtime, localIdGenerator, createBlobPayloadPending, } = props;
         this.routeContext = routeContext;
         this.storage = storage;
         this.blobRequested = blobRequested;
         this.isBlobDeleted = isBlobDeleted;
         this.runtime = runtime;
-        this.localBlobIdGenerator = localBlobIdGenerator ?? uuid;
+        this.localIdGenerator = localIdGenerator ?? uuid;
         this.createBlobPayloadPending = createBlobPayloadPending;
         this.mc = createChildMonitoringContext({
             logger: this.runtime.baseLogger,
             namespace: "BlobManager",
         });
-        this.redirectTable = toRedirectTable(blobManagerLoadInfo, this.mc.logger, this.runtime.attachState);
-        this.sendBlobAttachOp = (localId, blobId) => {
+        this.redirectTable = toRedirectTable(blobManagerLoadInfo, this.mc.logger);
+        this.sendBlobAttachOp = (localId, storageId) => {
             const pendingEntry = this.pendingBlobs.get(localId);
             assert(pendingEntry !== undefined, 0x725 /* Must have pending blob entry for upcoming op */);
             if (pendingEntry?.uploadTime && pendingEntry?.minTTLInSeconds) {
@@ -113,7 +137,7 @@ export class BlobManager {
                 }
             }
             pendingEntry.opsent = true;
-            sendBlobAttachOp(localId, blobId);
+            sendBlobAttachOp(localId, storageId);
         };
     }
     get allBlobsAttached() {
@@ -134,56 +158,63 @@ export class BlobManager {
             uploadTime: pending?.uploadTime,
         });
     }
-    hasBlob(blobId) {
-        return this.redirectTable.get(blobId) !== undefined;
+    hasBlob(localId) {
+        return this.redirectTable.get(localId) !== undefined;
+    }
+    /**
+     * Lookup the blob storage ID for a given local blob id.
+     * @param localId - The local blob id. Likely coming from a handle.
+     * @returns The storage ID if found and the blob is not pending, undefined otherwise.
+     * @remarks
+     * For blobs with pending payloads (localId exists but upload hasn't finished), this is expected to return undefined.
+     * Consumers should use the observability APIs on the handle (handle.payloadState, payloadShared event)
+     * to understand/wait for storage ID availability.
+     * Similarly, when the runtime is detached, this will return undefined as no blobs have been uploaded to storage.
+     */
+    lookupTemporaryBlobStorageId(localId) {
+        if (this.runtime.attachState === AttachState.Detached) {
+            return undefined;
+        }
+        // Get the storage ID from the redirect table
+        return this.redirectTable.get(localId);
     }
     /**
      * Retrieve the blob with the given local blob id.
-     * @param blobId - The local blob id.  Likely coming from a handle.
+     * @param localId - The local blob id.  Likely coming from a handle.
      * @param payloadPending - Whether we suspect the payload may be pending and not available yet.
      * @returns A promise which resolves to the blob contents
      */
-    async getBlob(blobId, payloadPending) {
+    async getBlob(localId, payloadPending) {
         // Verify that the blob is not deleted, i.e., it has not been garbage collected. If it is, this will throw
         // an error, failing the call.
-        this.verifyBlobNotDeleted(blobId);
+        this.verifyBlobNotDeleted(localId);
         // Let runtime know that the corresponding GC node was requested.
         // Note that this will throw if the blob is inactive or tombstoned and throwing on incorrect usage
         // is configured.
-        this.blobRequested(getGCNodePathFromBlobId(blobId));
-        const pending = this.pendingBlobs.get(blobId);
+        this.blobRequested(getGCNodePathFromLocalId(localId));
+        const pending = this.pendingBlobs.get(localId);
         if (pending) {
             return pending.blob;
         }
-        let storageId;
-        if (this.runtime.attachState === AttachState.Detached) {
-            assert(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
-            // Blobs created while the container is detached are stored in IDetachedBlobStorage.
-            // The 'IContainerStorageService.readBlob()' call below will retrieve these via localId.
-            storageId = blobId;
-        }
-        else {
-            const attachedStorageId = this.redirectTable.get(blobId);
-            if (!payloadPending) {
-                // Only blob handles explicitly marked with pending payload are permitted to exist without
-                // yet knowing their storage id. Otherwise they must already be associated with a storage id.
-                assert(attachedStorageId !== undefined, 0x11f /* "requesting unknown blobs" */);
-            }
-            // If we didn't find it in the redirectTable, assume the attach op is coming eventually and wait.
-            // We do this even if the local client doesn't have the blob payloadPending flag enabled, in case a
-            // remote client does have it enabled. This wait may be infinite if the uploading client failed
-            // the upload and doesn't exist anymore.
-            storageId =
-                attachedStorageId ??
-                    (await new Promise((resolve) => {
-                        const onProcessBlobAttach = (localId, _storageId) => {
-                            if (localId === blobId) {
-                                this.internalEvents.off("processedBlobAttach", onProcessBlobAttach);
-                                resolve(_storageId);
-                            }
-                        };
-                        this.internalEvents.on("processedBlobAttach", onProcessBlobAttach);
-                    }));
+        let storageId = this.redirectTable.get(localId);
+        if (storageId === undefined) {
+            // Only blob handles explicitly marked with pending payload are permitted to exist without
+            // yet knowing their storage id. Otherwise they must already be associated with a storage id.
+            // Handles for detached blobs are not payload pending.
+            assert(payloadPending, 0x11f /* "requesting unknown blobs" */);
+            // If we didn't find it in the redirectTable and it's payloadPending, assume the attach op is coming
+            // eventually and wait. We do this even if the local client doesn't have the blob payloadPending flag
+            // enabled, in case a remote client does have it enabled. This wait may be infinite if the uploading
+            // client failed the upload and doesn't exist anymore.
+            storageId = await new Promise((resolve) => {
+                const onProcessBlobAttach = (_localId, _storageId) => {
+                    if (_localId === localId) {
+                        this.internalEvents.off("processedBlobAttach", onProcessBlobAttach);
+                        resolve(_storageId);
+                    }
+                };
+                this.internalEvents.on("processedBlobAttach", onProcessBlobAttach);
+            });
         }
         return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "AttachmentReadBlob", id: storageId }, async (event) => {
             return this.storage.readBlob(storageId).catch((error) => {
@@ -207,15 +238,17 @@ export class BlobManager {
                 this.deletePendingBlobMaybe(localId);
             }
             : undefined;
-        return new BlobHandle(getGCNodePathFromBlobId(localId), this.routeContext, async () => this.getBlob(localId, false), false, // payloadPending
+        return new BlobHandle(getGCNodePathFromLocalId(localId), this.routeContext, async () => this.getBlob(localId, false), false, // payloadPending
         callback);
     }
     async createBlobDetached(blob) {
+        const localId = this.localIdGenerator();
         // Blobs created while the container is detached are stored in IDetachedBlobStorage.
-        // The 'IContainerStorageService.createBlob()' call below will respond with a localId.
-        const response = await this.storage.createBlob(blob);
-        this.setRedirection(response.id, undefined);
-        return this.getBlobHandle(response.id);
+        // The 'IContainerStorageService.createBlob()' call below will respond with a pseudo storage ID.
+        // That pseudo storage ID will be replaced with the real storage ID at attach time.
+        const { id: detachedStorageId } = await this.storage.createBlob(blob);
+        this.setRedirection(localId, detachedStorageId);
+        return this.getBlobHandle(localId);
     }
     async createBlob(blob, signal) {
         if (this.runtime.attachState === AttachState.Detached) {
@@ -237,7 +270,7 @@ export class BlobManager {
         }
         // Create a local ID for the blob. After uploading it to storage and before returning it, a local ID to
         // storage ID mapping is created.
-        const localId = this.localBlobIdGenerator();
+        const localId = this.localIdGenerator();
         const pendingEntry = {
             blob,
             handleP: new Deferred(),
@@ -259,8 +292,8 @@ export class BlobManager {
         });
     }
     createBlobWithPayloadPending(blob) {
-        const localId = this.localBlobIdGenerator();
-        const blobHandle = new BlobHandle(getGCNodePathFromBlobId(localId), this.routeContext, async () => blob, true, // payloadPending
+        const localId = this.localIdGenerator();
+        const blobHandle = new BlobHandle(getGCNodePathFromLocalId(localId), this.routeContext, async () => blob, true, // payloadPending
         () => {
             const pendingEntry = {
                 blob,
@@ -375,7 +408,7 @@ export class BlobManager {
         if (!entry.opsent) {
             this.sendBlobAttachOp(localId, response.id);
         }
-        const storageIds = getStorageIds(this.redirectTable, this.runtime.attachState);
+        const storageIds = getStorageIds(this.redirectTable);
         if (storageIds.has(response.id)) {
             // The blob is de-duped. Set up a local ID to storage ID mapping and return the blob. Since this is
             // an existing blob, we don't have to wait for the op to be ack'd since this step has already
@@ -408,7 +441,7 @@ export class BlobManager {
      */
     reSubmit(metadata) {
         assert(isBlobMetadata(metadata), 0xc01 /* Expected blob metadata for a BlobAttach op */);
-        const { localId, blobId } = metadata;
+        const { localId, blobId: storageId } = metadata;
         // Any blob that we're actively trying to advance to attached state must have a
         // pendingBlobs entry. Decline to resubmit for anything else.
         // For example, we might be asked to resubmit stashed ops for blobs that never had
@@ -416,22 +449,22 @@ export class BlobManager {
         // try to attach them since they won't be accessible to the customer and would just
         // be considered garbage immediately.
         if (this.pendingBlobs.has(localId)) {
-            this.sendBlobAttachOp(localId, blobId);
+            this.sendBlobAttachOp(localId, storageId);
         }
     }
     processBlobAttachMessage(message, local) {
         assert(isBlobMetadata(message.metadata), 0xc02 /* Expected blob metadata for a BlobAttach op */);
-        const { localId, blobId } = message.metadata;
+        const { localId, blobId: storageId } = message.metadata;
         const pendingEntry = this.pendingBlobs.get(localId);
         if (pendingEntry?.abortSignal?.aborted) {
             this.deletePendingBlob(localId);
             return;
         }
-        this.setRedirection(localId, blobId);
+        this.setRedirection(localId, storageId);
         // set identity (id -> id) entry
-        this.setRedirection(blobId, blobId);
+        this.setRedirection(storageId, storageId);
         if (local) {
-            const waitingBlobs = this.opsInFlight.get(blobId);
+            const waitingBlobs = this.opsInFlight.get(storageId);
             if (waitingBlobs !== undefined) {
                 // For each op corresponding to this storage ID that we are waiting for, resolve the pending blob.
                 // This is safe because the server will keep the blob alive and the op containing the local ID to
@@ -439,14 +472,14 @@ export class BlobManager {
                 for (const pendingLocalId of waitingBlobs) {
                     const entry = this.pendingBlobs.get(pendingLocalId);
                     assert(entry !== undefined, 0x38f /* local online BlobAttach op with no pending blob entry */);
-                    this.setRedirection(pendingLocalId, blobId);
+                    this.setRedirection(pendingLocalId, storageId);
                     entry.acked = true;
                     const blobHandle = this.getBlobHandle(pendingLocalId);
                     blobHandle.notifyShared();
                     entry.handleP.resolve(blobHandle);
                     this.deletePendingBlobMaybe(pendingLocalId);
                 }
-                this.opsInFlight.delete(blobId);
+                this.opsInFlight.delete(storageId);
             }
             const localEntry = this.pendingBlobs.get(localId);
             if (localEntry) {
@@ -457,10 +490,10 @@ export class BlobManager {
                 this.deletePendingBlobMaybe(localId);
             }
         }
-        this.internalEvents.emit("processedBlobAttach", localId, blobId);
+        this.internalEvents.emit("processedBlobAttach", localId, storageId);
     }
     summarize(telemetryContext) {
-        return summarizeBlobManagerState(this.redirectTable, this.runtime.attachState);
+        return summarizeBlobManagerState(this.redirectTable);
     }
     /**
      * Generates data used for garbage collection. Each blob uploaded represents a node in the GC graph as it can be
@@ -471,13 +504,12 @@ export class BlobManager {
     getGCData(fullGC = false) {
         const gcData = { gcNodes: {} };
         for (const [localId, storageId] of this.redirectTable) {
-            assert(!!storageId, 0x390 /* Must be attached to get GC data */);
-            // Only return local ids as GC nodes because a blob can only be referenced via its local id. The storage
-            // id entries have the same key and value, ignore them.
-            // The outbound routes are empty because a blob node cannot reference other nodes. It can only be referenced
-            // by adding its handle to a referenced DDS.
+            // Don't report the identity mappings to GC - these exist to service old handles that referenced the storage
+            // IDs directly. We'll implicitly clean them up if all of their localId references get GC'd first.
             if (localId !== storageId) {
-                gcData.gcNodes[getGCNodePathFromBlobId(localId)] = [];
+                // The outbound routes are empty because a blob node cannot reference other nodes. It can only be referenced
+                // by adding its handle to a referenced DDS.
+                gcData.gcNodes[getGCNodePathFromLocalId(localId)] = [];
             }
         }
         return gcData;
@@ -496,55 +528,53 @@ export class BlobManager {
      * Delete blobs with the given routes from the redirect table.
      *
      * @remarks
-     * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<blobId>`. The blob ids are all local ids.
+     * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<localId>`.
      * Deleting the blobs involves 2 steps:
      *
      * 1. The redirect table entry for the local ids are deleted.
      *
-     * 2. If the storage ids corresponding to the deleted local ids are not in-use anymore, the redirect table entries
-     * for the storage ids are deleted as well.
+     * 2. If the storage ids corresponding to the deleted local ids are not referenced by any further local ids, the
+     * identity mappings in the redirect table are deleted as well.
      *
      * Note that this does not delete the blobs from storage service immediately. Deleting the blobs from redirect table
-     * will remove them the next summary. The service would them delete them some time in the future.
+     * will ensure we don't create an attachment blob for them at the next summary. The service would then delete them
+     * some time in the future.
      */
     deleteBlobsFromRedirectTable(blobRoutes) {
-        if (blobRoutes.length === 0) {
-            return;
-        }
-        // This tracks the storage ids of local ids that are deleted. After the local ids have been deleted, if any of
-        // these storage ids are unused, they will be deleted as well.
+        // maybeUnusedStorageIds is used to compute the set of storage IDs that *used to have a local ID*, but that
+        // local ID is being deleted.
         const maybeUnusedStorageIds = new Set();
         for (const route of blobRoutes) {
-            const blobId = getBlobIdFromGCNodePath(route);
+            const localId = getLocalIdFromGCNodePath(route);
             // If the blob hasn't already been deleted, log an error because this should never happen.
             // If the blob has already been deleted, log a telemetry event. This can happen because multiple GC
             // sweep ops can contain the same data store. It would be interesting to track how often this happens.
             const alreadyDeleted = this.isBlobDeleted(route);
-            if (!this.redirectTable.has(blobId)) {
+            const storageId = this.redirectTable.get(localId);
+            if (storageId === undefined) {
                 this.mc.logger.sendTelemetryEvent({
                     eventName: "DeletedAttachmentBlobNotFound",
                     category: alreadyDeleted ? "generic" : "error",
-                    blobId,
+                    blobId: localId,
                     details: { alreadyDeleted },
                 });
                 continue;
             }
-            const storageId = this.redirectTable.get(blobId);
-            assert(!!storageId, 0x5bb /* Must be attached to run GC */);
             maybeUnusedStorageIds.add(storageId);
-            this.redirectTable.delete(blobId);
+            this.redirectTable.delete(localId);
         }
-        // Find out storage ids that are in-use and remove them from maybeUnusedStorageIds. A storage id is in-use if
-        // the redirect table has a local id -> storage id entry for it.
-        for (const [localId, storageId] of this.redirectTable.entries()) {
-            assert(!!storageId, 0x5bc /* Must be attached to run GC */);
-            // For every storage id, the redirect table has a id -> id entry. These do not make the storage id in-use.
-            if (maybeUnusedStorageIds.has(storageId) && localId !== storageId) {
+        // Remove any storage IDs that still have local IDs referring to them (excluding the identity mapping).
+        for (const [localId, storageId] of this.redirectTable) {
+            if (localId !== storageId) {
                 maybeUnusedStorageIds.delete(storageId);
             }
         }
-        // For unused storage ids, delete their id -> id entries from the redirect table.
-        // This way they'll be absent from the next summary, and the service is free to delete them from storage.
+        // Now delete any identity mappings (storage ID -> storage ID) from the redirect table that used to be
+        // referenced by a distinct local ID. This way they'll be absent from the next summary, and the service
+        // is free to delete them from storage.
+        // WARNING: This can potentially delete identity mappings that are still referenced, if storage deduping
+        // has let us add a local ID -> storage ID mapping that is later deleted.  AB#47337 tracks this issue
+        // and possible solutions.
         for (const storageId of maybeUnusedStorageIds) {
             this.redirectTable.delete(storageId);
         }
@@ -553,11 +583,11 @@ export class BlobManager {
      * Verifies that the blob with given id is not deleted, i.e., it has not been garbage collected. If the blob is GC'd,
      * log an error and throw if necessary.
      */
-    verifyBlobNotDeleted(blobId) {
-        if (!this.isBlobDeleted(getGCNodePathFromBlobId(blobId))) {
+    verifyBlobNotDeleted(localId) {
+        if (!this.isBlobDeleted(getGCNodePathFromLocalId(localId))) {
             return;
         }
-        const request = { url: blobId };
+        const request = { url: localId };
         const error = responseToException(createResponseError(404, `Blob was deleted`, request), request);
         // Only log deleted events. Tombstone events are logged by garbage collector.
         this.mc.logger.sendErrorEvent({
@@ -566,16 +596,6 @@ export class BlobManager {
         }, error);
         throw error;
     }
-    setRedirectTable(table) {
-        assert(this.runtime.attachState === AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
-        assert(this.redirectTable.size === table.size, 0x391 /* Redirect table size must match BlobManager's local ID count */);
-        for (const [localId, storageId] of table) {
-            assert(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
-            this.setRedirection(localId, storageId);
-            // set identity (id -> id) entry
-            this.setRedirection(storageId, storageId);
-        }
-    }
     /**
      * To be used in getPendingLocalState flow. Get a serializable record of the blobs that are
      * pending upload and/or their BlobAttach op, which can be given to a new BlobManager to
@@ -605,15 +625,15 @@ export class BlobManager {
     }
 }
 /**
- * For a blobId, returns its path in GC's graph. The node path is of the format `/<blobManagerBasePath>/<blobId>`.
+ * For a localId, returns its path in GC's graph. The node path is of the format `/<blobManagerBasePath>/<localId>`.
  * This path must match the path of the blob handle returned by the createBlob API because blobs are marked
  * referenced by storing these handles in a referenced DDS.
  */
-const getGCNodePathFromBlobId = (blobId) => `/${blobManagerBasePath}/${blobId}`;
+const getGCNodePathFromLocalId = (localId) => `/${blobManagerBasePath}/${localId}`;
 /**
- * For a given GC node path, return the blobId. The node path is of the format `/<basePath>/<blobId>`.
+ * For a given GC node path, return the localId. The node path is of the format `/<basePath>/<localId>`.
  */
-const getBlobIdFromGCNodePath = (nodePath) => {
+const getLocalIdFromGCNodePath = (nodePath) => {
     const pathParts = nodePath.split("/");
     assert(areBlobPathParts(pathParts), 0x5bd /* Invalid blob node path */);
     return pathParts[2];