@fluidframework/container-loader 1.2.7 → 2.0.0-dev.1.3.0.96595

package/src/loader.ts

@@ -48,6 +48,7 @@ import {
 import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
+import { ProtocolHandlerBuilder } from "./protocol";
 
 function canUseCache(request: IRequest): boolean {
     if (request.headers === undefined) {
@@ -132,7 +133,7 @@ export interface ILoaderOptions extends ILoaderOptions1 {
 
 /**
  * @deprecated IFluidModuleWithDetails interface is moved to
- * {@link @fluidframework/container-definition#IFluidModuleWithDetails}
+ * {@link @fluidframework/container-definitions#IFluidModuleWithDetails}
  * to have all the code loading modules in one package. #8193
  * Encapsulates a module entry point with corresponding code details.
  */
@@ -211,7 +212,13 @@ export interface ILoaderProps {
     /**
      * The configuration provider which may be used to control features.
      */
-     readonly configProvider?: IConfigProviderBase;
+    readonly configProvider?: IConfigProviderBase;
+
+    /**
+    * Optional property for allowing the container to use a custom
+    * protocol implementation for handling the quorum and/or the audience.
+    */
+    readonly protocolHandlerBuilder?: ProtocolHandlerBuilder;
 }
 
 /**
@@ -278,6 +285,7 @@ export class Loader implements IHostLoader {
     private readonly containers = new Map<string, Promise<Container>>();
     public readonly services: ILoaderServices;
     private readonly mc: MonitoringContext;
+    private readonly protocolHandlerBuilder: ProtocolHandlerBuilder | undefined;
 
     constructor(loaderProps: ILoaderProps) {
         const scope: FluidObject<ILoader> = { ...loaderProps.scope };
@@ -306,6 +314,7 @@ export class Loader implements IHostLoader {
         };
         this.mc = loggerToMonitoringContext(
             ChildLogger.create(this.services.subLogger, "Loader"));
+        this.protocolHandlerBuilder = loaderProps.protocolHandlerBuilder;
     }
 
     public get IFluidRouter(): IFluidRouter { return this; }
@@ -314,6 +323,7 @@ export class Loader implements IHostLoader {
         const container = await Container.createDetached(
             this,
             codeDetails,
+            this.protocolHandlerBuilder,
         );
 
         if (this.cachingEnabled) {
@@ -330,7 +340,7 @@ export class Loader implements IHostLoader {
     }
 
     public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<IContainer> {
-        return Container.rehydrateDetachedFromSnapshot(this, snapshot);
+        return Container.rehydrateDetachedFromSnapshot(this, snapshot, this.protocolHandlerBuilder);
     }
 
     public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
@@ -482,6 +492,7 @@ export class Loader implements IHostLoader {
                 loadMode: request.headers?.[LoaderHeader.loadMode],
             },
             pendingLocalState,
+            this.protocolHandlerBuilder,
         );
     }
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "1.2.7";
+export const pkgVersion = "2.0.0-dev.1.3.0.96595";

package/src/protocol.ts

@@ -0,0 +1,120 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IAudienceOwner } from "@fluidframework/container-definitions";
+import {
+    ILocalSequencedClient,
+    IProtocolHandler as IBaseProtocolHandler,
+    IQuorumSnapshot,
+    ProtocolOpHandler,
+} from "@fluidframework/protocol-base";
+import {
+    IDocumentAttributes,
+    IProcessMessageResult,
+    ISequencedDocumentMessage,
+    ISignalClient,
+    ISignalMessage,
+    MessageType,
+} from "@fluidframework/protocol-definitions";
+import { canBeCoalescedByService } from "@fluidframework/driver-utils";
+
+// ADO: #1986: Start using enum from protocol-base.
+export enum SignalType {
+    ClientJoin = "join", // same value as MessageType.ClientJoin,
+    ClientLeave = "leave", // same value as MessageType.ClientLeave,
+    Clear = "clear", // used only by client for synthetic signals
+}
+
+/**
+ * Function to be used for creating a protocol handler.
+ */
+export type ProtocolHandlerBuilder = (
+    attributes: IDocumentAttributes,
+    snapshot: IQuorumSnapshot,
+    sendProposal: (key: string, value: any) => number,
+) => IProtocolHandler;
+
+export interface IProtocolHandler extends IBaseProtocolHandler {
+    readonly audience: IAudienceOwner;
+    processSignal(message: ISignalMessage);
+}
+
+export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandler {
+    constructor(
+        attributes: IDocumentAttributes,
+        quorumSnapshot: IQuorumSnapshot,
+        sendProposal: (key: string, value: any) => number,
+        readonly audience: IAudienceOwner,
+    ) {
+        super(
+            attributes.minimumSequenceNumber,
+            attributes.sequenceNumber,
+            attributes.term,
+            quorumSnapshot.members,
+            quorumSnapshot.proposals,
+            quorumSnapshot.values,
+            sendProposal,
+        );
+
+        // Join / leave signals are ignored for "write" clients in favor of join / leave ops
+        this.quorum.on("addMember", (clientId, details) => audience.addMember(clientId, details.client));
+        this.quorum.on("removeMember", (clientId) => audience.removeMember(clientId));
+        for (const [clientId, details] of this.quorum.getMembers()) {
+            this.audience.addMember(clientId, details.client);
+        }
+    }
+
+    public processMessage(message: ISequencedDocumentMessage, local: boolean): IProcessMessageResult {
+        const client: ILocalSequencedClient | undefined = this.quorum.getMember(message.clientId);
+
+        // Check and report if we're getting messages from a clientId that we previously
+        // flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
+        if (message.clientId != null) {
+            if (client === undefined && message.type !== MessageType.ClientJoin) {
+                // pre-0.58 error message: messageClientIdMissingFromQuorum
+                throw new Error("Remote message's clientId is missing from the quorum");
+            }
+
+            if (client?.shouldHaveLeft === true && !canBeCoalescedByService(message)) {
+                // pre-0.58 error message: messageClientIdShouldHaveLeft
+                throw new Error("Remote message's clientId already should have left");
+            }
+        }
+
+        return super.processMessage(message, local);
+    }
+
+    public processSignal(message: ISignalMessage) {
+        const innerContent = message.content as { content: any; type: string; };
+        switch (innerContent.type) {
+            case SignalType.Clear: {
+                const members = this.audience.getMembers();
+                for (const [clientId, client] of members) {
+                    if (client.mode === "read") {
+                        this.audience.removeMember(clientId);
+                    }
+                }
+                break;
+            }
+            case SignalType.ClientJoin: {
+                const newClient = innerContent.content as ISignalClient;
+                // Ignore write clients - quorum will control such clients.
+                if (newClient.client.mode === "read") {
+                    this.audience.addMember(newClient.clientId, newClient.client);
+                }
+                break;
+            }
+            case SignalType.ClientLeave: {
+                const leftClientId = innerContent.content as string;
+                // Ignore write clients - quorum will control such clients.
+                if (this.audience.getMember(leftClientId)?.mode === "read") {
+                    this.audience.removeMember(leftClientId);
+                }
+                break;
+            }
+            default: break;
+        }
+    }
+}

package/src/retriableDocumentStorageService.ts

@@ -6,6 +6,7 @@
 import { assert } from "@fluidframework/common-utils";
 import { GenericError } from "@fluidframework/container-utils";
 import {
+    FetchSource,
     IDocumentStorageService,
     IDocumentStorageServicePolicies,
     ISummaryContext,
@@ -54,9 +55,14 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
         );
     }
 
-    public async getVersions(versionId: string | null, count: number, scenarioName?: string): Promise<IVersion[]> {
+    public async getVersions(
+        versionId: string | null,
+        count: number,
+        scenarioName?: string,
+        fetchSource?: FetchSource,
+    ): Promise<IVersion[]> {
         return this.runWithRetry(
-            async () => this.internalStorageService.getVersions(versionId, count, scenarioName),
+            async () => this.internalStorageService.getVersions(versionId, count, scenarioName, fetchSource),
             "storage_getVersions",
         );
     }