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

package/lib/blobManager.js

@@ -4,12 +4,12 @@
  */
 import { v4 as uuid } from "uuid";
 import { createResponseError, generateHandleContextPath, responseToException, SummaryTreeBuilder, } from "@fluidframework/runtime-utils";
-import { assert, bufferToString, Deferred, stringToBuffer, TypedEventEmitter, } from "@fluidframework/common-utils";
+import { assert, Deferred } from "@fluidframework/core-utils";
+import { bufferToString, stringToBuffer, TypedEventEmitter } from "@fluid-internal/client-utils";
 import { AttachState } from "@fluidframework/container-definitions";
-import { ChildLogger, loggerToMonitoringContext, PerformanceEvent, } from "@fluidframework/telemetry-utils";
-import { GenericError } from "@fluidframework/container-utils";
+import { createChildMonitoringContext, GenericError, LoggingError, PerformanceEvent, } from "@fluidframework/telemetry-utils";
 import { TombstoneResponseHeaderKey } from "./containerRuntime";
-import { sendGCUnexpectedUsageEvent, sweepAttachmentBlobsKey, throwOnTombstoneLoadKey } from "./gc";
+import { sendGCUnexpectedUsageEvent, disableAttachmentBlobSweepKey, throwOnTombstoneLoadKey, } from "./gc";
 import { Throttler, formExponentialFn } from "./throttler";
 import { summarizerClientType } from "./summary";
 /**
@@ -35,10 +35,9 @@ export 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) {
@@ -61,15 +60,6 @@ class CancellableThrottler {
         this.cancelP = new 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 = {}));
 export class BlobManager extends TypedEventEmitter {
     constructor(routeContext, snapshot, getStorage, 
     /**
@@ -97,9 +87,7 @@ export class BlobManager extends 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();
         /**
@@ -117,27 +105,32 @@ export class BlobManager extends TypedEventEmitter {
          * Tombstone is a temporary feature that imitates a blob getting swept by garbage collection.
          */
         this.tombstonedBlobs = new Set();
-        this.mc = loggerToMonitoringContext(ChildLogger.create(this.runtime.logger, "BlobManager"));
+        this.mc = 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(throwOnTombstoneLoadKey) === true &&
                 this.runtime.gcTombstoneEnforcementAllowed &&
                 this.runtime.clientDetails.type !== 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 = 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,
+                        uploading: false,
+                        opsent: true,
                         handleP: new Deferred(),
+                        storageId,
                         uploadP: undefined,
                         uploadTime: entry.uploadTime,
                         minTTLInSeconds: entry.minTTLInSeconds,
@@ -149,21 +142,22 @@ export class BlobManager extends TypedEventEmitter {
             }
             this.pendingBlobs.set(localId, {
                 blob,
-                status: PendingBlobStatus.OfflinePendingUpload,
+                uploading: true,
                 handleP: new 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)) {
+            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,
@@ -173,48 +167,45 @@ export class BlobManager extends TypedEventEmitter {
                     this.closeContainer(new 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 !== AttachState.Attached && this.redirectTable.size > 0) ||
             this.pendingBlobs.size > 0);
     }
+    createAbortError(pending) {
+        return new 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 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
@@ -261,6 +252,7 @@ export class BlobManager extends TypedEventEmitter {
         const callback = pending
             ? () => {
                 pending.attached = true;
+                this.emit("blobAttached", pending);
                 this.deletePendingBlobMaybe(id);
             }
             : undefined;
@@ -273,7 +265,7 @@ export class BlobManager extends TypedEventEmitter {
         this.setRedirection(response.id, undefined);
         return this.getBlobHandle(response.id);
     }
-    async createBlob(blob) {
+    async createBlob(blob, signal) {
         if (this.runtime.attachState === AttachState.Detached) {
             return this.createBlobDetached(blob);
         }
@@ -283,19 +275,32 @@ export class BlobManager extends TypedEventEmitter {
             await new Promise((resolve) => this.runtime.once("attached", resolve));
         }
         assert(this.runtime.attachState === 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 = uuid();
         const pendingEntry = {
             blob,
-            status: PendingBlobStatus.OnlinePendingUpload,
+            uploading: true,
             handleP: new 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 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));
@@ -310,69 +315,59 @@ export class BlobManager extends 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);
         assert(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
-        assert(entry.status === PendingBlobStatus.OnlinePendingUpload ||
-            entry.status === PendingBlobStatus.OfflinePendingUpload, 0x386 /* Must have pending blob entry for uploaded blob */);
+        if (entry.abortSignal?.aborted === true && !entry.opsent) {
+            this.deletePendingBlob(localId);
+            return;
+        }
+        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);
         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()
@@ -384,27 +379,6 @@ export class BlobManager extends TypedEventEmitter {
             throw error;
         }
     }
-    transitionToOffline(localId) {
-        assert(!this.runtime.connected, 0x388 /* Must only transition to offline flow while runtime is disconnected */);
-        const entry = this.pendingBlobs.get(localId);
-        assert(!!entry, 0x389 /* No pending blob entry */);
-        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.
@@ -417,16 +391,21 @@ export class BlobManager extends TypedEventEmitter {
         const pendingEntry = this.pendingBlobs.get(localId);
         if (!blobId) {
             // We submitted this op while offline. The blob should have been uploaded by now.
-            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);
+            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;
+        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;
+            }
+        }
         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.
@@ -447,21 +426,17 @@ export class BlobManager extends TypedEventEmitter {
                 waitingBlobs.forEach((pendingLocalId) => {
                     const entry = this.pendingBlobs.get(pendingLocalId);
                     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);
-                    }
+                    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);
             }
         }
@@ -490,11 +465,10 @@ export class BlobManager extends 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) {
@@ -553,11 +527,11 @@ export class BlobManager extends 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(sweepAttachmentBlobsKey) !== true) {
+        if (this.mc.config.getBoolean(disableAttachmentBlobSweepKey) === true) {
             return [];
         }
         this.deleteBlobsFromRedirectTable(sweepReadyBlobRoutes);
@@ -681,18 +655,56 @@ export class BlobManager extends TypedEventEmitter {
             this.setRedirection(storageId, storageId);
         }
     }
-    getPendingBlobs() {
-        const blobs = {};
-        for (const [key, entry] of this.pendingBlobs) {
-            blobs[key] = {
-                blob: bufferToString(entry.blob, "base64"),
-                attached: entry.attached,
-                acked: entry.acked,
-                minTTLInSeconds: entry.minTTLInSeconds,
-                uploadTime: entry.uploadTime,
-            };
-        }
-        return blobs;
+    async getPendingBlobs(waitBlobsToAttach) {
+        return 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: bufferToString(entry.blob, "base64"),
+                    storageId: entry.storageId,
+                    attached: entry.attached,
+                    acked: entry.acked,
+                    minTTLInSeconds: entry.minTTLInSeconds,
+                    uploadTime: entry.uploadTime,
+                };
+            }
+            return blobs;
+        });
     }
 }
 BlobManager.basePath = "_blobs";