@fluidframework/container-loader 0.52.1 → 0.53.0-46105

package/src/container.ts

@@ -51,7 +51,7 @@ import {
     ensureFluidResolvedUrl,
     combineAppAndProtocolSummary,
     runWithRetry,
-    canRetryOnError,
+    isFluidResolvedUrl,
 } from "@fluidframework/driver-utils";
 import {
     isSystemMessage,
@@ -279,7 +279,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                         onClosed(err);
                     });
             }),
-            { start: true, end: true, cancel: "error" },
+            { start: true, end: true, cancel: "generic" },
         );
     }
 
@@ -293,9 +293,16 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         const container = new Container(
             loader,
             {});
-        container._lifecycleState = "loading";
-        await container.createDetached(codeDetails);
-        return container;
+
+        return PerformanceEvent.timedExecAsync(
+            container.logger,
+            { eventName: "CreateDetached" },
+            async (_event) => {
+                container._lifecycleState = "loading";
+                await container.createDetached(codeDetails);
+                return container;
+            },
+            { start: true, end: true, cancel: "generic" });
     }
 
     /**
@@ -309,10 +316,16 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         const container = new Container(
             loader,
             {});
-        const deserializedSummary = JSON.parse(snapshot) as ISummaryTree;
-        container._lifecycleState = "loading";
-        await container.rehydrateDetachedFromSnapshot(deserializedSummary);
-        return container;
+        return PerformanceEvent.timedExecAsync(
+            container.logger,
+            { eventName: "RehydrateDetachedFromSnapshot" },
+            async (_event) => {
+                const deserializedSummary = JSON.parse(snapshot) as ISummaryTree;
+                container._lifecycleState = "loading";
+                await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+                return container;
+            },
+            { start: true, end: true, cancel: "generic" });
     }
 
     public subLogger: TelemetryLogger;
@@ -412,33 +425,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return this._loadedFromVersion;
     }
 
-    /**
-     * Tells if container is in read-only mode.
-     * Data stores should listen for "readonly" notifications and disallow user making changes to data stores.
-     * Readonly state can be because of no storage write permission,
-     * or due to host forcing readonly mode for container.
-     *
-     * We do not differentiate here between no write access to storage vs. host disallowing changes to container -
-     * in all cases container runtime and data stores should respect readonly state and not allow local changes.
-     *
-     * It is undefined if we have not yet established websocket connection
-     * and do not know if user has write access to a file.
-     * @deprecated - use readOnlyInfo
-     */
-    public get readonly() {
-        return this._deltaManager.readonly;
-    }
-
-    /**
-     * Tells if user has no write permissions for file in storage
-     * It is undefined if we have not yet established websocket connection
-     * and do not know if user has write access to a file.
-     * @deprecated - use readOnlyInfo
-     */
-    public get readonlyPermissions() {
-        return this._deltaManager.readonlyPermissions;
-    }
-
     public get readOnlyInfo(): ReadOnlyInfo {
         return this._deltaManager.readOnlyInfo;
     }
@@ -576,7 +562,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             {
                 all: {
                     clientType, // Differentiating summarizer container from main container
-                    loaderVersion: pkgVersion,
                     containerId: uuid(),
                     docId: () => this.id,
                     containerAttachState: () => this._attachState,
@@ -672,22 +657,22 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 switch (event) {
                     case dirtyContainerEvent:
                         if (this._dirtyContainer) {
-                            listener(dirtyContainerEvent);
+                            listener();
                         }
                         break;
                     case savedContainerEvent:
                         if (!this._dirtyContainer) {
-                            listener(savedContainerEvent);
+                            listener();
                         }
                         break;
                     case connectedEventName:
                          if (this.connected) {
-                            listener(event, this.clientId);
+                            listener(this.clientId);
                          }
                          break;
                     case disconnectedEventName:
                         if (!this.connected) {
-                            listener(event);
+                            listener();
                         }
                         break;
                     default:
@@ -719,6 +704,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
                 this._protocolHandler?.close();
 
+                this.connectionStateHandler.dispose();
+
                 this._context?.dispose(error !== undefined ? new Error(error.message) : undefined);
 
                 assert(this.connectionState === ConnectionState.Disconnected,
@@ -786,113 +773,113 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     }
 
     public async attach(request: IRequest): Promise<void> {
-        if (this._lifecycleState !== "loaded") {
-            throw new UsageError(`containerNotValidForAttach [${this._lifecycleState}]`);
-        }
+        await PerformanceEvent.timedExecAsync(this.logger, { eventName: "Attach" }, async () => {
+            if (this._lifecycleState !== "loaded") {
+                throw new UsageError(`containerNotValidForAttach [${this._lifecycleState}]`);
+            }
 
-        // If container is already attached or attach is in progress, throw an error.
-        assert(this._attachState === AttachState.Detached && !this.attachStarted,
-            0x205 /* "attach() called more than once" */);
-        this.attachStarted = true;
+            // If container is already attached or attach is in progress, throw an error.
+            assert(this._attachState === AttachState.Detached && !this.attachStarted,
+                0x205 /* "attach() called more than once" */);
+            this.attachStarted = true;
 
-        // If attachment blobs were uploaded in detached state we will go through a different attach flow
-        const hasAttachmentBlobs = this.loader.services.detachedBlobStorage !== undefined
-            && this.loader.services.detachedBlobStorage.size > 0;
+            // If attachment blobs were uploaded in detached state we will go through a different attach flow
+            const hasAttachmentBlobs = this.loader.services.detachedBlobStorage !== undefined
+                && this.loader.services.detachedBlobStorage.size > 0;
 
-        try {
-            assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
-
-            let summary: ISummaryTree;
-            if (!hasAttachmentBlobs) {
-                // Get the document state post attach - possibly can just call attach but we need to change the
-                // semantics around what the attach means as far as async code goes.
-                const appSummary: ISummaryTree = this.context.createSummary();
-                const protocolSummary = this.captureProtocolSummary();
-                summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-
-                // Set the state as attaching as we are starting the process of attaching container.
-                // This should be fired after taking the summary because it is the place where we are
-                // starting to attach the container to storage.
-                // Also, this should only be fired in detached container.
-                this._attachState = AttachState.Attaching;
-                this.context.notifyAttaching();
-            }
+            try {
+                assert(this.deltaManager.inbound.length === 0,
+                    0x0d6 /* "Inbound queue should be empty when attaching" */);
+
+                let summary: ISummaryTree;
+                if (!hasAttachmentBlobs) {
+                    // Get the document state post attach - possibly can just call attach but we need to change the
+                    // semantics around what the attach means as far as async code goes.
+                    const appSummary: ISummaryTree = this.context.createSummary();
+                    const protocolSummary = this.captureProtocolSummary();
+                    summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
+
+                    // Set the state as attaching as we are starting the process of attaching container.
+                    // This should be fired after taking the summary because it is the place where we are
+                    // starting to attach the container to storage.
+                    // Also, this should only be fired in detached container.
+                    this._attachState = AttachState.Attaching;
+                    this.context.notifyAttaching();
+                }
 
-            // Actually go and create the resolved document
-            const createNewResolvedUrl = await this.urlResolver.resolve(request);
-            ensureFluidResolvedUrl(createNewResolvedUrl);
-            if (this.service === undefined) {
-                this.service = await runWithRetry(
-                    async () => this.serviceFactory.createContainer(
-                        summary,
-                        createNewResolvedUrl,
-                        this.subLogger,
-                    ),
-                    "containerAttach",
-                    this.logger,
-                    {}, // progress
-                );
-            }
-            const resolvedUrl = this.service.resolvedUrl;
-            ensureFluidResolvedUrl(resolvedUrl);
-            this._resolvedUrl = resolvedUrl;
-            await this.connectStorageService();
-
-            if (hasAttachmentBlobs) {
-                // upload blobs to storage
-                assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
-
-                // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
-                // support blob handles that only know about the local IDs
-                const redirectTable = new Map<string, string>();
-                // if new blobs are added while uploading, upload them too
-                while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
-                    const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter(
-                        (id) => !redirectTable.has(id));
-                    for (const id of newIds) {
-                        const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
-                        const response = await this.storageService.createBlob(blob);
-                        redirectTable.set(id, response.id);
-                    }
+                // Actually go and create the resolved document
+                const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                ensureFluidResolvedUrl(createNewResolvedUrl);
+                if (this.service === undefined) {
+                    this.service = await runWithRetry(
+                        async () => this.serviceFactory.createContainer(
+                            summary,
+                            createNewResolvedUrl,
+                            this.subLogger,
+                        ),
+                        "containerAttach",
+                        this.logger,
+                        {}, // progress
+                    );
                 }
+                const resolvedUrl = this.service.resolvedUrl;
+                ensureFluidResolvedUrl(resolvedUrl);
+                this._resolvedUrl = resolvedUrl;
+                await this.connectStorageService();
+
+                if (hasAttachmentBlobs) {
+                    // upload blobs to storage
+                    assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+
+                    // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
+                    // support blob handles that only know about the local IDs
+                    const redirectTable = new Map<string, string>();
+                    // if new blobs are added while uploading, upload them too
+                    while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
+                        const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter(
+                            (id) => !redirectTable.has(id));
+                        for (const id of newIds) {
+                            const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
+                            const response = await this.storageService.createBlob(blob);
+                            redirectTable.set(id, response.id);
+                        }
+                    }
 
-                // take summary and upload
-                const appSummary: ISummaryTree = this.context.createSummary(redirectTable);
-                const protocolSummary = this.captureProtocolSummary();
-                summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
+                    // take summary and upload
+                    const appSummary: ISummaryTree = this.context.createSummary(redirectTable);
+                    const protocolSummary = this.captureProtocolSummary();
+                    summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
 
-                this._attachState = AttachState.Attaching;
-                this.context.notifyAttaching();
+                    this._attachState = AttachState.Attaching;
+                    this.context.notifyAttaching();
 
-                await this.storageService.uploadSummaryWithContext(summary, {
-                    referenceSequenceNumber: 0,
-                    ackHandle: undefined,
-                    proposalHandle: undefined,
-                });
-            }
+                    await this.storageService.uploadSummaryWithContext(summary, {
+                        referenceSequenceNumber: 0,
+                        ackHandle: undefined,
+                        proposalHandle: undefined,
+                    });
+                }
 
-            this._attachState = AttachState.Attached;
-            this.emit("attached");
+                this._attachState = AttachState.Attached;
+                this.emit("attached");
 
-            // Propagate current connection state through the system.
-            this.propagateConnectionState();
-            if (!this.closed) {
-                this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
-            }
-        } catch(error) {
-            // we should retry upon any retriable errors, so we shouldn't see them here
-            assert(!canRetryOnError(error), 0x24f /* "retriable error thrown from attach()" */);
-
-            // add resolved URL on error object so that host has the ability to find this document and delete it
-            const newError = normalizeError(error);
-            const resolvedUrl = this.resolvedUrl;
-            if (resolvedUrl) {
-                ensureFluidResolvedUrl(resolvedUrl);
-                newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
+                // Propagate current connection state through the system.
+                this.propagateConnectionState();
+                if (!this.closed) {
+                    this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
+                }
+            } catch(error) {
+                // add resolved URL on error object so that host has the ability to find this document and delete it
+                const newError = normalizeError(error);
+                const resolvedUrl = this.resolvedUrl;
+                if (isFluidResolvedUrl(resolvedUrl)) {
+                    newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
+                }
+                this.close(newError);
+                throw newError;
             }
-            this.close(newError);
-            throw newError;
-        }
+        },
+        { start: true, end: true, cancel: "generic" });
     }
 
     public async request(path: IRequest): Promise<IResponse> {
@@ -1539,7 +1526,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         if (this.clientDetailsOverride !== undefined) {
             merge(client.details, this.clientDetailsOverride);
         }
-
+        client.details.environment = [client.details.environment, ` loaderVersion:${pkgVersion}`].join(";");
         return client;
     }
 
@@ -1550,17 +1537,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
      * If it's not true, runtime is not in position to send ops.
      */
     private activeConnection() {
-        const active = this.connectionState === ConnectionState.Connected &&
+        return this.connectionState === ConnectionState.Connected &&
             this._deltaManager.connectionMode === "write";
-
-        // Check for presence of current client in quorum for "write" connections - inactive clients
-        // would get leave op after some long timeout (5 min) and that should automatically transition
-        // state to "read" mode.
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        assert(!active || this.getQuorum().getMember(this.clientId!) !== undefined,
-            0x276 /* "active connection not present in quorum" */);
-
-        return active;
     }
 
     private createDeltaManager() {

package/src/containerContext.ts

@@ -191,6 +191,10 @@ export class ContainerContext implements IContainerContext {
         this.attachListener();
     }
 
+    public getSpecifiedCodeDetails(): IFluidCodeDetails | undefined {
+        return (this.quorum.get("code") ?? this.quorum.get("code2")) as IFluidCodeDetails | undefined;
+    }
+
     public dispose(error?: Error): void {
         if (this._disposed) {
             return;

package/src/deltaManager.ts

@@ -93,6 +93,8 @@ const createReconnectError = (fluidErrorCode: string, err: any) =>
         (errorMessage: string) => new GenericNetworkError(fluidErrorCode, errorMessage, true /* canRetry */),
     );
 
+const fatalConnectErrorProp = { fatalConnectError: true };
+
 export interface IConnectionArgs {
     mode?: ConnectionMode;
     fetchOpsFromStorage?: boolean;
@@ -331,7 +333,7 @@ export class DeltaManager
     public get connectionMode(): ConnectionMode {
         assert(!this.downgradedConnection || this.connection?.mode === "write",
             0x277 /* "Did we forget to reset downgradedConnection on new connection?" */);
-        if (this.connection === undefined || this.downgradedConnection) {
+        if (this.connection === undefined) {
             return "read";
         }
         return this.connection.mode;
@@ -347,23 +349,13 @@ export class DeltaManager
      * and do not know if user has write access to a file.
      * @deprecated - use readOnlyInfo
      */
-    public get readonly() {
+     public get readonly() {
         if (this._forceReadonly) {
             return true;
         }
         return this._readonlyPermissions;
     }
 
-    /**
-     * Tells if user has no write permissions for file in storage
-     * It is undefined if we have not yet established websocket connection
-     * and do not know if user has write access to a file.
-     * @deprecated - use readOnlyInfo
-     */
-    public get readonlyPermissions() {
-        return this._readonlyPermissions;
-    }
-
     public get readOnlyInfo(): ReadOnlyInfo {
         const storageOnly = this.connection !== undefined && this.connection instanceof NoDeltaStream;
         if (storageOnly || this._forceReadonly || this._readonlyPermissions === true) {
@@ -402,6 +394,7 @@ export class DeltaManager
             return {
                 ...common,
                 connectionMode: this.connectionMode,
+                relayServiceAgent: this.connection.relayServiceAgent,
             };
         } else {
             return {
@@ -452,15 +445,15 @@ export class DeltaManager
                 value: readonly,
             });
         }
-        const oldValue = this.readonly;
+        const oldValue = this.readOnlyInfo.readonly;
         this._forceReadonly = readonly;
 
-        if (oldValue !== this.readonly) {
+        if (oldValue !== this.readOnlyInfo.readonly) {
             assert(this._reconnectMode !== ReconnectMode.Never,
                 0x279 /* "API is not supported for non-connecting or closed container" */);
 
             let reconnect = false;
-            if (this.readonly === true) {
+            if (this.readOnlyInfo.readonly === true) {
                 // If we switch to readonly while connected, we should disconnect first
                 // See comment in the "readonly" event handler to deltaManager set up by
                 // the ContainerRuntime constructor
@@ -473,7 +466,7 @@ export class DeltaManager
 
                 reconnect = this.disconnectFromDeltaStream("Force readonly");
             }
-            safeRaiseEvent(this, this.logger, "readonly", this.readonly);
+            safeRaiseEvent(this, this.logger, "readonly", this.readOnlyInfo.readonly);
             if (reconnect) {
                 // reconnect if we disconnected from before.
                 this.triggerConnect({ reason: "forceReadonly", mode: "read", fetchOpsFromStorage: false });
@@ -511,10 +504,10 @@ export class DeltaManager
     }
 
     private set_readonlyPermissions(readonly: boolean) {
-        const oldValue = this.readonly;
+        const oldValue = this.readOnlyInfo.readonly;
         this._readonlyPermissions = readonly;
-        if (oldValue !== this.readonly) {
-            safeRaiseEvent(this, this.logger, "readonly", this.readonly);
+        if (oldValue !== this.readOnlyInfo.readonly) {
+            safeRaiseEvent(this, this.logger, "readonly", this.readOnlyInfo.readonly);
         }
     }
 
@@ -713,9 +706,7 @@ export class DeltaManager
         }
 
         const docService = this.serviceProvider();
-        if (docService === undefined) {
-            throw new Error("Container is not attached");
-        }
+        assert(docService !== undefined, 0x2a7 /* "Container is not attached" */);
 
         if (docService.policies?.storageOnly === true) {
             const connection = new NoDeltaStream();
@@ -758,7 +749,7 @@ export class DeltaManager
 
                     // Socket.io error when we connect to wrong socket, or hit some multiplexing bug
                     if (!canRetryOnError(origError)) {
-                        const error = normalizeError(origError);
+                        const error = normalizeError(origError, { props: fatalConnectErrorProp });
                         this.close(error);
                         throw error;
                     }
@@ -817,9 +808,11 @@ export class DeltaManager
         const cleanupAndReject = (error) => {
             this.connectionP = undefined;
             this.removeListener("closed", cleanupAndReject);
+
             // This error came from some logic error in this file. Fail-fast to learn and fix the issue faster
-            this.close(error);
-            deferred.reject(error);
+            const normalizedError = normalizeError(error, { props: fatalConnectErrorProp });
+            this.close(normalizedError);
+            deferred.reject(normalizedError);
         };
         this.on("closed", cleanupAndReject);
 
@@ -857,7 +850,7 @@ export class DeltaManager
         // const serializedContent = JSON.stringify(this.messageBuffer);
         // const maxOpSize = this.context.deltaManager.maxMessageSize;
 
-        if (this.readonly === true) {
+        if (this.readOnlyInfo.readonly === true) {
             assert(this.readOnlyInfo.readonly === true, 0x1f0 /* "Unexpected mismatch in readonly" */);
             const error = new GenericError("deltaManagerReadonlySubmit", undefined /* error */, {
                 readonly: this.readOnlyInfo.readonly,
@@ -885,7 +878,7 @@ export class DeltaManager
         // Note that we also want nacks to be rare and be treated as catastrophic failures.
         // Be careful with reentrancy though - disconnected event should not be be raised in the
         // middle of the current workflow, but rather on clean stack!
-        if (this.connectionMode === "read") {
+        if (this.connectionMode === "read" || this.downgradedConnection) {
             if (!this.pendingReconnect) {
                 this.pendingReconnect = true;
                 Promise.resolve().then(async () => {
@@ -1024,7 +1017,8 @@ export class DeltaManager
                 from, // inclusive
                 to, // exclusive
                 controller.signal,
-                cacheOnly);
+                cacheOnly,
+                this.fetchReason);
 
             // eslint-disable-next-line no-constant-condition
             while (true) {
@@ -1059,8 +1053,12 @@ export class DeltaManager
 
         this.closeAbortController.abort();
 
+        const disconnectReason = error !== undefined
+            ? `Closing DeltaManager (${error.message})`
+            : "Closing DeltaManager";
+
         // This raises "disconnect" event if we have active connection.
-        this.disconnectFromDeltaStream(error !== undefined ? `${error.message}` : "Container closed");
+        this.disconnectFromDeltaStream(disconnectReason);
 
         this._inbound.clear();
         this._outbound.clear();
@@ -1201,7 +1199,7 @@ export class DeltaManager
 
         if (this.closed) {
             // Raise proper events, Log telemetry event and close connection.
-            this.disconnectFromDeltaStream(`Disconnect on close`);
+            this.disconnectFromDeltaStream("DeltaManager already closed");
             return;
         }
 
@@ -1233,6 +1231,9 @@ export class DeltaManager
             clientId: connection.clientId,
             mode: connection.mode,
         };
+        if (connection.relayServiceAgent !== undefined) {
+            this.connectionStateProps.relayServiceAgent = connection.relayServiceAgent;
+        }
         this._hasCheckpointSequenceNumber = false;
 
         // Some storages may provide checkpointSequenceNumber to identify how far client is behind.
@@ -1368,11 +1369,13 @@ export class DeltaManager
         const canRetry = error !== undefined ? canRetryOnError(error) : true;
 
         // If reconnection is not an option, close the DeltaManager
-        if (this.reconnectMode === ReconnectMode.Never || !canRetry) {
+        if (!canRetry) {
+            this.close(normalizeError(error, { props: fatalConnectErrorProp }));
+        } else if (this.reconnectMode === ReconnectMode.Never) {
             // Do not raise container error if we are closing just because we lost connection.
             // Those errors (like IdleDisconnect) would show up in telemetry dashboards and
             // are very misleading, as first initial reaction - some logic is broken.
-            this.close(canRetry ? undefined : error);
+            this.close();
         }
 
         // If closed then we can't reconnect
@@ -1580,8 +1583,6 @@ export class DeltaManager
                 // We have been kicked out from quorum
                 this.logger.sendPerformanceEvent({ eventName: "ReadConnectionTransition" });
                 this.downgradedConnection = true;
-                assert(this.connectionMode === "read",
-                    0x27c /* "effective connectionMode should be 'read' after downgrade" */);
             }
         }