@fluidframework/container-loader 1.2.2 → 2.0.0-internal.1.0.0.81589

package/src/deltaQueue.ts

@@ -4,7 +4,7 @@
  */
 
 import { IDeltaQueue, IDeltaQueueEvents } from "@fluidframework/container-definitions";
-import { assert, performance, Deferred, TypedEventEmitter } from "@fluidframework/common-utils";
+import { assert, performance, TypedEventEmitter } from "@fluidframework/common-utils";
 import Deque from "double-ended-queue";
 
 export interface IDeltaQueueWriter<T> {
@@ -30,7 +30,7 @@ export class DeltaQueue<T>
      * When processing is ongoing, holds a deferred that will resolve once processing stops.
      * Undefined when not processing.
      */
-    private processingDeferred: Deferred<void> | undefined;
+    private processingPromise: Promise<{ count: number; duration: number; }> | undefined;
 
     public get disposed(): boolean {
         return this.isDisposed;
@@ -48,13 +48,11 @@ export class DeltaQueue<T>
     }
 
     public get idle(): boolean {
-        return this.processingDeferred === undefined && this.q.length === 0;
+        return this.processingPromise === undefined && this.q.length === 0;
     }
 
-    public async waitTillProcessingDone(): Promise<void> {
-        if (this.processingDeferred !== undefined) {
-            return this.processingDeferred.promise;
-        }
+    public async waitTillProcessingDone() {
+        return this.processingPromise ?? { count: 0, duration: 0 };
     }
 
     /**
@@ -98,7 +96,7 @@ export class DeltaQueue<T>
         this.pauseCount++;
         // If called from within the processing loop, we are in the middle of processing an op. Return a promise
         // that will resolve when processing has actually stopped.
-        return this.waitTillProcessingDone();
+        await this.waitTillProcessingDone();
     }
 
     public resume(): void {
@@ -113,20 +111,31 @@ export class DeltaQueue<T>
      * not already started.
      */
     private ensureProcessing() {
-        if (!this.paused && this.processingDeferred === undefined) {
-            this.processingDeferred = new Deferred<void>();
+        if (this.anythingToProcess() && this.processingPromise === undefined) {
             // Use a resolved promise to start the processing on a separate stack.
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            Promise.resolve().then(() => {
-                this.processDeltas();
-                if (this.processingDeferred !== undefined) {
-                    this.processingDeferred.resolve();
-                    this.processingDeferred = undefined;
-                }
+            this.processingPromise = Promise.resolve().then(() => {
+                assert(this.processingPromise !== undefined, "reentrancy?");
+                const result = this.processDeltas();
+                assert(this.processingPromise !== undefined, "reentrancy?");
+                // WARNING: Do not move next line to .finally() clause!
+                // It runs async and creates a race condition where incoming ensureProcessing() call observes
+                // from previous run while previous run is over (but finally clause was not scheduled yet)
+                this.processingPromise = undefined;
+                return result;
+            }).catch((error) => {
+                this.error = error;
+                this.processingPromise = undefined;
+                this.emit("error", error);
+                return { count: 0, duration: 0 };
             });
+            assert(this.processingPromise !== undefined, "processDeltas() should run async");
         }
     }
 
+    private anythingToProcess() {
+        return this.q.length !== 0 && !this.paused && this.error === undefined;
+    }
+
     /**
      * Executes the delta processing loop until a stop condition is reached.
      */
@@ -136,24 +145,21 @@ export class DeltaQueue<T>
 
         // For grouping to work we must process all local messages immediately and in the single turn.
         // So loop over them until no messages to process, we have become paused, or hit an error.
-        while (!(this.q.length === 0 || this.paused || this.error !== undefined)) {
+        while (this.anythingToProcess()) {
             // Get the next message in the queue
             const next = this.q.shift();
             count++;
             // Process the message.
-            try {
-                // We know next is defined since we did a length check just prior to shifting.
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.worker(next!);
-                this.emit("op", next);
-            } catch (error) {
-                this.error = error;
-                this.emit("error", error);
-            }
+            // We know next is defined since we did a length check just prior to shifting.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.worker(next!);
+            this.emit("op", next);
         }
 
+        const duration = performance.now() - start;
         if (this.q.length === 0) {
-            this.emit("idle", count, performance.now() - start);
+            this.emit("idle", count, duration);
         }
+        return { count, duration };
     }
 }

package/src/index.ts

@@ -21,3 +21,7 @@ export {
     Loader,
     RelativeLoader,
 } from "./loader";
+export {
+    IProtocolHandler,
+    ProtocolHandlerBuilder,
+} from "./protocol";

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) {
@@ -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.2";
+export const pkgVersion = "2.0.0-internal.1.0.0.81589";

package/src/protocol.ts

@@ -0,0 +1,96 @@
+/*!
+ * 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";
+
+/**
+ * Function to be used for creating a protocol handler.
+ */
+export type ProtocolHandlerBuilder = (
+    attributes: IDocumentAttributes,
+    snapshot: IQuorumSnapshot,
+    sendProposal: (key: string, value: any) => number,
+    initialClients: ISignalClient[],
+) => 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,
+        initialClients: ISignalClient[],
+        readonly audience: IAudienceOwner,
+    ) {
+        super(
+            attributes.minimumSequenceNumber,
+            attributes.sequenceNumber,
+            attributes.term,
+            quorumSnapshot.members,
+            quorumSnapshot.proposals,
+            quorumSnapshot.values,
+            sendProposal,
+        );
+
+        for (const initialClient of initialClients) {
+            this.audience.addMember(initialClient.clientId, initialClient.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 && message.type !== MessageType.NoOp) {
+                // 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 MessageType.ClientJoin: {
+                const newClient = innerContent.content as ISignalClient;
+                this.audience.addMember(newClient.clientId, newClient.client);
+                break;
+            }
+            case MessageType.ClientLeave: {
+                const leftClientId = innerContent.content as string;
+                this.audience.removeMember(leftClientId);
+                break;
+            }
+            default: break;
+        }
+    }
+}