@fluidframework/container-runtime 2.0.0-dev-rc.3.0.0.250606 → 2.0.0-dev-rc.3.0.0.254274

package/dist/blobManager.js

@@ -7,11 +7,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlobManager = exports.BlobHandle = void 0;
 const client_utils_1 = require("@fluid-internal/client-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
-const core_utils_1 = require("@fluidframework/core-utils");
-const runtime_utils_1 = require("@fluidframework/runtime-utils");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const internal_1 = require("@fluidframework/core-utils/internal");
+const internal_2 = require("@fluidframework/driver-utils/internal");
+const internal_3 = require("@fluidframework/runtime-utils/internal");
+const internal_4 = require("@fluidframework/telemetry-utils/internal");
 const uuid_1 = require("uuid");
-const driver_utils_1 = require("@fluidframework/driver-utils");
 /**
  * This class represents blob (long string)
  * This object is used only when creating (writing) new blob and serialization purposes.
@@ -32,7 +32,7 @@ class BlobHandle {
         this.get = get;
         this.onAttachGraph = onAttachGraph;
         this.attached = false;
-        this.absolutePath = (0, runtime_utils_1.generateHandleContextPath)(path, this.routeContext);
+        this.absolutePath = (0, internal_3.generateHandleContextPath)(path, this.routeContext);
     }
     attachGraph() {
         if (!this.attached) {
@@ -45,32 +45,15 @@ class BlobHandle {
     }
 }
 exports.BlobHandle = BlobHandle;
+const stashedPendingBlobOverrides = {
+    stashedUpload: true,
+    storageId: undefined,
+    minTTLInSeconds: undefined,
+    uploadTime: undefined,
+};
 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
-     * deleted. The BlobAttach op notifies the server that blob is in use. The server will then not delete the
-     * the blob as long as it is listed as referenced in future summaries. The summarizing client will know to
-     * include the storage ID in the summary when it sees the op.
-     *
-     * The op will also include a local ID to inform all clients of the relation to the storage ID, without
-     * knowledge of which they cannot request the blob from storage. It's important that this op is sequenced
-     * before any ops that reference the local ID, otherwise, an invalid handle could be added to the document.
-     */
-    sendBlobAttachOp, 
-    // Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
-    // blobPath's format - `/<BlobManager.basePath>/<blobId>`.
-    blobRequested, 
-    // Called to check if a blob has been deleted by GC.
-    // blobPath's format - `/<BlobManager.basePath>/<blobId>`.
-    isBlobDeleted, runtime, stashedBlobs = {}, closeContainer) {
+    constructor(props) {
         super();
-        this.routeContext = routeContext;
-        this.getStorage = getStorage;
-        this.blobRequested = blobRequested;
-        this.isBlobDeleted = isBlobDeleted;
-        this.runtime = runtime;
-        this.closeContainer = closeContainer;
         /**
          * Blobs which we have not yet seen a BlobAttach op round-trip and not yet attached to a DDS.
          */
@@ -89,50 +72,50 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
          */
         this.tombstonedBlobs = new Set();
         this.stopAttaching = false;
-        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({
+        const { routeContext, snapshot, getStorage, sendBlobAttachOp, blobRequested, isBlobDeleted, runtime, stashedBlobs, closeContainer, } = props;
+        this.routeContext = routeContext;
+        this.getStorage = getStorage;
+        this.blobRequested = blobRequested;
+        this.isBlobDeleted = isBlobDeleted;
+        this.runtime = runtime;
+        this.closeContainer = closeContainer;
+        this.mc = (0, internal_4.createChildMonitoringContext)({
             logger: this.runtime.logger,
             namespace: "BlobManager",
         });
         this.redirectTable = this.load(snapshot);
         // Begin uploading stashed blobs from previous container instance
-        Object.entries(stashedBlobs).forEach(([localId, entry]) => {
+        Object.entries(stashedBlobs ?? {}).forEach(([localId, entry]) => {
+            const { acked, storageId, minTTLInSeconds, uploadTime } = entry;
             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;
+            const pendingEntry = {
+                blob,
+                opsent: true,
+                handleP: new internal_1.Deferred(),
+                storageId,
+                uploadP: undefined,
+                uploadTime,
+                minTTLInSeconds,
+                attached: true,
+                acked,
+            };
+            this.pendingBlobs.set(localId, pendingEntry);
+            if (storageId !== undefined && minTTLInSeconds && uploadTime) {
+                const timeLapseSinceLocalUpload = (Date.now() - 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,
-                        uploading: false,
-                        opsent: true,
-                        handleP: new core_utils_1.Deferred(),
-                        storageId,
-                        uploadP: undefined,
-                        uploadTime: entry.uploadTime,
-                        minTTLInSeconds: entry.minTTLInSeconds,
-                        attached,
-                        acked,
-                    });
+                if (minTTLInSeconds - timeLapseSinceLocalUpload > minTTLInSeconds / 2) {
                     return;
                 }
             }
             this.pendingBlobs.set(localId, {
-                blob,
-                uploading: true,
-                handleP: new core_utils_1.Deferred(),
+                ...pendingEntry,
+                ...stashedPendingBlobOverrides,
                 uploadP: this.uploadBlob(localId, blob),
-                attached,
-                acked,
-                opsent: true,
-                pendingStashed: true,
             });
         });
         this.sendBlobAttachOp = (localId, blobId) => {
             const pendingEntry = this.pendingBlobs.get(localId);
-            (0, core_utils_1.assert)(pendingEntry !== undefined, 0x725 /* Must have pending blob entry for upcoming op */);
+            (0, internal_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;
@@ -144,7 +127,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
                 });
                 if (expired) {
                     // we want to avoid submitting ops with broken handles
-                    this.closeContainer(new telemetry_utils_1.GenericError("Trying to submit a BlobAttach for expired blob", undefined, {
+                    this.closeContainer(new internal_4.GenericError("Trying to submit a BlobAttach for expired blob", undefined, {
                         localId,
                         blobId,
                         secondsSinceUpload,
@@ -168,22 +151,25 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
             this.pendingBlobs.size > 0);
     }
     createAbortError(pending) {
-        return new telemetry_utils_1.LoggingError("uploadBlob aborted", {
+        return new internal_4.LoggingError("uploadBlob aborted", {
             acked: pending?.acked,
             uploadTime: pending?.uploadTime,
         });
     }
-    hasPendingStashedBlobs() {
-        return Array.from(this.pendingBlobs.values()).some((e) => e.pendingStashed === true);
+    hasPendingStashedUploads() {
+        return Array.from(this.pendingBlobs.values()).some((e) => e.stashedUpload === true);
     }
     /**
      * Upload blobs added while offline. This must be completed before connecting and resubmitting ops.
      */
-    async processStashedChanges() {
+    async trackPendingStashedUploads() {
         const pendingUploads = Array.from(this.pendingBlobs.values())
-            .filter((e) => e.pendingStashed === true)
+            .filter((e) => e.stashedUpload === true)
             .map(async (e) => e.uploadP);
-        await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, {
+        if (pendingUploads.length === 0) {
+            return;
+        }
+        await internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, {
             eventName: "BlobUploadProcessStashedChanges",
             count: pendingUploads.length,
         }, async () => Promise.all(pendingUploads), { start: true, end: true });
@@ -198,7 +184,7 @@ class BlobManager extends client_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, core_utils_1.assert)(!undefinedValueInTable ||
+        (0, internal_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;
     }
@@ -216,22 +202,22 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
         }
         let storageId;
         if (this.runtime.attachState === container_definitions_1.AttachState.Detached) {
-            (0, core_utils_1.assert)(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
+            (0, internal_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, core_utils_1.assert)(!!attachedStorageId, 0x11f /* "requesting unknown blobs" */);
+            (0, internal_1.assert)(!!attachedStorageId, 0x11f /* "requesting unknown blobs" */);
             storageId = attachedStorageId;
         }
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "AttachmentReadBlob", id: storageId }, async () => {
+        return internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "AttachmentReadBlob", id: storageId }, async () => {
             return this.getStorage().readBlob(storageId);
         }, { end: true, cancel: "error" });
     }
     getBlobHandle(id) {
-        (0, core_utils_1.assert)(this.redirectTable.has(id) || this.pendingBlobs.has(id), 0x384 /* requesting handle for unknown blob */);
+        (0, internal_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
             ? () => {
@@ -258,7 +244,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
             this.mc.logger.sendTelemetryEvent({ eventName: "CreateBlobWhileAttaching" });
             await new Promise((resolve) => this.runtime.once("attached", resolve));
         }
-        (0, core_utils_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Attached, 0x385 /* For clarity and paranoid defense against adding future attachment states */);
+        (0, internal_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();
         }
@@ -267,8 +253,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
         const localId = (0, uuid_1.v4)();
         const pendingEntry = {
             blob,
-            uploading: true,
-            handleP: new core_utils_1.Deferred(),
+            handleP: new internal_1.Deferred(),
             uploadP: this.uploadBlob(localId, blob),
             attached: false,
             acked: false,
@@ -287,15 +272,15 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
         });
     }
     async uploadBlob(localId, blob) {
-        return (0, driver_utils_1.runWithRetry)(async () => {
+        return (0, internal_2.runWithRetry)(async () => {
             try {
                 return await this.getStorage().createBlob(blob);
             }
             catch (error) {
                 const entry = this.pendingBlobs.get(localId);
-                (0, core_utils_1.assert)(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
-                if (entry.opsent && !(0, driver_utils_1.canRetryOnError)(error)) {
-                    throw (0, telemetry_utils_1.wrapError)(error, () => new telemetry_utils_1.LoggingError(`uploadBlob error`, { canRetry: true }));
+                (0, internal_1.assert)(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
+                if (entry.opsent && !(0, internal_2.canRetryOnError)(error)) {
+                    throw (0, internal_4.wrapError)(error, () => new internal_4.LoggingError(`uploadBlob error`, { canRetry: true }));
                 }
                 throw error;
             }
@@ -331,12 +316,13 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
     }
     onUploadResolve(localId, response) {
         const entry = this.pendingBlobs.get(localId);
-        (0, core_utils_1.assert)(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
+        (0, internal_1.assert)(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
         if ((entry.abortSignal?.aborted === true && !entry.opsent) || this.stopAttaching) {
             this.deletePendingBlob(localId);
             return;
         }
-        (0, core_utils_1.assert)(entry.uploading === true, 0x386 /* Must have pending blob entry for uploaded blob */);
+        (0, internal_1.assert)(entry.storageId === undefined, 0x386 /* Must have pending blob entry for uploaded blob */);
+        entry.stashedUpload = undefined;
         entry.storageId = response.id;
         entry.uploadTime = Date.now();
         entry.minTTLInSeconds = response.minTTLInSeconds;
@@ -370,13 +356,13 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
      * @param metadata - op metadata containing storage and/or local IDs
      */
     reSubmit(metadata) {
-        (0, core_utils_1.assert)(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
+        (0, internal_1.assert)(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
         const { localId, blobId } = metadata;
-        (0, core_utils_1.assert)(localId !== undefined, 0x50d /* local ID not available on reSubmit */);
+        (0, internal_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, core_utils_1.assert)(pendingEntry?.opsent === true && !!pendingEntry?.storageId, 0x38d /* blob must be uploaded before resubmitting BlobAttach op */);
+            (0, internal_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);
@@ -390,11 +376,8 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
                 this.deletePendingBlob(localId);
                 return;
             }
-            if (pendingEntry?.pendingStashed) {
-                pendingEntry.pendingStashed = false;
-            }
         }
-        (0, core_utils_1.assert)(blobId !== undefined, 0x12a /* "Missing blob id on metadata" */);
+        (0, internal_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
@@ -405,7 +388,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
         // set identity (id -> id) entry
         this.setRedirection(blobId, blobId);
         if (local) {
-            (0, core_utils_1.assert)(localId !== undefined, 0x50e /* local ID not present in blob attach message */);
+            (0, internal_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.
@@ -413,7 +396,7 @@ class BlobManager extends client_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, core_utils_1.assert)(entry !== undefined, 0x38f /* local online BlobAttach op with no pending blob entry */);
+                    (0, internal_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));
@@ -472,7 +455,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
         const blobIds = this.storageIds.size > 0
             ? Array.from(this.storageIds)
             : Array.from(this.redirectTable.keys());
-        const builder = new runtime_utils_1.SummaryTreeBuilder();
+        const builder = new internal_3.SummaryTreeBuilder();
         blobIds.forEach((blobId) => {
             builder.addAttachment(blobId);
         });
@@ -493,7 +476,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
     getGCData(fullGC = false) {
         const gcData = { gcNodes: {} };
         for (const [localId, storageId] of this.redirectTable) {
-            (0, core_utils_1.assert)(!!storageId, 0x390 /* Must be attached to get GC data */);
+            (0, internal_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
@@ -548,14 +531,14 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
                 continue;
             }
             const storageId = this.redirectTable.get(blobId);
-            (0, core_utils_1.assert)(!!storageId, 0x5bb /* Must be attached to run GC */);
+            (0, internal_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, core_utils_1.assert)(!!storageId, 0x5bc /* Must be attached to run GC */);
+            (0, internal_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);
@@ -603,7 +586,7 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
             return;
         }
         const request = { url: blobId };
-        const error = (0, runtime_utils_1.responseToException)((0, runtime_utils_1.createResponseError)(404, `Blob was deleted`, request), request);
+        const error = (0, internal_3.responseToException)((0, internal_3.createResponseError)(404, `Blob was deleted`, request), request);
         // Only log deleted events. Tombstone events are logged by garbage collector.
         this.mc.logger.sendErrorEvent({
             eventName: "GC_Deleted_Blob_Requested",
@@ -612,17 +595,17 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
         throw error;
     }
     setRedirectTable(table) {
-        (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 */);
+        (0, internal_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
+        (0, internal_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, core_utils_1.assert)(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
+            (0, internal_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);
         }
     }
     async attachAndGetPendingBlobs(stopBlobAttachingSignal) {
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "GetPendingBlobs" }, async () => {
+        return internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "GetPendingBlobs" }, async () => {
             if (this.pendingBlobs.size === 0) {
                 return;
             }
@@ -664,14 +647,13 @@ class BlobManager extends client_utils_1.TypedEventEmitter {
                     });
                     continue;
                 }
-                (0, core_utils_1.assert)(entry.attached === true, 0x790 /* stashed blob should be attached */);
+                (0, internal_1.assert)(entry.attached === true, 0x790 /* stashed blob should be attached */);
                 if (!entry.opsent) {
                     this.sendBlobAttachOp(id, entry.storageId);
                 }
                 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,
@@ -697,7 +679,7 @@ function getGCNodePathFromBlobId(blobId) {
  */
 function getBlobIdFromGCNodePath(nodePath) {
     const pathParts = nodePath.split("/");
-    (0, core_utils_1.assert)(pathParts.length === 3 && pathParts[1] === BlobManager.basePath, 0x5bd /* Invalid blob node path */);
+    (0, internal_1.assert)(pathParts.length === 3 && pathParts[1] === BlobManager.basePath, 0x5bd /* Invalid blob node path */);
     return pathParts[2];
 }
 //# sourceMappingURL=blobManager.js.map