@fluidframework/container-loader 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.2.0.153917

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @fluidframework/container-loader
+
+## 2.0.0-internal.4.1.0
+
+### Minor Changes
+
+-   Container-loader deprecations ([#14891](https://github.com/microsoft/FluidFramework/pull-requests/14891)) [961e96f3c9](https://github.com/microsoft/FluidFramework/commits/961e96f3c92d1dcf9575e56c703fe1779af5442d)
+
+    The following types in the @fluidframework/container-loader package are not used by, or necessary to use our public api, so will be removed from export in the next major release:
+
+    -   IContainerLoadOptions
+    -   IContainerConfig
+    -   IPendingContainerState
+    -   ISerializableBlobContents

package/README.md

@@ -1,5 +1,25 @@
 # @fluidframework/container-loader
 
+<!-- AUTO-GENERATED-CONTENT:START (README_DEPENDENCY_GUIDELINES_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Using Fluid Framework libraries
+
+When taking a dependency on a Fluid Framework library, we recommend using a `^` (caret) version range, such as `^1.3.4`.
+While Fluid Framework libraries may use different ranges with interdependencies between other Fluid Framework libraries,
+library consumers should always prefer `^`.
+
+Note that when depending on a library version of the form 2.0.0-internal.x.y.z, called the Fluid internal version
+scheme, you must use a `>= <` dependency range. Standard `^` and `~` ranges will not work as expected. See the
+[@fluid-tools/version-tools](https://github.com/microsoft/FluidFramework/blob/main/build-tools/packages/version-tools/README.md)
+package for more information including tools to convert between version schemes.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
+
 **Topics covered below:**
 
 -   [@fluidframework/container-loader](#fluidframeworkcontainer-loader)
@@ -10,6 +30,8 @@
         -   [Loading](#loading)
         -   [Connectivity](#connectivity)
         -   [Closure](#closure)
+            -   [`Container.close()`](#containerclose)
+            -   [`Container.dispose()`](#containerdispose)
     -   [Audience](#audience)
     -   [ClientID and client identification](#clientid-and-client-identification)
     -   [Error handling](#error-handling)
@@ -141,13 +163,14 @@ Errors are of [ICriticalContainerError](../../../common/lib/container-definition
      readonly errorType: string;
 ```
 
-There are 3 sources of errors:
+There are 4 sources of errors:
 
 1. [ContainerErrorType](../../../common/lib/container-definitions/src/error.ts) - errors & warnings raised at loader level
-2. [OdspErrorType](../../drivers/odsp-driver/src/odspError.ts) and [R11sErrorType](../../drivers/routerlicious-driver/src/documentDeltaConnection.ts) - errors raised by ODSP and R11S drivers.
-3. Runtime errors, like `"summarizingError"`, `"dataCorruptionError"`. This class of errors is not pre-determined and depends on type of container loaded.
+2. [DriverErrorType](../../common/driver-definitions/src/driverError.ts) - errors that are likely to be raised from the driver level
+3. [OdspErrorType](../../drivers/odsp-driver/src/odspError.ts) and [RouterliciousErrorType](../../drivers/routerlicious-driver/src/documentDeltaConnection.ts) - errors raised by ODSP and R11S drivers.
+4. Runtime errors, like `"summarizingError"`, `"dataCorruptionError"`. This class of errors is not pre-determined and depends on type of container loaded.
 
-`ICriticalContainerError.errorType` is a string, which represents a union of 3 error types described above. Hosting application may package different drivers and open different types of containers, and only hosting application may have enough information to enumerate all possible error codes in such scenarios.
+`ICriticalContainerError.errorType` is a string, which represents a union of 4 error types described above. Hosting application may package different drivers and open different types of containers, and only hosting application may have enough information to enumerate all possible error codes in such scenarios.
 
 Hosts must listen to `"closed"` event. If error object is present there, container was closed due to error and this information needs to be communicated to user in some way. If there is no error object, it was closed due to host application calling Container.close() (without specifying error).
 When container is closed, it is no longer connected to ordering service. It is also in read-only state, communicating to data stores not to allow user to make changes to container.
@@ -216,3 +239,21 @@ This information can be used by a host to build appropriate UX that allows user
 Note that when an active connection is in place, it's just a matter of time before changes will be flushed to storage unless there is some source of continuous local changes being generated that prevents container from ever being fully saved. But if there is no active connection, because the user is offline, for example, then a document may stay in a dirty state for very long time.
 
 `Container.isDirty` can be used to get current state of container.
+
+<!-- AUTO-GENERATED-CONTENT:START (README_TRADEMARK_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Trademark
+
+This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
+
+Use of these trademarks or logos must follow Microsoft's [Trademark & Brand
+Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->

package/closeAndGetPendingLocalState.md

@@ -0,0 +1,51 @@
+# closeAndGetPendingLocalState
+
+Pending local state is a mechanism that Fluid provides for mitigating data loss, particularly in offline scenarios.
+When changes are made in a Container, it puts the Container into a "dirty" state until the changes have been confirmed by the server.
+If the Container is closed in this state, the changes may be lost if they did not reach the server (for example, if the user is offline).
+
+`Container.closeAndGetPendingLocalState()` solves this problem by returning pending changes when closing a Container so they may be resupplied to a new container instance and resubmitted.
+
+Additionally, the blob returned by closeAndGetPendingLocalState() contains enough data to load a container offline.
+This method will still return a such a blob even if the container is not dirty when called.
+
+## Using `Container.closeAndGetPendingLocalState()`
+
+When closeAndGetPendingLocalState() is called it will return a serialized blob containing the necessary data to load and resubmit the changes in a new container.
+
+The stashed changes blob can be used by passing it to `Loader.resolve()` when loading a new container.
+The container will then automatically submit the stashed changes when the Container reaches the "connected" state, if the changes were not originally successful.
+
+**It's important that these blobs are not reused, since it can result in the same changes being submitted multiple times, possibly resulting in document corruption.**
+Instead, closeAndGetPendingLocalState() should be called again on the new container, which will return a new blob containing all its pending changes, including any still-pending stashed changes it was loaded with.
+
+```ts
+const myContainer = await myLoader.resolve(myRequest);
+const pendingChanges = myContainer.closeAndGetPendingLocalState();
+const myNewContainer = await myLoader.resolve(myRequest, pendingChanges);
+```
+
+Note that closeAndGetPendingLocalState() cannot be called on a Container that is already closed or disposed.
+The purpose of closeAndGetPendingLocalState() is to avoid data loss when a dirty container must be closed, not recovering from internal Container errors.
+
+## How it works
+
+The blob contains ops and attachment blob uploads that were still pending whe the container was closed.
+It also contains the container's last client ID, a snapshot older than the reference sequence number of the oldest pending op, and all sequenced ops the container has processed since the snapshot.
+
+When the blob is supplied to `Loader.resolve()`, it will return a new container.
+This container will load from the snapshot in the blob, and "replay" the saved ops in the blob by processing them one by one.
+applyStashedOp() will be called for each stashed op after the op whose sequence number matches the stashed op's reference sequence number is processed (i.e., when the document is in the same state as when the op was originally made).
+
+When the container connects to the delta stream and starts processing new ops, they are matched to stashed ops by client ID, so the container will not submit stashed ops that were originally successfully submitted.
+When it processes its own join op (i.e., reaches "connected" state), the container will have seen any previously successful stashed ops, and it is safe to resubmit any remaining stashed ops.
+
+### applyStashedOp()
+
+When an op is created, it is given a "reference sequence number," which is the sequence number of the last op processed by the container.
+For various reasons, the server will only sequence ops if they are within the "collab window," limited by the "minimum sequence number" of the document.
+For this reason, if an op is not successfully submitted while its reference sequence number is within this window, runtime will call SharedObject.reSubmit() to ask the DDS to merge it with later remote changes and resubmit the change.
+Once the op is sequenced by the server, runtime will pass it to SharedObject.process().
+
+The job of applyStashedOp() is to return a new DDS in a new container to the same state, so that the DDS is able to handle calls to reSubmit() or process() with the op, even though the DDS itself did not submit it.
+Once stashed ops are passed to applyStashedOp(), they are handled by runtime the same as any other pending ops.

package/dist/connectionManager.d.ts

@@ -14,6 +14,7 @@ import { ReconnectMode, IConnectionManager, IConnectionManagerFactoryArgs } from
  */
 export declare class ConnectionManager implements IConnectionManager {
     private readonly serviceProvider;
+    readonly containerDirty: () => boolean;
     private client;
     private readonly logger;
     private readonly props;
@@ -83,7 +84,7 @@ export declare class ConnectionManager implements IConnectionManager {
     private get readonly();
     get readOnlyInfo(): ReadOnlyInfo;
     private static detailsFromConnection;
-    constructor(serviceProvider: () => IDocumentService | undefined, client: IClient, reconnectAllowed: boolean, logger: ITelemetryLogger, props: IConnectionManagerFactoryArgs);
+    constructor(serviceProvider: () => IDocumentService | undefined, containerDirty: () => boolean, client: IClient, reconnectAllowed: boolean, logger: ITelemetryLogger, props: IConnectionManagerFactoryArgs);
     dispose(error?: ICriticalContainerError, switchToReadonly?: boolean): void;
     /**
      * Enables or disables automatic reconnecting.

package/dist/connectionManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connectionManager.d.ts","sourceRoot":"","sources":["../src/connectionManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"connectionManager.d.ts","sourceRoot":"","sources":["../src/connectionManager.ts"],"names":[],"mappings":"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"}

package/dist/connectionManager.js

@@ -11,6 +11,7 @@ exports.ConnectionManager = void 0;
 const abort_controller_1 = __importDefault(require("abort-controller"));
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
+const driver_definitions_1 = require("@fluidframework/driver-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
@@ -83,14 +84,28 @@ class NoDeltaStream extends common_utils_1.TypedEventEmitter {
         this._disposed = true;
     }
 }
+const waitForOnline = async () => {
+    var _a;
+    // Only wait if we have a strong signal that we're offline - otherwise assume we're online.
+    if (((_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.onLine) === false && globalThis.addEventListener !== undefined) {
+        return new Promise((resolve) => {
+            const resolveAndRemoveListener = () => {
+                resolve();
+                globalThis.removeEventListener("online", resolveAndRemoveListener);
+            };
+            globalThis.addEventListener("online", resolveAndRemoveListener);
+        });
+    }
+};
 /**
  * Implementation of IConnectionManager, used by Container class
  * Implements constant connectivity to relay service, by reconnecting in case of lost connection or error.
  * Exposes various controls to influence this process, including manual reconnects, forced read-only mode, etc.
  */
 class ConnectionManager {
-    constructor(serviceProvider, client, reconnectAllowed, logger, props) {
+    constructor(serviceProvider, containerDirty, client, reconnectAllowed, logger, props) {
         this.serviceProvider = serviceProvider;
+        this.containerDirty = containerDirty;
         this.client = client;
         this.logger = logger;
         this.props = props;
@@ -207,7 +222,19 @@ class ConnectionManager {
     }
     shouldJoinWrite() {
         // We don't have to wait for ack for topmost NoOps. So subtract those.
-        return (this.clientSequenceNumberObserved < this.clientSequenceNumber - this.localOpsToIgnore);
+        const outstandingOps = this.clientSequenceNumberObserved < this.clientSequenceNumber - this.localOpsToIgnore;
+        // Previous behavior was to force write mode here only when there are outstanding ops (besides
+        // no-ops). The dirty signal from runtime should provide the same behavior, but also support
+        // stashed ops that weren't submitted to container layer yet. For safety, we want to retain the
+        // same behavior whenever dirty is false.
+        const isDirty = this.containerDirty();
+        if (outstandingOps !== isDirty) {
+            this.logger.sendTelemetryEvent({
+                eventName: "DesiredConnectionModeMismatch",
+                details: JSON.stringify({ outstandingOps, isDirty }),
+            });
+        }
+        return outstandingOps || isDirty;
     }
     /**
      * Tells if container is in read-only mode.
@@ -219,10 +246,7 @@ class ConnectionManager {
      * and do not know if user has write access to a file.
      */
     get readonly() {
-        if (this._forceReadonly) {
-            return true;
-        }
-        return this._readonlyPermissions;
+        return this.readOnlyInfo.readonly;
     }
     get readOnlyInfo() {
         const storageOnly = this.connection !== undefined && this.connection instanceof NoDeltaStream;
@@ -240,7 +264,6 @@ class ConnectionManager {
         return {
             claims: connection.claims,
             clientId: connection.clientId,
-            existing: connection.existing,
             checkpointSequenceNumber: connection.checkpointSequenceNumber,
             get initialClients() {
                 return connection.initialClients;
@@ -259,9 +282,7 @@ class ConnectionManager {
         // Ensure that things like triggerConnect() will short circuit
         this._reconnectMode = contracts_1.ReconnectMode.Never;
         this._outbound.clear();
-        const disconnectReason = error !== undefined
-            ? `Closing DeltaManager (${error.message})`
-            : "Closing DeltaManager";
+        const disconnectReason = "Closing DeltaManager";
         // This raises "disconnect" event if we have active connection.
         this.disconnectFromDeltaStream(disconnectReason);
         if (switchToReadonly) {
@@ -346,7 +367,7 @@ class ConnectionManager {
         });
     }
     async connectCore(connectionMode) {
-        var _a, _b;
+        var _a, _b, _c;
         (0, common_utils_1.assert)(!this._disposed, 0x26a /* "not closed" */);
         if (this.connection !== undefined) {
             return; // Connection attempt already completed successfully
@@ -415,7 +436,7 @@ class ConnectionManager {
             catch (origError) {
                 if (typeof origError === "object" &&
                     origError !== null &&
-                    (origError === null || origError === void 0 ? void 0 : origError.errorType) === driver_utils_1.DeltaStreamConnectionForbiddenError.errorType) {
+                    (origError === null || origError === void 0 ? void 0 : origError.errorType) === driver_definitions_1.DriverErrorType.deltaStreamConnectionForbidden) {
                     connection = new NoDeltaStream();
                     requestedMode = "read";
                     break;
@@ -435,11 +456,25 @@ class ConnectionManager {
                 }, origError);
                 lastError = origError;
                 const retryDelayFromError = (0, driver_utils_1.getRetryDelayFromError)(origError);
-                delayMs = retryDelayFromError !== null && retryDelayFromError !== void 0 ? retryDelayFromError : Math.min(delayMs * 2, MaxReconnectDelayInMs);
                 if (retryDelayFromError !== undefined) {
+                    // If the error told us to wait, then we wait.
                     this.props.reconnectionDelayHandler(retryDelayFromError, origError);
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, retryDelayFromError);
+                    });
+                }
+                else if (((_c = globalThis.navigator) === null || _c === void 0 ? void 0 : _c.onLine) !== false) {
+                    // If the error didn't tell us to wait, let's still wait a little bit before retrying.
+                    // We skip this delay if we're confident we're offline, because we probably just need to wait to come back online.
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, delayMs);
+                        delayMs = Math.min(delayMs * 2, MaxReconnectDelayInMs);
+                    });
                 }
-                await (0, driver_utils_1.waitForConnectedState)(delayMs);
+                // If we believe we're offline, we assume there's no point in trying until we at least think we're online.
+                // NOTE: This isn't strictly true for drivers that don't require network (e.g. local driver).  Really this logic
+                // should probably live in the driver.
+                await waitForOnline();
             }
         }
         // If we retried more than once, log an event about how long it took (this will not log to error table)
@@ -469,7 +504,7 @@ class ConnectionManager {
      * @param args - The connection arguments
      */
     triggerConnect(connectionMode) {
-        // reconnect() has async await of waitForConnectedState(), and that causes potential race conditions
+        // reconnect() includes async awaits, and that causes potential race conditions
         // where we might already have a connection. If it were to happen, it's possible that we will connect
         // with different mode to `connectionMode`. Glancing through the caller chains, it looks like code should be
         // fine (if needed, reconnect flow will get triggered again). Places where new mode matters should encode it
@@ -508,8 +543,8 @@ class ConnectionManager {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this._outbound.pause();
         this._outbound.clear();
-        this.props.disconnectHandler(reason);
         connection.dispose();
+        this.props.disconnectHandler(reason);
         this._connectionVerboseProps = {};
         return true;
     }
@@ -671,11 +706,18 @@ class ConnectionManager {
         if (this._disposed || this.reconnectMode !== contracts_1.ReconnectMode.Enabled) {
             return;
         }
+        // If the error tells us to wait before retrying, then do so.
         const delayMs = (0, driver_utils_1.getRetryDelayFromError)(error);
         if (error !== undefined && delayMs !== undefined) {
             this.props.reconnectionDelayHandler(delayMs, error);
-            await (0, driver_utils_1.waitForConnectedState)(delayMs);
+            await new Promise((resolve) => {
+                setTimeout(resolve, delayMs);
+            });
         }
+        // If we believe we're offline, we assume there's no point in trying again until we at least think we're online.
+        // NOTE: This isn't strictly true for drivers that don't require network (e.g. local driver).  Really this logic
+        // should probably live in the driver.
+        await waitForOnline();
         this.triggerConnect(requestedMode);
     }
     prepareMessageToSend(message) {