@fluidframework/container-loader 2.0.0-rc.4.0.6 → 2.0.0-rc.5.0.1

package/dist/protocol/quorum.d.ts

@@ -0,0 +1,185 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { IQuorumClients, ISequencedClient } from "@fluidframework/driver-definitions";
+import { ISequencedDocumentMessage, ICommittedProposal, IQuorum, IQuorumProposals, ISequencedProposal } from "@fluidframework/driver-definitions/internal";
+/**
+ * Snapshot format for a QuorumClients
+ * @alpha
+ */
+export type QuorumClientsSnapshot = [string, ISequencedClient][];
+/**
+ * Snapshot format for a QuorumProposals
+ * @alpha
+ */
+export type QuorumProposalsSnapshot = {
+    proposals: [number, ISequencedProposal, string[]][];
+    values: [string, ICommittedProposal][];
+};
+/**
+ * Snapshot format for a Quorum
+ * @alpha
+ */
+export interface IQuorumSnapshot {
+    members: QuorumClientsSnapshot;
+    proposals: QuorumProposalsSnapshot["proposals"];
+    values: QuorumProposalsSnapshot["values"];
+}
+/**
+ * The QuorumClients is used to track members joining and leaving the collaboration session.
+ * @internal
+ */
+export declare class QuorumClients extends TypedEventEmitter<IQuorumClients["on"]> implements IQuorumClients {
+    private readonly members;
+    private isDisposed;
+    get disposed(): boolean;
+    /**
+     * Cached snapshot state, to avoid unnecessary deep clones on repeated snapshot calls.
+     * Cleared immediately (set to undefined) when the cache becomes invalid.
+     */
+    private snapshotCache;
+    constructor(snapshot: QuorumClientsSnapshot);
+    /**
+     * Snapshots the current state of the QuorumClients
+     * @returns a snapshot of the clients in the quorum
+     */
+    snapshot(): QuorumClientsSnapshot;
+    /**
+     * Adds a new client to the quorum
+     */
+    addMember(clientId: string, details: ISequencedClient): void;
+    /**
+     * Removes a client from the quorum
+     */
+    removeMember(clientId: string): void;
+    /**
+     * Retrieves all the members in the quorum
+     */
+    getMembers(): Map<string, ISequencedClient>;
+    /**
+     * Retrieves a specific member of the quorum
+     */
+    getMember(clientId: string): ISequencedClient | undefined;
+    dispose(): void;
+}
+/**
+ * The QuorumProposals holds a key/value store.  Proposed values become finalized in the store once all connected
+ * clients have seen the proposal.
+ * @internal
+ */
+export declare class QuorumProposals extends TypedEventEmitter<IQuorumProposals["on"]> implements IQuorumProposals {
+    private readonly sendProposal;
+    private readonly proposals;
+    private readonly values;
+    private isDisposed;
+    get disposed(): boolean;
+    private readonly stateEvents;
+    /**
+     * Cached snapshot state, to avoid unnecessary deep clones on repeated snapshot calls.
+     * Cleared immediately (set to undefined) when the cache becomes invalid.
+     */
+    private proposalsSnapshotCache;
+    private valuesSnapshotCache;
+    constructor(snapshot: QuorumProposalsSnapshot, sendProposal: (key: string, value: any) => number);
+    /**
+     * Snapshots the current state of the QuorumProposals
+     * @returns arrays of proposals and values
+     */
+    snapshot(): QuorumProposalsSnapshot;
+    /**
+     * Returns whether the quorum has achieved a consensus for the given key.
+     */
+    has(key: string): boolean;
+    /**
+     * Returns the consensus value for the given key
+     */
+    get(key: string): any;
+    /**
+     * Returns additional data about the approved consensus value
+     * @deprecated Removed in recent protocol-definitions.  Use get() instead.
+     */
+    getApprovalData(key: string): ICommittedProposal | undefined;
+    /**
+     * Proposes a new value. Returns a promise that will either:
+     * - Resolve when the proposal is accepted
+     * - Reject if the proposal fails to send or if the QuorumProposals is disposed
+     */
+    propose(key: string, value: any): Promise<void>;
+    /**
+     * Begins tracking a new proposal
+     */
+    addProposal(key: string, value: any, sequenceNumber: number, local: boolean, clientSequenceNumber: number): void;
+    /**
+     * Updates the minimum sequence number. If the MSN advances past the sequence number for any proposal then it
+     * becomes an approved value.
+     */
+    updateMinimumSequenceNumber(message: ISequencedDocumentMessage): void;
+    setConnectionState(connected: boolean): void;
+    dispose(): void;
+}
+/**
+ * A quorum represents all clients currently within the collaboration window. As well as the values
+ * they have agreed upon and any pending proposals.
+ * @internal
+ */
+export declare class Quorum extends TypedEventEmitter<IQuorum["on"]> implements IQuorum {
+    private readonly quorumClients;
+    private readonly quorumProposals;
+    private readonly isDisposed;
+    get disposed(): boolean;
+    constructor(members: QuorumClientsSnapshot, proposals: QuorumProposalsSnapshot["proposals"], values: QuorumProposalsSnapshot["values"], sendProposal: (key: string, value: any) => number);
+    close(): void;
+    /**
+     * Snapshots the entire quorum
+     * @returns a quorum snapshot
+     */
+    snapshot(): IQuorumSnapshot;
+    /**
+     * Returns whether the quorum has achieved a consensus for the given key.
+     */
+    has(key: string): boolean;
+    /**
+     * Returns the consensus value for the given key
+     */
+    get(key: string): any;
+    /**
+     * Returns additional data about the approved consensus value
+     * @deprecated Removed in recent protocol-definitions.  Use get() instead.
+     */
+    getApprovalData(key: string): ICommittedProposal | undefined;
+    /**
+     * Adds a new client to the quorum
+     */
+    addMember(clientId: string, details: ISequencedClient): void;
+    /**
+     * Removes a client from the quorum
+     */
+    removeMember(clientId: string): void;
+    /**
+     * Retrieves all the members in the quorum
+     */
+    getMembers(): Map<string, ISequencedClient>;
+    /**
+     * Retrieves a specific member of the quorum
+     */
+    getMember(clientId: string): ISequencedClient | undefined;
+    /**
+     * Proposes a new value. Returns a promise that will resolve when the proposal is either accepted, or reject if
+     * the proposal fails to send.
+     */
+    propose(key: string, value: any): Promise<void>;
+    /**
+     * Begins tracking a new proposal
+     */
+    addProposal(key: string, value: any, sequenceNumber: number, local: boolean, clientSequenceNumber: number): void;
+    /**
+     * Updates the minimum sequence number. If the MSN advances past the sequence number for any proposal then it
+     * becomes an approved value.
+     */
+    updateMinimumSequenceNumber(message: ISequencedDocumentMessage): void;
+    setConnectionState(connected: boolean, clientId?: string): void;
+    dispose(): void;
+}
+//# sourceMappingURL=quorum.d.ts.map

package/dist/protocol/quorum.d.ts.map

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

package/dist/protocol/quorum.js

@@ -0,0 +1,419 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Quorum = exports.QuorumProposals = exports.QuorumClients = void 0;
+const client_utils_1 = require("@fluid-internal/client-utils");
+const internal_1 = require("@fluidframework/core-utils/internal");
+const events_pkg_1 = __importDefault(require("events_pkg"));
+const { EventEmitter } = events_pkg_1.default;
+/**
+ * Structure for tracking proposals that have been sequenced but not approved yet.
+ */
+class PendingProposal {
+    constructor(sequenceNumber, key, value, local) {
+        this.sequenceNumber = sequenceNumber;
+        this.key = key;
+        this.value = value;
+        this.local = local;
+    }
+}
+/**
+ * The QuorumClients is used to track members joining and leaving the collaboration session.
+ * @internal
+ */
+class QuorumClients extends client_utils_1.TypedEventEmitter {
+    get disposed() {
+        return this.isDisposed;
+    }
+    constructor(snapshot) {
+        super();
+        this.isDisposed = false;
+        this.members = new Map(snapshot);
+        this.snapshotCache = snapshot;
+    }
+    /**
+     * Snapshots the current state of the QuorumClients
+     * @returns a snapshot of the clients in the quorum
+     */
+    snapshot() {
+        this.snapshotCache ?? (this.snapshotCache = Array.from(this.members));
+        return this.snapshotCache;
+    }
+    /**
+     * Adds a new client to the quorum
+     */
+    addMember(clientId, details) {
+        (0, internal_1.assert)(!!clientId, 0x9a0 /* clientId has to be non-empty string */);
+        (0, internal_1.assert)(!this.members.has(clientId), 0x9a1 /* clientId not found */);
+        this.members.set(clientId, details);
+        this.emit("addMember", clientId, details);
+        // clear the cache
+        this.snapshotCache = undefined;
+    }
+    /**
+     * Removes a client from the quorum
+     */
+    removeMember(clientId) {
+        (0, internal_1.assert)(!!clientId, 0x9a2 /* clientId has to be non-empty string */);
+        (0, internal_1.assert)(this.members.has(clientId), 0x9a3 /* clientId not found */);
+        this.members.delete(clientId);
+        this.emit("removeMember", clientId);
+        // clear the cache
+        this.snapshotCache = undefined;
+    }
+    /**
+     * Retrieves all the members in the quorum
+     */
+    getMembers() {
+        return new Map(this.members);
+    }
+    /**
+     * Retrieves a specific member of the quorum
+     */
+    getMember(clientId) {
+        return this.members.get(clientId);
+    }
+    dispose() {
+        this.isDisposed = true;
+    }
+}
+exports.QuorumClients = QuorumClients;
+/**
+ * The QuorumProposals holds a key/value store.  Proposed values become finalized in the store once all connected
+ * clients have seen the proposal.
+ * @internal
+ */
+class QuorumProposals extends client_utils_1.TypedEventEmitter {
+    get disposed() {
+        return this.isDisposed;
+    }
+    constructor(snapshot, sendProposal) {
+        super();
+        this.sendProposal = sendProposal;
+        this.isDisposed = false;
+        // Event emitter for changes to the environment that affect pending proposal promises.
+        this.stateEvents = new EventEmitter();
+        this.proposals = new Map(snapshot.proposals.map(([, proposal]) => {
+            return [
+                proposal.sequenceNumber,
+                new PendingProposal(proposal.sequenceNumber, proposal.key, proposal.value, false),
+            ];
+        }));
+        this.values = new Map(snapshot.values);
+        this.proposalsSnapshotCache = snapshot.proposals;
+        this.valuesSnapshotCache = snapshot.values;
+    }
+    /**
+     * Snapshots the current state of the QuorumProposals
+     * @returns arrays of proposals and values
+     */
+    snapshot() {
+        this.proposalsSnapshotCache ?? (this.proposalsSnapshotCache = Array.from(this.proposals).map(([sequenceNumber, proposal]) => [
+            sequenceNumber,
+            { sequenceNumber, key: proposal.key, value: proposal.value },
+            [], // rejections, which has been removed
+        ]));
+        this.valuesSnapshotCache ?? (this.valuesSnapshotCache = Array.from(this.values));
+        return {
+            proposals: this.proposalsSnapshotCache,
+            values: this.valuesSnapshotCache,
+        };
+    }
+    /**
+     * Returns whether the quorum has achieved a consensus for the given key.
+     */
+    has(key) {
+        return this.values.has(key);
+    }
+    /**
+     * Returns the consensus value for the given key
+     */
+    get(key) {
+        return this.values.get(key)?.value;
+    }
+    /**
+     * Returns additional data about the approved consensus value
+     * @deprecated Removed in recent protocol-definitions.  Use get() instead.
+     */
+    getApprovalData(key) {
+        return this.values.get(key);
+    }
+    /**
+     * Proposes a new value. Returns a promise that will either:
+     * - Resolve when the proposal is accepted
+     * - Reject if the proposal fails to send or if the QuorumProposals is disposed
+     */
+    async propose(key, value) {
+        const clientSequenceNumber = this.sendProposal(key, value);
+        if (clientSequenceNumber < 0) {
+            this.emit("error", { eventName: "ProposalInDisconnectedState", key });
+            throw new Error("Can't propose in disconnected state");
+        }
+        return new Promise((resolve, reject) => {
+            // The sequence number that our proposal was assigned and went pending.
+            // If undefined, then it's not sequenced yet.
+            let thisProposalSequenceNumber;
+            // A proposal goes through two phases before this promise resolves:
+            // 1. Sequencing - waiting for the proposal to be ack'd by the server.
+            // 2. Approval - waiting for the proposal to be approved by connected clients.
+            const localProposalSequencedHandler = (sequencedCSN, sequenceNumber) => {
+                if (sequencedCSN === clientSequenceNumber) {
+                    thisProposalSequenceNumber = sequenceNumber;
+                    this.stateEvents.off("localProposalSequenced", localProposalSequencedHandler);
+                    this.stateEvents.off("disconnected", disconnectedHandler);
+                    this.stateEvents.on("localProposalApproved", localProposalApprovedHandler);
+                }
+            };
+            const localProposalApprovedHandler = (sequenceNumber) => {
+                // Proposals can be uniquely identified by the sequenceNumber they were assigned.
+                if (sequenceNumber === thisProposalSequenceNumber) {
+                    resolve();
+                    removeListeners();
+                }
+            };
+            // There are two error flows we consider:  disconnect and disposal.
+            // If we get disconnected before the proposal is sequenced, it has one of two possible futures:
+            // 1. We reconnect and see the proposal was sequenced in the meantime.
+            //    -> The promise can still resolve, once it is approved.
+            // 2. We reconnect and see the proposal was not sequenced in the meantime, so it will never sequence.
+            //    -> The promise rejects.
+            const disconnectedHandler = () => {
+                // If we haven't seen the ack by the time we disconnect, we hope to see it by the time we reconnect.
+                if (thisProposalSequenceNumber === undefined) {
+                    this.stateEvents.once("connected", () => {
+                        // If we don't see the ack by the time reconnection finishes, it failed to send.
+                        if (thisProposalSequenceNumber === undefined) {
+                            reject(new Error("Client disconnected without successfully sending proposal"));
+                            removeListeners();
+                        }
+                    });
+                }
+            };
+            // If the QuorumProposals is disposed of, we assume something catastrophic has happened
+            // All outstanding proposals are considered rejected.
+            const disposedHandler = () => {
+                reject(new Error("QuorumProposals was disposed"));
+                removeListeners();
+            };
+            // Convenience function to clean up our listeners.
+            const removeListeners = () => {
+                this.stateEvents.off("localProposalSequenced", localProposalSequencedHandler);
+                this.stateEvents.off("localProposalApproved", localProposalApprovedHandler);
+                this.stateEvents.off("disconnected", disconnectedHandler);
+                this.stateEvents.off("disposed", disposedHandler);
+            };
+            this.stateEvents.on("localProposalSequenced", localProposalSequencedHandler);
+            this.stateEvents.on("disconnected", disconnectedHandler);
+            this.stateEvents.on("disposed", disposedHandler);
+        });
+    }
+    /**
+     * Begins tracking a new proposal
+     */
+    addProposal(key, value, sequenceNumber, local, clientSequenceNumber) {
+        (0, internal_1.assert)(!this.proposals.has(sequenceNumber), 0x9a4 /* sequenceNumber not found */);
+        const proposal = new PendingProposal(sequenceNumber, key, value, local);
+        this.proposals.set(sequenceNumber, proposal);
+        // Legacy event, from rejection support.  May still have some use for clients to learn that a proposal is
+        // likely to be approved soon.
+        this.emit("addProposal", proposal);
+        if (local) {
+            this.stateEvents.emit("localProposalSequenced", clientSequenceNumber, sequenceNumber);
+        }
+        // clear the proposal cache
+        this.proposalsSnapshotCache = undefined;
+    }
+    /**
+     * Updates the minimum sequence number. If the MSN advances past the sequence number for any proposal then it
+     * becomes an approved value.
+     */
+    updateMinimumSequenceNumber(message) {
+        const msn = message.minimumSequenceNumber;
+        // Accept proposals proposals whose sequenceNumber is <= the minimumSequenceNumber
+        // Return a sorted list of approved proposals. We sort so that we apply them in their sequence number order
+        // TODO this can be optimized if necessary to avoid the linear search+sort
+        const completed = [];
+        for (const [sequenceNumber, proposal] of this.proposals) {
+            if (sequenceNumber <= msn) {
+                completed.push(proposal);
+            }
+        }
+        completed.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+        for (const proposal of completed) {
+            const committedProposal = {
+                approvalSequenceNumber: message.sequenceNumber,
+                // No longer used.  We still stamp a -1 for compat with older versions of the quorum.
+                // Can be removed after 0.1035 and higher is ubiquitous.
+                commitSequenceNumber: -1,
+                key: proposal.key,
+                sequenceNumber: proposal.sequenceNumber,
+                value: proposal.value,
+            };
+            this.values.set(committedProposal.key, committedProposal);
+            // clear the values cache
+            this.valuesSnapshotCache = undefined;
+            // check if there are multiple proposals with matching keys
+            let proposalSettled = false;
+            let proposalKeySeen = false;
+            for (const [, p] of this.proposals) {
+                if (p.key === committedProposal.key) {
+                    if (!proposalKeySeen) {
+                        // set proposalSettled to true if the proposal key match is unique thus far
+                        proposalSettled = true;
+                    }
+                    else {
+                        // set proposalSettled to false if matching proposal key is not unique
+                        proposalSettled = false;
+                        break;
+                    }
+                    proposalKeySeen = true;
+                }
+            }
+            this.emit("approveProposal", committedProposal.sequenceNumber, committedProposal.key, committedProposal.value, committedProposal.approvalSequenceNumber);
+            // emit approveProposalComplete when all pending proposals are processed
+            if (proposalSettled) {
+                this.emit("approveProposalComplete", committedProposal.sequenceNumber, committedProposal.key, committedProposal.value, committedProposal.approvalSequenceNumber);
+            }
+            this.proposals.delete(proposal.sequenceNumber);
+            // clear the proposals cache
+            this.proposalsSnapshotCache = undefined;
+            if (proposal.local) {
+                this.stateEvents.emit("localProposalApproved", proposal.sequenceNumber);
+            }
+        }
+    }
+    setConnectionState(connected) {
+        if (connected) {
+            this.stateEvents.emit("connected");
+        }
+        else {
+            this.stateEvents.emit("disconnected");
+        }
+    }
+    dispose() {
+        this.isDisposed = true;
+        this.stateEvents.emit("disposed");
+    }
+}
+exports.QuorumProposals = QuorumProposals;
+/**
+ * A quorum represents all clients currently within the collaboration window. As well as the values
+ * they have agreed upon and any pending proposals.
+ * @internal
+ */
+class Quorum extends client_utils_1.TypedEventEmitter {
+    get disposed() {
+        return this.isDisposed;
+    }
+    constructor(members, proposals, values, sendProposal) {
+        super();
+        this.isDisposed = false;
+        this.quorumClients = new QuorumClients(members);
+        this.quorumClients.on("addMember", (clientId, details) => {
+            this.emit("addMember", clientId, details);
+        });
+        this.quorumClients.on("removeMember", (clientId) => {
+            this.emit("removeMember", clientId);
+        });
+        this.quorumProposals = new QuorumProposals({ proposals, values }, sendProposal);
+        this.quorumProposals.on("addProposal", (proposal) => {
+            this.emit("addProposal", proposal);
+        });
+        this.quorumProposals.on("approveProposal", (sequenceNumber, key, value, approvalSequenceNumber) => {
+            this.emit("approveProposal", sequenceNumber, key, value, approvalSequenceNumber);
+        });
+    }
+    close() {
+        this.removeAllListeners();
+    }
+    /**
+     * Snapshots the entire quorum
+     * @returns a quorum snapshot
+     */
+    snapshot() {
+        const members = this.quorumClients.snapshot();
+        const { proposals, values } = this.quorumProposals.snapshot();
+        return {
+            members,
+            proposals,
+            values,
+        };
+    }
+    /**
+     * Returns whether the quorum has achieved a consensus for the given key.
+     */
+    has(key) {
+        return this.quorumProposals.has(key);
+    }
+    /**
+     * Returns the consensus value for the given key
+     */
+    get(key) {
+        return this.quorumProposals.get(key);
+    }
+    /**
+     * Returns additional data about the approved consensus value
+     * @deprecated Removed in recent protocol-definitions.  Use get() instead.
+     */
+    getApprovalData(key) {
+        return this.quorumProposals.getApprovalData(key);
+    }
+    /**
+     * Adds a new client to the quorum
+     */
+    addMember(clientId, details) {
+        this.quorumClients.addMember(clientId, details);
+    }
+    /**
+     * Removes a client from the quorum
+     */
+    removeMember(clientId) {
+        this.quorumClients.removeMember(clientId);
+    }
+    /**
+     * Retrieves all the members in the quorum
+     */
+    getMembers() {
+        return this.quorumClients.getMembers();
+    }
+    /**
+     * Retrieves a specific member of the quorum
+     */
+    getMember(clientId) {
+        return this.quorumClients.getMember(clientId);
+    }
+    /**
+     * Proposes a new value. Returns a promise that will resolve when the proposal is either accepted, or reject if
+     * the proposal fails to send.
+     */
+    async propose(key, value) {
+        return this.quorumProposals.propose(key, value);
+    }
+    /**
+     * Begins tracking a new proposal
+     */
+    addProposal(key, value, sequenceNumber, local, clientSequenceNumber) {
+        return this.quorumProposals.addProposal(key, value, sequenceNumber, local, clientSequenceNumber);
+    }
+    /**
+     * Updates the minimum sequence number. If the MSN advances past the sequence number for any proposal then it
+     * becomes an approved value.
+     */
+    updateMinimumSequenceNumber(message) {
+        this.quorumProposals.updateMinimumSequenceNumber(message);
+    }
+    setConnectionState(connected, clientId) {
+        this.quorumProposals.setConnectionState(connected);
+    }
+    dispose() {
+        throw new Error("Not implemented.");
+    }
+}
+exports.Quorum = Quorum;
+//# sourceMappingURL=quorum.js.map