@fluidframework/container-runtime 2.118.1 → 3.0.1

package/lib/blobManager/blobManager.js

@@ -18,18 +18,34 @@ import { summarizeBlobManagerState, toRedirectTable, } from "./blobManagerSnapSu
  * and loads blob.
  */
 export class BlobHandle extends FluidHandleBase {
+    path;
+    routeContext;
+    get;
+    payloadPending;
+    sharePayloadCallback;
+    attachGraphCallback;
+    attached = false;
+    payloadSharingStarted = false;
     get isAttached() {
         return this.routeContext.isAttached && this.attached;
     }
+    _events;
     get events() {
         return (this._events ??= createEmitter());
     }
+    _payloadState;
     get payloadState() {
         return this._payloadState;
     }
+    /**
+     * The error property starts undefined, signalling that there has been no error yet.
+     * If an error occurs, the property will contain the error.
+     */
+    _payloadShareError;
     get payloadShareError() {
         return this._payloadShareError;
     }
+    absolutePath;
     constructor(path, routeContext, 
     // TODO: just take the blob rather than a get function?
     get, payloadPending, sharePayloadCallback, attachGraphCallback) {
@@ -40,19 +56,17 @@ export class BlobHandle extends FluidHandleBase {
         this.payloadPending = payloadPending;
         this.sharePayloadCallback = sharePayloadCallback;
         this.attachGraphCallback = attachGraphCallback;
-        this.attached = false;
-        this.payloadSharingStarted = false;
-        this.notifyShared = () => {
-            this._payloadState = "shared";
-            this._events?.emit("payloadShared");
-        };
-        this.notifyFailed = (error) => {
-            this._payloadShareError = error;
-            this._events?.emit("payloadShareFailed", error);
-        };
         this._payloadState = payloadPending ? "pending" : "shared";
         this.absolutePath = generateHandleContextPath(path, this.routeContext);
     }
+    notifyShared = () => {
+        this._payloadState = "shared";
+        this._events?.emit("payloadShared");
+    };
+    notifyFailed = (error) => {
+        this._payloadShareError = error;
+        this._events?.emit("payloadShareFailed", error);
+    };
     sharePayload() {
         if (this.payloadState === "shared" || this.payloadSharingStarted) {
             return;
@@ -80,228 +94,41 @@ const createAbortError = () => new LoggingError("uploadBlob aborted");
  */
 export const blobManagerBasePath = "_blobs";
 export class BlobManager {
+    mc;
+    internalEvents = createEmitter();
+    /**
+     * 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().
+     */
+    redirectTable;
+    /**
+     * The localBlobCache has a dual role of caching locally-created blobs, as well as tracking their state as they
+     * are shared. Keys are localIds.
+     */
+    localBlobCache = new Map();
+    /**
+     * Blobs with an attached handle that have not finished blob-attaching are the set we need to provide from
+     * getPendingState(). This stores their local IDs, and then we can look them up against the localBlobCache.
+     */
+    pendingBlobsWithAttachedHandles = new Set();
+    /**
+     * Local IDs for any pending blobs we loaded with and have not yet started the upload/attach flow for.
+     */
+    pendingOnlyLocalIds = new Set();
+    sendBlobAttachMessage;
+    routeContext;
+    storage;
+    // Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
+    // blobPath's format - `/<basePath>/<localId>`.
+    blobRequested;
+    // Called to check if a blob has been deleted by GC.
+    // blobPath's format - `/<basePath>/<localId>`.
+    isBlobDeleted;
+    runtime;
+    createBlobPayloadPending;
     constructor(props) {
-        this.internalEvents = createEmitter();
-        /**
-         * The localBlobCache has a dual role of caching locally-created blobs, as well as tracking their state as they
-         * are shared. Keys are localIds.
-         */
-        this.localBlobCache = new Map();
-        /**
-         * Blobs with an attached handle that have not finished blob-attaching are the set we need to provide from
-         * getPendingState(). This stores their local IDs, and then we can look them up against the localBlobCache.
-         */
-        this.pendingBlobsWithAttachedHandles = new Set();
-        /**
-         * Local IDs for any pending blobs we loaded with and have not yet started the upload/attach flow for.
-         */
-        this.pendingOnlyLocalIds = new Set();
-        /**
-         * Upload and attach the localBlobCache entry for the given localId.
-         *
-         * Expects the localBlobCache entry for the given localId to be in either localOnly or uploaded state
-         * when called. Returns a promise that resolves when the blob completes uploading and attaching, or else
-         * rejects if an error is encountered or the signal is aborted.
-         */
-        this.uploadAndAttach = async (localId, signal) => {
-            if (signal?.aborted === true) {
-                this.localBlobCache.delete(localId);
-                this.pendingBlobsWithAttachedHandles.delete(localId);
-                throw createAbortError();
-            }
-            const localBlobRecordInitial = this.localBlobCache.get(localId);
-            assert(localBlobRecordInitial?.state === "localOnly" ||
-                localBlobRecordInitial?.state === "uploaded", 0xc80 /* Expect uploadAndAttach to be called with either localOnly or uploaded state */);
-            const { blob } = localBlobRecordInitial;
-            /**
-             * Expects the localBlobCache entry for the given localId to be in either localOnly or uploaded state
-             * when called. Returns a promise that resolves when the blob is in uploaded or attached state, or else
-             * rejects on error during upload or if the signal is aborted.
-             *
-             * Most of the time this should be expected to exit in uploaded state, but if we are loading from pending
-             * state we may see an attach message from the client that generated the pending state, which can complete the
-             * attach while the upload is outstanding.
-             */
-            const ensureUploaded = async () => {
-                const localBlobRecord = this.localBlobCache.get(localId);
-                if (localBlobRecord?.state === "uploaded") {
-                    // In normal creation flows, the blob will be in localOnly state here. But in the case of loading
-                    // with pending state we can call it with an uploaded-but-not-attached blob. Start the upload
-                    // flow only if it's localOnly.
-                    return;
-                }
-                assert(localBlobRecord?.state === "localOnly", 0xc81 /* Attempting to upload from unexpected state */);
-                this.localBlobCache.set(localId, { state: "uploading", blob });
-                await new Promise((resolve, reject) => {
-                    // If we eventually have driver-level support for abort, then this can simplify a bit as we won't
-                    // need to track upload completion and abort separately. Until then, we need to handle the case that
-                    // the upload continues and settles after becoming irrelevant due to signal abort or blob attach.
-                    let uploadHasBecomeIrrelevant = false;
-                    const onSignalAbort = () => {
-                        removeListeners();
-                        uploadHasBecomeIrrelevant = true;
-                        this.localBlobCache.delete(localId);
-                        this.pendingBlobsWithAttachedHandles.delete(localId);
-                        reject(createAbortError());
-                    };
-                    const onProcessedBlobAttach = (_localId, _storageId) => {
-                        if (_localId === localId) {
-                            removeListeners();
-                            uploadHasBecomeIrrelevant = true;
-                            resolve();
-                        }
-                    };
-                    const removeListeners = () => {
-                        this.internalEvents.off("processedBlobAttach", onProcessedBlobAttach);
-                        signal?.removeEventListener("abort", onSignalAbort);
-                    };
-                    this.internalEvents.on("processedBlobAttach", onProcessedBlobAttach);
-                    signal?.addEventListener("abort", onSignalAbort);
-                    this.storage
-                        .createBlob(blob)
-                        .then((createBlobResponse) => {
-                        if (!uploadHasBecomeIrrelevant) {
-                            removeListeners();
-                            this.localBlobCache.set(localId, {
-                                state: "uploaded",
-                                blob,
-                                storageId: createBlobResponse.id,
-                                uploadTime: Date.now(),
-                                minTTLInSeconds: createBlobResponse.minTTLInSeconds,
-                            });
-                            resolve();
-                        }
-                    })
-                        .catch((error) => {
-                        if (!uploadHasBecomeIrrelevant) {
-                            removeListeners();
-                            // If the storage call errors, we can't recover. Reject to throw back to the caller.
-                            this.localBlobCache.delete(localId);
-                            this.pendingBlobsWithAttachedHandles.delete(localId);
-                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                            reject(error);
-                        }
-                    });
-                });
-            };
-            /**
-             * Expects the localBlobCache entry for the given localId to be in uploaded or attached state when called.
-             * Returns a promise that resolves to true if the blob is successfully attached, or false if it cannot be
-             * attached and the upload flow needs to be restarted from the top (currently only if the TTL expires before
-             * attach can be completed). In the latter case, the localBlobRecord will also be reset to localOnly state.
-             * The promise rejects if the signal is aborted.
-             */
-            const tryAttach = async () => {
-                const localBlobRecord = this.localBlobCache.get(localId);
-                if (localBlobRecord?.state === "attached") {
-                    // In normal creation flows, the blob will be in uploaded state here. But if we are loading from pending
-                    // state and see an attach message from the client that generated the pending state, we may have reached
-                    // attached state in the middle of the upload attempt. In that case there's no more work to do and we
-                    // can just return.
-                    return true;
-                }
-                assert(localBlobRecord?.state === "uploaded", 0xc82 /* Attempting to attach from unexpected state */);
-                // If we just uploaded the blob TTL really shouldn't be expired at this location. But if we loaded from
-                // pending state, the upload may have happened some time far in the past and could be expired here.
-                if (isTTLTooCloseToExpiry(localBlobRecord)) {
-                    // If the TTL is expired, we assume it's gone from the storage and so is effectively localOnly again.
-                    // Then when we re-enter the loop, we'll re-upload it.
-                    this.localBlobCache.set(localId, { state: "localOnly", blob });
-                    // Emitting here isn't really necessary since the only listener would be attached below. Including here
-                    // for completeness though, in case we add other listeners in the future.
-                    this.internalEvents.emit("blobExpired", localId);
-                    return false;
-                }
-                else {
-                    this.localBlobCache.set(localId, {
-                        ...localBlobRecord,
-                        state: "attaching",
-                    });
-                    // Send and await 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.
-                    return new Promise((resolve, reject) => {
-                        const onProcessedBlobAttach = (_localId, _storageId) => {
-                            if (_localId === localId) {
-                                removeListeners();
-                                resolve(true);
-                            }
-                        };
-                        // Although we already checked for TTL expiry above, the message we're about to send may later be asked
-                        // to resubmit. Before we resubmit, we check again for TTL expiry - this listener is how we learn if
-                        // we discovered expiry in the resubmit flow.
-                        const onBlobExpired = (_localId) => {
-                            if (_localId === localId) {
-                                removeListeners();
-                                resolve(false);
-                            }
-                        };
-                        const onSignalAbort = () => {
-                            removeListeners();
-                            this.localBlobCache.delete(localId);
-                            this.pendingBlobsWithAttachedHandles.delete(localId);
-                            reject(createAbortError());
-                        };
-                        const removeListeners = () => {
-                            this.internalEvents.off("processedBlobAttach", onProcessedBlobAttach);
-                            this.internalEvents.off("blobExpired", onBlobExpired);
-                            signal?.removeEventListener("abort", onSignalAbort);
-                        };
-                        this.internalEvents.on("processedBlobAttach", onProcessedBlobAttach);
-                        this.internalEvents.on("blobExpired", onBlobExpired);
-                        signal?.addEventListener("abort", onSignalAbort);
-                        this.sendBlobAttachMessage(localId, localBlobRecord.storageId);
-                    });
-                }
-            };
-            let attachCompleted = false;
-            while (!attachCompleted) {
-                await ensureUploaded();
-                attachCompleted = await tryAttach();
-                // If something stopped the attach from completing successfully (currently just TTL expiry),
-                // we expect that the blob was already updated to reflect the updated state (i.e. back to localOnly)
-                // and we'll try the loop again from the top.
-            }
-            // When the blob successfully attaches, the localBlobRecord will have been updated to attached state
-            // at the time we processed the op, so there's nothing else to do here.
-        };
-        /**
-         * 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, 0xc53 /* Couldn't find a matching storage ID */);
-                this.redirectTable.set(localId, newStorageId);
-                // set identity (id -> id) entry
-                this.redirectTable.set(newStorageId, newStorageId);
-            }
-        };
-        /**
-         * Upload and attach any pending blobs that the BlobManager was loaded with that have not already
-         * been attached in the meantime.
-         * @returns A promise that resolves when all the uploads and attaches have completed, or rejects
-         * if any of them fail.
-         */
-        this.sharePendingBlobs = async () => {
-            const localIdsToUpload = [...this.pendingOnlyLocalIds];
-            this.pendingOnlyLocalIds.clear();
-            await Promise.all(localIdsToUpload.map(async (localId) => this.uploadAndAttach(localId)));
-        };
         const { routeContext, blobManagerLoadInfo, storage, sendBlobAttachMessage, blobRequested, isBlobDeleted, runtime, pendingBlobs, createBlobPayloadPending, } = props;
         this.routeContext = routeContext;
         this.storage = storage;
@@ -469,6 +296,177 @@ export class BlobManager {
         });
         return blobHandle;
     }
+    /**
+     * Upload and attach the localBlobCache entry for the given localId.
+     *
+     * Expects the localBlobCache entry for the given localId to be in either localOnly or uploaded state
+     * when called. Returns a promise that resolves when the blob completes uploading and attaching, or else
+     * rejects if an error is encountered or the signal is aborted.
+     */
+    uploadAndAttach = async (localId, signal) => {
+        if (signal?.aborted === true) {
+            this.localBlobCache.delete(localId);
+            this.pendingBlobsWithAttachedHandles.delete(localId);
+            throw createAbortError();
+        }
+        const localBlobRecordInitial = this.localBlobCache.get(localId);
+        assert(localBlobRecordInitial?.state === "localOnly" ||
+            localBlobRecordInitial?.state === "uploaded", 0xc80 /* Expect uploadAndAttach to be called with either localOnly or uploaded state */);
+        const { blob } = localBlobRecordInitial;
+        /**
+         * Expects the localBlobCache entry for the given localId to be in either localOnly or uploaded state
+         * when called. Returns a promise that resolves when the blob is in uploaded or attached state, or else
+         * rejects on error during upload or if the signal is aborted.
+         *
+         * Most of the time this should be expected to exit in uploaded state, but if we are loading from pending
+         * state we may see an attach message from the client that generated the pending state, which can complete the
+         * attach while the upload is outstanding.
+         */
+        const ensureUploaded = async () => {
+            const localBlobRecord = this.localBlobCache.get(localId);
+            if (localBlobRecord?.state === "uploaded") {
+                // In normal creation flows, the blob will be in localOnly state here. But in the case of loading
+                // with pending state we can call it with an uploaded-but-not-attached blob. Start the upload
+                // flow only if it's localOnly.
+                return;
+            }
+            assert(localBlobRecord?.state === "localOnly", 0xc81 /* Attempting to upload from unexpected state */);
+            this.localBlobCache.set(localId, { state: "uploading", blob });
+            await new Promise((resolve, reject) => {
+                // If we eventually have driver-level support for abort, then this can simplify a bit as we won't
+                // need to track upload completion and abort separately. Until then, we need to handle the case that
+                // the upload continues and settles after becoming irrelevant due to signal abort or blob attach.
+                let uploadHasBecomeIrrelevant = false;
+                const onSignalAbort = () => {
+                    removeListeners();
+                    uploadHasBecomeIrrelevant = true;
+                    this.localBlobCache.delete(localId);
+                    this.pendingBlobsWithAttachedHandles.delete(localId);
+                    reject(createAbortError());
+                };
+                const onProcessedBlobAttach = (_localId, _storageId) => {
+                    if (_localId === localId) {
+                        removeListeners();
+                        uploadHasBecomeIrrelevant = true;
+                        resolve();
+                    }
+                };
+                const removeListeners = () => {
+                    this.internalEvents.off("processedBlobAttach", onProcessedBlobAttach);
+                    signal?.removeEventListener("abort", onSignalAbort);
+                };
+                this.internalEvents.on("processedBlobAttach", onProcessedBlobAttach);
+                signal?.addEventListener("abort", onSignalAbort);
+                this.storage
+                    .createBlob(blob)
+                    .then((createBlobResponse) => {
+                    if (!uploadHasBecomeIrrelevant) {
+                        removeListeners();
+                        this.localBlobCache.set(localId, {
+                            state: "uploaded",
+                            blob,
+                            storageId: createBlobResponse.id,
+                            uploadTime: Date.now(),
+                            minTTLInSeconds: createBlobResponse.minTTLInSeconds,
+                        });
+                        resolve();
+                    }
+                })
+                    .catch((error) => {
+                    if (!uploadHasBecomeIrrelevant) {
+                        removeListeners();
+                        // If the storage call errors, we can't recover. Reject to throw back to the caller.
+                        this.localBlobCache.delete(localId);
+                        this.pendingBlobsWithAttachedHandles.delete(localId);
+                        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                        reject(error);
+                    }
+                });
+            });
+        };
+        /**
+         * Expects the localBlobCache entry for the given localId to be in uploaded or attached state when called.
+         * Returns a promise that resolves to true if the blob is successfully attached, or false if it cannot be
+         * attached and the upload flow needs to be restarted from the top (currently only if the TTL expires before
+         * attach can be completed). In the latter case, the localBlobRecord will also be reset to localOnly state.
+         * The promise rejects if the signal is aborted.
+         */
+        const tryAttach = async () => {
+            const localBlobRecord = this.localBlobCache.get(localId);
+            if (localBlobRecord?.state === "attached") {
+                // In normal creation flows, the blob will be in uploaded state here. But if we are loading from pending
+                // state and see an attach message from the client that generated the pending state, we may have reached
+                // attached state in the middle of the upload attempt. In that case there's no more work to do and we
+                // can just return.
+                return true;
+            }
+            assert(localBlobRecord?.state === "uploaded", 0xc82 /* Attempting to attach from unexpected state */);
+            // If we just uploaded the blob TTL really shouldn't be expired at this location. But if we loaded from
+            // pending state, the upload may have happened some time far in the past and could be expired here.
+            if (isTTLTooCloseToExpiry(localBlobRecord)) {
+                // If the TTL is expired, we assume it's gone from the storage and so is effectively localOnly again.
+                // Then when we re-enter the loop, we'll re-upload it.
+                this.localBlobCache.set(localId, { state: "localOnly", blob });
+                // Emitting here isn't really necessary since the only listener would be attached below. Including here
+                // for completeness though, in case we add other listeners in the future.
+                this.internalEvents.emit("blobExpired", localId);
+                return false;
+            }
+            else {
+                this.localBlobCache.set(localId, {
+                    ...localBlobRecord,
+                    state: "attaching",
+                });
+                // Send and await 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.
+                return new Promise((resolve, reject) => {
+                    const onProcessedBlobAttach = (_localId, _storageId) => {
+                        if (_localId === localId) {
+                            removeListeners();
+                            resolve(true);
+                        }
+                    };
+                    // Although we already checked for TTL expiry above, the message we're about to send may later be asked
+                    // to resubmit. Before we resubmit, we check again for TTL expiry - this listener is how we learn if
+                    // we discovered expiry in the resubmit flow.
+                    const onBlobExpired = (_localId) => {
+                        if (_localId === localId) {
+                            removeListeners();
+                            resolve(false);
+                        }
+                    };
+                    const onSignalAbort = () => {
+                        removeListeners();
+                        this.localBlobCache.delete(localId);
+                        this.pendingBlobsWithAttachedHandles.delete(localId);
+                        reject(createAbortError());
+                    };
+                    const removeListeners = () => {
+                        this.internalEvents.off("processedBlobAttach", onProcessedBlobAttach);
+                        this.internalEvents.off("blobExpired", onBlobExpired);
+                        signal?.removeEventListener("abort", onSignalAbort);
+                    };
+                    this.internalEvents.on("processedBlobAttach", onProcessedBlobAttach);
+                    this.internalEvents.on("blobExpired", onBlobExpired);
+                    signal?.addEventListener("abort", onSignalAbort);
+                    this.sendBlobAttachMessage(localId, localBlobRecord.storageId);
+                });
+            }
+        };
+        let attachCompleted = false;
+        while (!attachCompleted) {
+            await ensureUploaded();
+            attachCompleted = await tryAttach();
+            // If something stopped the attach from completing successfully (currently just TTL expiry),
+            // we expect that the blob was already updated to reflect the updated state (i.e. back to localOnly)
+            // and we'll try the loop again from the top.
+        }
+        // When the blob successfully attaches, the localBlobRecord will have been updated to attached state
+        // at the time we processed the op, so there's nothing else to do here.
+    };
     /**
      * Resubmit a BlobAttach op. Used to add storage IDs to messages that were
      * submitted to runtime while disconnected.
@@ -616,6 +614,41 @@ export class BlobManager {
         }, error);
         throw error;
     }
+    /**
+     * 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.
+     */
+    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, 0xc53 /* Couldn't find a matching storage ID */);
+            this.redirectTable.set(localId, newStorageId);
+            // set identity (id -> id) entry
+            this.redirectTable.set(newStorageId, newStorageId);
+        }
+    };
+    /**
+     * Upload and attach any pending blobs that the BlobManager was loaded with that have not already
+     * been attached in the meantime.
+     * @returns A promise that resolves when all the uploads and attaches have completed, or rejects
+     * if any of them fail.
+     */
+    sharePendingBlobs = async () => {
+        const localIdsToUpload = [...this.pendingOnlyLocalIds];
+        this.pendingOnlyLocalIds.clear();
+        await Promise.all(localIdsToUpload.map(async (localId) => this.uploadAndAttach(localId)));
+    };
     /**
      * 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