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

package/src/connectionManager.ts

@@ -59,7 +59,6 @@ import {
     IConnectionManagerFactoryArgs,
 } from "./contracts";
 import { DeltaQueue } from "./deltaQueue";
-import { SignalType } from "./protocol";
 
 const MaxReconnectDelayInMs = 8000;
 const InitialReconnectDelayInMs = 1000;
@@ -714,43 +713,17 @@ export class ConnectionManager implements IConnectionManager {
             initialMessages,
             this.connectFirstConnection ? "InitialOps" : "ReconnectOps");
 
-        const details = ConnectionManager.detailsFromConnection(connection);
-        details.checkpointSequenceNumber = checkpointSequenceNumber;
-        this.props.connectHandler(details);
-
-        this.connectFirstConnection = false;
-
-        // Synthesize clear & join signals out of initialClients state.
-        // This allows us to have single way to process signals, and makes it simpler to initialize
-        // protocol in Container.
-        const clearSignal: ISignalMessage = {
-            clientId: null, // system message
-            content: JSON.stringify({
-                type: SignalType.Clear,
-            }),
-        };
-        this.props.signalHandler(clearSignal);
-
-        for (const priorClient of connection.initialClients ?? []) {
-            const joinSignal: ISignalMessage = {
-                clientId: null, // system signal
-                content: JSON.stringify({
-                    type: SignalType.ClientJoin,
-                    content: priorClient, // ISignalClient
-                }),
-            };
-            this.props.signalHandler(joinSignal);
-        }
-
-        // Unfortunately, there is no defined order between initialSignals (including join & leave signals)
-        // and connection.initialClients. In practice, connection.initialSignals quite often contains join signal
-        // for "self" and connection.initialClients does not contain "self", so we have to process them after
-        // "clear" signal above.
         if (connection.initialSignals !== undefined) {
             for (const signal of connection.initialSignals) {
                 this.props.signalHandler(signal);
             }
         }
+
+        const details = ConnectionManager.detailsFromConnection(connection);
+        details.checkpointSequenceNumber = checkpointSequenceNumber;
+        this.props.connectHandler(details);
+
+        this.connectFirstConnection = false;
     }
 
     /**

package/src/container.ts

@@ -64,6 +64,7 @@ import {
     ISequencedClient,
     ISequencedDocumentMessage,
     ISequencedProposal,
+    ISignalClient,
     ISignalMessage,
     ISnapshotTree,
     ISummaryContent,
@@ -411,6 +412,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private readonly clientDetailsOverride: IClientDetails | undefined;
     private readonly _deltaManager: DeltaManager<ConnectionManager>;
     private service: IDocumentService | undefined;
+    private _initialClients: ISignalClient[] | undefined;
 
     private _context: ContainerContext | undefined;
     private get context() {
@@ -1381,8 +1383,11 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             attributes,
             quorumSnapshot,
             (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })),
+            this._initialClients ?? [],
         );
 
+        this._initialClients = undefined;
+
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
 
         protocol.quorum.on("error", (error) => {
@@ -1507,6 +1512,20 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         deltaManager.inboundSignal.pause();
 
         deltaManager.on("connect", (details: IConnectionDetails, _opsBehind?: number) => {
+            if (this._protocolHandler === undefined) {
+                // Store the initial clients so that they can be submitted to the
+                // protocol handler when it is created.
+                this._initialClients = details.initialClients;
+            } else {
+                // When reconnecting, the protocol handler is already created,
+                // so we can update the audience right now.
+                this._protocolHandler.audience.clear();
+
+                for (const priorClient of details.initialClients ?? []) {
+                    this._protocolHandler.audience.addMember(priorClient.clientId, priorClient.client);
+                }
+            }
+
             this.connectionStateHandler.receivedConnectEvent(
                 this.connectionMode,
                 details,
@@ -1721,7 +1740,9 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     (type) => {
                         assert(this.activeConnection(),
                             0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                        this.submitMessage(type);
+                        // back-compat: There is a bug in 1.2 runtime where clients cannot handle
+                        // ops whose contents are undefined
+                        this.submitMessage(type, null as any);
                     },
                     this.serviceConfiguration.noopTimeFrequency,
                     this.serviceConfiguration.noopCountFrequency,

package/src/deltaManager.ts

@@ -218,7 +218,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
             return -1;
         }
 
-        if (contents !== undefined) {
+        if (contents !== undefined && contents !== null) {
             this.opsSize += contents.length;
         }
 

package/src/packageVersion.ts

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

package/src/protocol.ts

@@ -20,13 +20,6 @@ import {
 } 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.
  */
@@ -34,6 +27,7 @@ export type ProtocolHandlerBuilder = (
     attributes: IDocumentAttributes,
     snapshot: IQuorumSnapshot,
     sendProposal: (key: string, value: any) => number,
+    initialClients: ISignalClient[],
 ) => IProtocolHandler;
 
 export interface IProtocolHandler extends IBaseProtocolHandler {
@@ -46,6 +40,7 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
         attributes: IDocumentAttributes,
         quorumSnapshot: IQuorumSnapshot,
         sendProposal: (key: string, value: any) => number,
+        initialClients: ISignalClient[],
         readonly audience: IAudienceOwner,
     ) {
         super(
@@ -58,11 +53,8 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
             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);
+        for (const initialClient of initialClients) {
+            this.audience.addMember(initialClient.clientId, initialClient.client);
         }
     }
 
@@ -89,29 +81,14 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
     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: {
+            case MessageType.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);
-                }
+                this.audience.addMember(newClient.clientId, newClient.client);
                 break;
             }
-            case SignalType.ClientLeave: {
+            case MessageType.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);
-                }
+                this.audience.removeMember(leftClientId);
                 break;
             }
             default: break;