@fluidframework/container-runtime 2.0.0-dev.5.3.2.178189 → 2.0.0-dev.6.4.0.191457

package/dist/blobManager.js

@@ -7,10 +7,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlobManager = exports.BlobHandle = void 0;
 const uuid_1 = require("uuid");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
-const common_utils_1 = require("@fluidframework/common-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const container_utils_1 = require("@fluidframework/container-utils");
 const containerRuntime_1 = require("./containerRuntime");
 const gc_1 = require("./gc");
 const throttler_1 = require("./throttler");
@@ -38,10 +38,9 @@ class BlobHandle {
         return this.routeContext.isAttached && this.attached;
     }
     attachGraph() {
-        var _a;
         if (!this.attached) {
             this.attached = true;
-            (_a = this.onAttachGraph) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.onAttachGraph?.();
         }
     }
     bind(handle) {
@@ -52,7 +51,7 @@ exports.BlobHandle = BlobHandle;
 class CancellableThrottler {
     constructor(throttler) {
         this.throttler = throttler;
-        this.cancelP = new common_utils_1.Deferred();
+        this.cancelP = new core_utils_1.Deferred();
     }
     async getDelay() {
         return Promise.race([
@@ -62,19 +61,10 @@ class CancellableThrottler {
     }
     cancel() {
         this.cancelP.resolve();
-        this.cancelP = new common_utils_1.Deferred();
+        this.cancelP = new core_utils_1.Deferred();
     }
 }
-// Note that while offline we "submit" an op before uploading the blob, but we always
-// expect blobs to be uploaded before we actually see the op round-trip
-var PendingBlobStatus;
-(function (PendingBlobStatus) {
-    PendingBlobStatus[PendingBlobStatus["OnlinePendingUpload"] = 0] = "OnlinePendingUpload";
-    PendingBlobStatus[PendingBlobStatus["OnlinePendingOp"] = 1] = "OnlinePendingOp";
-    PendingBlobStatus[PendingBlobStatus["OfflinePendingUpload"] = 2] = "OfflinePendingUpload";
-    PendingBlobStatus[PendingBlobStatus["OfflinePendingOp"] = 3] = "OfflinePendingOp";
-})(PendingBlobStatus || (PendingBlobStatus = {}));
-class BlobManager extends common_utils_1.TypedEventEmitter {
+class BlobManager extends client_utils_1.TypedEventEmitter {
     constructor(routeContext, snapshot, getStorage, 
     /**
      * Submit a BlobAttach op. When a blob is uploaded, there is a short grace period before which the blob is
@@ -101,9 +91,7 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         this.runtime = runtime;
         this.closeContainer = closeContainer;
         /**
-         * Blobs which have not been uploaded or for which we have not yet seen a BlobAttach op round-trip.
-         * Until we see the op round-trip, there is a possibility we may need to re-upload the blob, so
-         * we must save it. This is true for both the online and offline flow.
+         * Blobs which we have not yet seen a BlobAttach op round-trip and not yet attached to a DDS.
          */
         this.pendingBlobs = new Map();
         /**
@@ -121,27 +109,32 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
          * Tombstone is a temporary feature that imitates a blob getting swept by garbage collection.
          */
         this.tombstonedBlobs = new Set();
-        this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.runtime.logger, "BlobManager"));
+        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({
+            logger: this.runtime.logger,
+            namespace: "BlobManager",
+        });
         // Read the feature flag that tells whether to throw when a tombstone blob is requested.
         this.throwOnTombstoneLoad =
             this.mc.config.getBoolean(gc_1.throwOnTombstoneLoadKey) === true &&
                 this.runtime.gcTombstoneEnforcementAllowed &&
                 this.runtime.clientDetails.type !== summary_1.summarizerClientType;
-        this.runtime.on("disconnected", () => this.onDisconnected());
         this.redirectTable = this.load(snapshot);
         // Begin uploading stashed blobs from previous container instance
         Object.entries(stashedBlobs).forEach(([localId, entry]) => {
-            const blob = (0, common_utils_1.stringToBuffer)(entry.blob, "base64");
+            const blob = (0, client_utils_1.stringToBuffer)(entry.blob, "base64");
             const attached = entry.attached;
             const acked = entry.acked;
+            const storageId = entry.storageId; // entry.storageId = response.id
             if (entry.minTTLInSeconds && entry.uploadTime) {
                 const timeLapseSinceLocalUpload = (Date.now() - entry.uploadTime) / 1000;
                 // stashed entries with more than half-life in storage will not be reuploaded
                 if (entry.minTTLInSeconds - timeLapseSinceLocalUpload > entry.minTTLInSeconds / 2) {
                     this.pendingBlobs.set(localId, {
                         blob,
-                        status: PendingBlobStatus.OfflinePendingOp,
-                        handleP: new common_utils_1.Deferred(),
+                        uploading: false,
+                        opsent: true,
+                        handleP: new core_utils_1.Deferred(),
+                        storageId,
                         uploadP: undefined,
                         uploadTime: entry.uploadTime,
                         minTTLInSeconds: entry.minTTLInSeconds,
@@ -153,72 +146,70 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
             }
             this.pendingBlobs.set(localId, {
                 blob,
-                status: PendingBlobStatus.OfflinePendingUpload,
-                handleP: new common_utils_1.Deferred(),
+                uploading: true,
+                handleP: new core_utils_1.Deferred(),
                 uploadP: this.uploadBlob(localId, blob),
                 attached,
                 acked,
+                opsent: true,
             });
         });
         this.sendBlobAttachOp = (localId, blobId) => {
             const pendingEntry = this.pendingBlobs.get(localId);
-            if ((pendingEntry === null || pendingEntry === void 0 ? void 0 : pendingEntry.uploadTime) && (pendingEntry === null || pendingEntry === void 0 ? void 0 : pendingEntry.minTTLInSeconds)) {
+            (0, core_utils_1.assert)(pendingEntry !== undefined, 0x725 /* Must have pending blob entry for upcoming op */);
+            if (pendingEntry?.uploadTime && pendingEntry?.minTTLInSeconds) {
                 const secondsSinceUpload = (Date.now() - pendingEntry.uploadTime) / 1000;
                 const expired = pendingEntry.minTTLInSeconds - secondsSinceUpload < 0;
                 this.mc.logger.sendTelemetryEvent({
                     eventName: "sendBlobAttach",
-                    entryStatus: pendingEntry.status,
                     secondsSinceUpload,
                     minTTLInSeconds: pendingEntry.minTTLInSeconds,
                     expired,
                 });
                 if (expired) {
                     // we want to avoid submitting ops with broken handles
-                    this.closeContainer(new container_utils_1.GenericError("Trying to submit a BlobAttach for expired blob", undefined, {
+                    this.closeContainer(new telemetry_utils_1.GenericError("Trying to submit a BlobAttach for expired blob", undefined, {
                         localId,
                         blobId,
-                        entryStatus: pendingEntry.status,
                         secondsSinceUpload,
                     }));
                 }
             }
+            pendingEntry.opsent = true;
             return sendBlobAttachOp(localId, blobId);
         };
     }
-    get pendingOfflineUploads() {
-        return Array.from(this.pendingBlobs.values()).filter((e) => e.status === PendingBlobStatus.OfflinePendingUpload);
-    }
-    get hasPendingOfflineUploads() {
-        return this.pendingOfflineUploads.length > 0;
+    get allBlobsAttached() {
+        for (const [, entry] of this.pendingBlobs) {
+            if (entry.attached === false) {
+                return false;
+            }
+        }
+        return true;
     }
     get hasPendingBlobs() {
         return ((this.runtime.attachState !== container_definitions_1.AttachState.Attached && this.redirectTable.size > 0) ||
             this.pendingBlobs.size > 0);
     }
+    createAbortError(pending) {
+        return new telemetry_utils_1.LoggingError("uploadBlob aborted", {
+            acked: pending?.acked,
+            uploadTime: pending?.uploadTime,
+        });
+    }
     /**
      * Upload blobs added while offline. This must be completed before connecting and resubmitting ops.
      */
-    async onConnected() {
+    async processStashedChanges() {
         this.retryThrottler.cancel();
-        const pendingUploads = this.pendingOfflineUploads.map(async (e) => e.uploadP);
+        const pendingUploads = Array.from(this.pendingBlobs.values())
+            .filter((e) => e.uploading === true)
+            .map(async (e) => e.uploadP);
         await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, {
-            eventName: "BlobUploadOnConnected",
+            eventName: "BlobUploadProcessStashedChanges",
             count: pendingUploads.length,
         }, async () => Promise.all(pendingUploads), { start: true, end: true });
     }
-    /**
-     * Transition online blobs waiting for BlobAttach op round-trip since we will not see the op until we are connected
-     * again
-     */
-    onDisconnected() {
-        for (const [localId, entry] of this.pendingBlobs) {
-            if (entry.status === PendingBlobStatus.OnlinePendingOp) {
-                // This will submit another BlobAttach op for this blob. This is necessary because the one we sent
-                // already didn't have the local ID.
-                this.transitionToOffline(localId);
-            }
-        }
-    }
     /**
      * Set of actual storage IDs (i.e., IDs that can be requested from storage). This will be empty if the container is
      * detached or there are no (non-pending) attachment blobs in the document
@@ -229,7 +220,7 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         const undefinedValueInTable = ids.delete(undefined);
         // For a detached container, entries are inserted into the redirect table with an undefined storage ID.
         // For an attached container, entries are inserted w/storage ID after the BlobAttach op round-trips.
-        (0, common_utils_1.assert)(!undefinedValueInTable ||
+        (0, core_utils_1.assert)(!undefinedValueInTable ||
             (this.runtime.attachState === container_definitions_1.AttachState.Detached && ids.size === 0), 0x382 /* 'redirectTable' must contain only undefined while detached / defined values while attached */);
         return ids;
     }
@@ -243,14 +234,14 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         }
         let storageId;
         if (this.runtime.attachState === container_definitions_1.AttachState.Detached) {
-            (0, common_utils_1.assert)(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
+            (0, core_utils_1.assert)(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
             // Blobs created while the container is detached are stored in IDetachedBlobStorage.
             // The 'IDocumentStorageService.readBlob()' call below will retrieve these via localId.
             storageId = blobId;
         }
         else {
             const attachedStorageId = this.redirectTable.get(blobId);
-            (0, common_utils_1.assert)(!!attachedStorageId, 0x11f /* "requesting unknown blobs" */);
+            (0, core_utils_1.assert)(!!attachedStorageId, 0x11f /* "requesting unknown blobs" */);
             storageId = attachedStorageId;
         }
         // Let runtime know that the corresponding GC node was requested.
@@ -260,11 +251,12 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         }, { end: true, cancel: "error" });
     }
     getBlobHandle(id) {
-        (0, common_utils_1.assert)(this.redirectTable.has(id) || this.pendingBlobs.has(id), 0x384 /* requesting handle for unknown blob */);
+        (0, core_utils_1.assert)(this.redirectTable.has(id) || this.pendingBlobs.has(id), 0x384 /* requesting handle for unknown blob */);
         const pending = this.pendingBlobs.get(id);
         const callback = pending
             ? () => {
                 pending.attached = true;
+                this.emit("blobAttached", pending);
                 this.deletePendingBlobMaybe(id);
             }
             : undefined;
@@ -277,7 +269,7 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         this.setRedirection(response.id, undefined);
         return this.getBlobHandle(response.id);
     }
-    async createBlob(blob) {
+    async createBlob(blob, signal) {
         if (this.runtime.attachState === container_definitions_1.AttachState.Detached) {
             return this.createBlobDetached(blob);
         }
@@ -286,20 +278,33 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
             this.mc.logger.sendTelemetryEvent({ eventName: "CreateBlobWhileAttaching" });
             await new Promise((resolve) => this.runtime.once("attached", resolve));
         }
-        (0, common_utils_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Attached, 0x385 /* For clarity and paranoid defense against adding future attachment states */);
+        (0, core_utils_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Attached, 0x385 /* For clarity and paranoid defense against adding future attachment states */);
+        if (signal?.aborted) {
+            throw this.createAbortError();
+        }
         // 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 = (0, uuid_1.v4)();
         const pendingEntry = {
             blob,
-            status: PendingBlobStatus.OnlinePendingUpload,
-            handleP: new common_utils_1.Deferred(),
+            uploading: true,
+            handleP: new core_utils_1.Deferred(),
             uploadP: this.uploadBlob(localId, blob),
             attached: false,
             acked: false,
+            abortSignal: signal,
+            opsent: false,
         };
         this.pendingBlobs.set(localId, pendingEntry);
-        return pendingEntry.handleP.promise;
+        const abortListener = () => {
+            if (!pendingEntry.acked) {
+                pendingEntry.handleP.reject(this.createAbortError(pendingEntry));
+            }
+        };
+        signal?.addEventListener("abort", abortListener, { once: true });
+        return pendingEntry.handleP.promise.finally(() => {
+            signal?.removeEventListener("abort", abortListener);
+        });
     }
     async uploadBlob(localId, blob) {
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "createBlob" }, async () => this.getStorage().createBlob(blob), { end: true, cancel: this.runtime.connected ? "error" : "generic" }).then((response) => this.onUploadResolve(localId, response), async (err) => this.onUploadReject(localId, err));
@@ -314,69 +319,59 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
     deletePendingBlobMaybe(id) {
         if (this.pendingBlobs.has(id)) {
             const entry = this.pendingBlobs.get(id);
-            if ((entry === null || entry === void 0 ? void 0 : entry.attached) && (entry === null || entry === void 0 ? void 0 : entry.acked)) {
-                this.pendingBlobs.delete(id);
-                if (!this.hasPendingBlobs) {
-                    this.emit("noPendingBlobs");
-                }
+            if (entry?.attached && entry?.acked) {
+                this.deletePendingBlob(id);
             }
         }
     }
+    deletePendingBlob(id) {
+        if (this.pendingBlobs.delete(id) && !this.hasPendingBlobs) {
+            this.emit("noPendingBlobs");
+        }
+    }
     onUploadResolve(localId, response) {
-        var _a;
         const entry = this.pendingBlobs.get(localId);
-        (0, common_utils_1.assert)(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
-        (0, common_utils_1.assert)(entry.status === PendingBlobStatus.OnlinePendingUpload ||
-            entry.status === PendingBlobStatus.OfflinePendingUpload, 0x386 /* Must have pending blob entry for uploaded blob */);
+        (0, core_utils_1.assert)(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
+        if (entry.abortSignal?.aborted === true && !entry.opsent) {
+            this.deletePendingBlob(localId);
+            return;
+        }
+        (0, core_utils_1.assert)(entry.uploading === true, 0x386 /* Must have pending blob entry for uploaded blob */);
         entry.storageId = response.id;
         entry.uploadTime = Date.now();
         entry.minTTLInSeconds = response.minTTLInSeconds;
-        if (this.runtime.connected) {
-            if (entry.status === PendingBlobStatus.OnlinePendingUpload) {
-                // Send a blob attach op. This serves two purposes:
-                // 1. If its a new blob, i.e., it isn't de-duped, the server will keep the blob alive if it sees this op
-                //    until its storage ID is added to the next summary.
-                // 2. It will create a local ID to storage ID mapping in all clients which is needed to retrieve the
-                //    blob from the server via the storage ID.
-                this.sendBlobAttachOp(localId, response.id);
-                if (this.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
-                    // happened before and so, the server won't delete it.
-                    this.setRedirection(localId, response.id);
-                    entry.handleP.resolve(this.getBlobHandle(localId));
-                    this.deletePendingBlobMaybe(localId);
-                }
-                else {
-                    // If there is already an op for this storage ID, append the local ID to the list. Once any op for
-                    // this storage ID is ack'd, all pending blobs for it can be resolved since the op will keep the
-                    // blob alive in storage.
-                    this.opsInFlight.set(response.id, ((_a = this.opsInFlight.get(response.id)) !== null && _a !== void 0 ? _a : []).concat(localId));
-                    entry.status = PendingBlobStatus.OnlinePendingOp;
-                }
-            }
-            else if (entry.status === PendingBlobStatus.OfflinePendingUpload) {
-                // We already submitted a BlobAttach op for this blob when it was transitioned to offline flow
-                entry.status = PendingBlobStatus.OfflinePendingOp;
-            }
+        // Send a blob attach op. This serves two purposes:
+        // 1. If its a new blob, i.e., it isn't de-duped, the server will keep the blob alive if it sees this op
+        //    until its storage ID is added to the next summary.
+        // 2. It will create a local ID to storage ID mapping in all clients which is needed to retrieve the
+        //    blob from the server via the storage ID.
+        if (!entry.opsent) {
+            this.sendBlobAttachOp(localId, response.id);
+        }
+        if (this.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
+            // happened before and so, the server won't delete it.
+            this.setRedirection(localId, response.id);
+            entry.handleP.resolve(this.getBlobHandle(localId));
+            this.deletePendingBlobMaybe(localId);
         }
         else {
-            // connected to storage but not ordering service?
-            this.mc.logger.sendTelemetryEvent({ eventName: "BlobUploadSuccessWhileDisconnected" });
-            if (entry.status === PendingBlobStatus.OnlinePendingUpload) {
-                this.transitionToOffline(localId);
-            }
-            entry.status = PendingBlobStatus.OfflinePendingOp;
+            // If there is already an op for this storage ID, append the local ID to the list. Once any op for
+            // this storage ID is ack'd, all pending blobs for it can be resolved since the op will keep the
+            // blob alive in storage.
+            this.opsInFlight.set(response.id, (this.opsInFlight.get(response.id) ?? []).concat(localId));
         }
         return response;
     }
     async onUploadReject(localId, error) {
         const entry = this.pendingBlobs.get(localId);
-        (0, common_utils_1.assert)(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
+        (0, core_utils_1.assert)(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
+        if (entry.abortSignal?.aborted === true && !entry.opsent) {
+            this.deletePendingBlob(localId);
+            return;
+        }
         if (!this.runtime.connected) {
-            if (entry.status === PendingBlobStatus.OnlinePendingUpload) {
-                this.transitionToOffline(localId);
-            }
             // we are probably not connected to storage but start another upload request in case we are
             entry.uploadP = this.retryThrottler
                 .getDelay()
@@ -388,50 +383,34 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
             throw error;
         }
     }
-    transitionToOffline(localId) {
-        (0, common_utils_1.assert)(!this.runtime.connected, 0x388 /* Must only transition to offline flow while runtime is disconnected */);
-        const entry = this.pendingBlobs.get(localId);
-        (0, common_utils_1.assert)(!!entry, 0x389 /* No pending blob entry */);
-        (0, common_utils_1.assert)([PendingBlobStatus.OnlinePendingUpload, PendingBlobStatus.OnlinePendingOp].includes(entry.status), 0x38a /* Blob must be in online flow to transition to offline flow */);
-        /**
-         * If we haven't already submitted a BlobAttach op for this entry, send it before returning the blob handle.
-         * This will make sure that the BlobAttach op is sequenced prior to any ops referencing the handle. Otherwise,
-         * an invalid handle could be added to the document.
-         * storageId may be undefined but since we are not connected we will have a chance to add it when reSubmit()
-         * is called on reconnection.
-         */
-        if (entry.status !== PendingBlobStatus.OnlinePendingOp) {
-            this.sendBlobAttachOp(localId, entry.storageId);
-        }
-        entry.status =
-            entry.status === PendingBlobStatus.OnlinePendingUpload
-                ? PendingBlobStatus.OfflinePendingUpload
-                : PendingBlobStatus.OfflinePendingOp;
-        entry.handleP.resolve(this.getBlobHandle(localId));
-    }
     /**
      * Resubmit a BlobAttach op. Used to add storage IDs to ops that were
      * submitted to runtime while disconnected.
      * @param metadata - op metadata containing storage and/or local IDs
      */
     reSubmit(metadata) {
-        (0, common_utils_1.assert)(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
+        (0, core_utils_1.assert)(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
         const { localId, blobId } = metadata;
-        (0, common_utils_1.assert)(localId !== undefined, 0x50d /* local ID not available on reSubmit */);
+        (0, core_utils_1.assert)(localId !== undefined, 0x50d /* local ID not available on reSubmit */);
         const pendingEntry = this.pendingBlobs.get(localId);
         if (!blobId) {
             // We submitted this op while offline. The blob should have been uploaded by now.
-            (0, common_utils_1.assert)((pendingEntry === null || pendingEntry === void 0 ? void 0 : pendingEntry.status) === PendingBlobStatus.OfflinePendingOp &&
-                !!(pendingEntry === null || pendingEntry === void 0 ? void 0 : pendingEntry.storageId), 0x38d /* blob must be uploaded before resubmitting BlobAttach op */);
-            return this.sendBlobAttachOp(localId, pendingEntry.storageId);
+            (0, core_utils_1.assert)(pendingEntry?.opsent === true && !!pendingEntry?.storageId, 0x38d /* blob must be uploaded before resubmitting BlobAttach op */);
+            return this.sendBlobAttachOp(localId, pendingEntry?.storageId);
         }
         return this.sendBlobAttachOp(localId, blobId);
     }
     processBlobAttachOp(message, local) {
-        var _a, _b;
-        const localId = (_a = message.metadata) === null || _a === void 0 ? void 0 : _a.localId;
-        const blobId = (_b = message.metadata) === null || _b === void 0 ? void 0 : _b.blobId;
-        (0, common_utils_1.assert)(blobId !== undefined, 0x12a /* "Missing blob id on metadata" */);
+        const localId = message.metadata?.localId;
+        const blobId = message.metadata?.blobId;
+        if (localId) {
+            const pendingEntry = this.pendingBlobs.get(localId);
+            if (pendingEntry?.abortSignal?.aborted) {
+                this.deletePendingBlob(localId);
+                return;
+            }
+        }
+        (0, core_utils_1.assert)(blobId !== undefined, 0x12a /* "Missing blob id on metadata" */);
         // Set up a mapping from local ID to storage ID. This is crucial since without this the blob cannot be
         // requested from the server.
         // Note: The check for undefined is needed for back-compat when localId was not part of the BlobAttach op that
@@ -442,7 +421,7 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         // set identity (id -> id) entry
         this.setRedirection(blobId, blobId);
         if (local) {
-            (0, common_utils_1.assert)(localId !== undefined, 0x50e /* local ID not present in blob attach message */);
+            (0, core_utils_1.assert)(localId !== undefined, 0x50e /* local ID not present in blob attach message */);
             const waitingBlobs = this.opsInFlight.get(blobId);
             if (waitingBlobs !== undefined) {
                 // For each op corresponding to this storage ID that we are waiting for, resolve the pending blob.
@@ -450,22 +429,18 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
                 // storage ID is already in flight and any op containing this local ID will be sequenced after that.
                 waitingBlobs.forEach((pendingLocalId) => {
                     const entry = this.pendingBlobs.get(pendingLocalId);
-                    (0, common_utils_1.assert)(entry !== undefined, 0x38f /* local online BlobAttach op with no pending blob entry */);
-                    // It's possible we transitioned to offline flow while waiting for this op.
-                    if (entry.status === PendingBlobStatus.OnlinePendingOp) {
-                        this.setRedirection(pendingLocalId, blobId);
-                        entry.acked = true;
-                        entry.handleP.resolve(this.getBlobHandle(pendingLocalId));
-                        this.deletePendingBlobMaybe(pendingLocalId);
-                    }
+                    (0, core_utils_1.assert)(entry !== undefined, 0x38f /* local online BlobAttach op with no pending blob entry */);
+                    this.setRedirection(pendingLocalId, blobId);
+                    entry.acked = true;
+                    entry.handleP.resolve(this.getBlobHandle(pendingLocalId));
+                    this.deletePendingBlobMaybe(pendingLocalId);
                 });
                 this.opsInFlight.delete(blobId);
             }
-            // offline flow does not resolve the handle (since it was already resolved)
-            // but we still need to delete the entry in case is acked and attached.
             const localEntry = this.pendingBlobs.get(localId);
             if (localEntry) {
                 localEntry.acked = true;
+                localEntry.handleP.resolve(this.getBlobHandle(localId));
                 this.deletePendingBlobMaybe(localId);
             }
         }
@@ -494,11 +469,10 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
      * Load a set of previously attached blob IDs and redirect table from a previous snapshot.
      */
     load(snapshot) {
-        var _a, _b, _c;
         this.mc.logger.sendTelemetryEvent({
             eventName: "AttachmentBlobsLoaded",
-            count: (_b = (_a = snapshot.ids) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
-            redirectTable: (_c = snapshot.redirectTable) === null || _c === void 0 ? void 0 : _c.length,
+            count: snapshot.ids?.length ?? 0,
+            redirectTable: snapshot.redirectTable?.length,
         });
         const table = new Map(snapshot.redirectTable);
         if (snapshot.ids) {
@@ -535,7 +509,7 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
     getGCData(fullGC = false) {
         const gcData = { gcNodes: {} };
         for (const [localId, storageId] of this.redirectTable) {
-            (0, common_utils_1.assert)(!!storageId, 0x390 /* Must be attached to get GC data */);
+            (0, core_utils_1.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
@@ -557,11 +531,11 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
      * Delete attachment blobs that are sweep ready.
      * @param sweepReadyBlobRoutes - The routes of blobs that are sweep ready and should be deleted. These routes will
      * be based off of local ids.
-     * @returns - The routes of blobs that were deleted.
+     * @returns The routes of blobs that were deleted.
      */
     deleteSweepReadyNodes(sweepReadyBlobRoutes) {
         // If sweep for attachment blobs is not enabled, return empty list indicating nothing is deleted.
-        if (this.mc.config.getBoolean(gc_1.sweepAttachmentBlobsKey) !== true) {
+        if (this.mc.config.getBoolean(gc_1.disableAttachmentBlobSweepKey) === true) {
             return [];
         }
         this.deleteBlobsFromRedirectTable(sweepReadyBlobRoutes);
@@ -595,14 +569,14 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
                 continue;
             }
             const storageId = this.redirectTable.get(blobId);
-            (0, common_utils_1.assert)(!!storageId, 0x5bb /* Must be attached to run GC */);
+            (0, core_utils_1.assert)(!!storageId, 0x5bb /* Must be attached to run GC */);
             maybeUnusedStorageIds.add(storageId);
             this.redirectTable.delete(blobId);
         }
         // 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()) {
-            (0, common_utils_1.assert)(!!storageId, 0x5bc /* Must be attached to run GC */);
+            (0, core_utils_1.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) {
                 maybeUnusedStorageIds.delete(storageId);
@@ -676,27 +650,65 @@ class BlobManager extends common_utils_1.TypedEventEmitter {
         }
     }
     setRedirectTable(table) {
-        (0, common_utils_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
-        (0, common_utils_1.assert)(this.redirectTable.size === table.size, 0x391 /* Redirect table size must match BlobManager's local ID count */);
+        (0, core_utils_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
+        (0, core_utils_1.assert)(this.redirectTable.size === table.size, 0x391 /* Redirect table size must match BlobManager's local ID count */);
         for (const [localId, storageId] of table) {
-            (0, common_utils_1.assert)(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
+            (0, core_utils_1.assert)(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
             this.setRedirection(localId, storageId);
             // set identity (id -> id) entry
             this.setRedirection(storageId, storageId);
         }
     }
-    getPendingBlobs() {
-        const blobs = {};
-        for (const [key, entry] of this.pendingBlobs) {
-            blobs[key] = {
-                blob: (0, common_utils_1.bufferToString)(entry.blob, "base64"),
-                attached: entry.attached,
-                acked: entry.acked,
-                minTTLInSeconds: entry.minTTLInSeconds,
-                uploadTime: entry.uploadTime,
-            };
-        }
-        return blobs;
+    async getPendingBlobs(waitBlobsToAttach) {
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "GetPendingBlobs" }, async () => {
+            if (this.pendingBlobs.size === 0) {
+                return;
+            }
+            const blobs = {};
+            const localBlobs = new Set();
+            while (localBlobs.size < this.pendingBlobs.size) {
+                const attachBlobsP = [];
+                for (const [id, entry] of this.pendingBlobs) {
+                    if (!localBlobs.has(entry)) {
+                        localBlobs.add(entry);
+                        if (waitBlobsToAttach) {
+                            if (!entry.opsent) {
+                                this.sendBlobAttachOp(id, entry.storageId);
+                            }
+                            entry.handleP.resolve(this.getBlobHandle(id));
+                            attachBlobsP.push(new Promise((resolve) => {
+                                const onBlobAttached = (attachedEntry) => {
+                                    if (attachedEntry === entry) {
+                                        this.off("blobAttached", onBlobAttached);
+                                        resolve();
+                                    }
+                                };
+                                if (!entry.attached) {
+                                    this.on("blobAttached", onBlobAttached);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            }));
+                        }
+                    }
+                }
+                await Promise.all(attachBlobsP);
+            }
+            // another for is needed to correctly mark attach state
+            // future optimization won't add unattached blobs to the list
+            for (const [id, entry] of this.pendingBlobs) {
+                blobs[id] = {
+                    blob: (0, client_utils_1.bufferToString)(entry.blob, "base64"),
+                    storageId: entry.storageId,
+                    attached: entry.attached,
+                    acked: entry.acked,
+                    minTTLInSeconds: entry.minTTLInSeconds,
+                    uploadTime: entry.uploadTime,
+                };
+            }
+            return blobs;
+        });
     }
 }
 exports.BlobManager = BlobManager;
@@ -715,7 +727,7 @@ function getGCNodePathFromBlobId(blobId) {
  */
 function getBlobIdFromGCNodePath(nodePath) {
     const pathParts = nodePath.split("/");
-    (0, common_utils_1.assert)(pathParts.length === 3 && pathParts[1] === BlobManager.basePath, 0x5bd /* Invalid blob node path */);
+    (0, core_utils_1.assert)(pathParts.length === 3 && pathParts[1] === BlobManager.basePath, 0x5bd /* Invalid blob node path */);
     return pathParts[2];
 }
 //# sourceMappingURL=blobManager.js.map