@fluidframework/container-runtime 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/summarizerClientElection.ts

@@ -1,161 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IEvent, IEventProvider, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { TypedEventEmitter } from "@fluidframework/common-utils";
-import { IClientDetails, MessageType } from "@fluidframework/protocol-definitions";
-import { IOrderedClientElection, ISerializedElection, ITrackedClient } from "./orderedClientElection";
-import { ISummaryCollectionOpEvents } from "./summaryCollection";
-
-export const summarizerClientType = "summarizer";
-
-export interface ISummarizerClientElectionEvents extends IEvent {
-    (event: "electedSummarizerChanged", handler: () => void): void;
-}
-
-export interface ISummarizerClientElection extends IEventProvider<ISummarizerClientElectionEvents> {
-    readonly electedClientId: string | undefined;
-    readonly electedParentId: string | undefined;
-}
-
-/**
- * This class encapsulates logic around tracking the elected summarizer client.
- * It will handle updating the elected client when a summary ack hasn't been seen
- * for some configured number of ops.
- */
-export class SummarizerClientElection
-    extends TypedEventEmitter<ISummarizerClientElectionEvents>
-    implements ISummarizerClientElection {
-    /**
-     * Used to calculate number of ops since last summary ack for the current elected client.
-     * This will be undefined if there is no elected summarizer, or no summary ack has been
-     * observed since this client was elected.
-     * When a summary ack comes in, this will be set to the sequence number of the summary ack.
-     */
-    private lastSummaryAckSeqForClient: number | undefined;
-    /**
-     * Used to prevent excess logging by recording the sequence number that we last reported at,
-     * and making sure we don't report another event to telemetry. If things work as intended,
-     * this is not needed, otherwise it could report an event on every op in worst case scenario.
-     */
-    private lastReportedSeq = 0;
-
-    public get electedClientId() {
-        return this.clientElection.electedClient?.clientId;
-    }
-    public get electedParentId() {
-        return this.clientElection.electedParent?.clientId;
-    }
-
-    constructor(
-        private readonly logger: ITelemetryLogger,
-        private readonly summaryCollection: IEventProvider<ISummaryCollectionOpEvents>,
-        public readonly clientElection: IOrderedClientElection,
-        private readonly maxOpsSinceLastSummary: number,
-        private readonly electionEnabled: boolean,
-    ) {
-        super();
-        // On every inbound op, if enough ops pass without seeing a summary ack (per elected client),
-        // elect a new client and log to telemetry.
-        this.summaryCollection.on("default", ({ sequenceNumber }) => {
-            const electedClientId = this.electedClientId;
-            if (electedClientId === undefined) {
-                // Reset election if no elected client, but eligible clients are connected.
-                // This should be uncommon, but is possible if the initial state of the
-                // ordered client election contains an undefined client id or one not found
-                // in the quorum (the latter would already log an error).
-                if (this.clientElection.eligibleCount > 0) {
-                    this.clientElection.resetElectedClient(sequenceNumber);
-                }
-                return;
-            }
-            let electionSequenceNumber = this.clientElection.electionSequenceNumber;
-            const opsWithoutSummary = sequenceNumber - (this.lastSummaryAckSeqForClient ?? electionSequenceNumber);
-            if (opsWithoutSummary > this.maxOpsSinceLastSummary) {
-                // Log and elect a new summarizer client.
-                const opsSinceLastReport = sequenceNumber - this.lastReportedSeq;
-                if (opsSinceLastReport > this.maxOpsSinceLastSummary) {
-                    this.logger.sendErrorEvent({
-                        eventName: "ElectedClientNotSummarizing",
-                        electedClientId,
-                        lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
-                        electionSequenceNumber,
-                        nextElectedClientId: this.clientElection.peekNextElectedClient()?.clientId,
-                        electionEnabled: this.electionEnabled,
-                    });
-                    this.lastReportedSeq = sequenceNumber;
-                }
-
-                if (this.electionEnabled) {
-                    const previousParentId = this.electedParentId;
-                    this.clientElection.incrementElectedClient(sequenceNumber);
-
-                    // Verify that state incremented as expected. This should be reliable,
-                    // since all of OrderedClientElection is synchronous.
-                    electionSequenceNumber = this.clientElection.electionSequenceNumber;
-                    if (sequenceNumber > (this.lastSummaryAckSeqForClient ?? electionSequenceNumber)) {
-                        if (opsSinceLastReport > this.maxOpsSinceLastSummary) {
-                            this.logger.sendErrorEvent({
-                                eventName: "UnexpectedElectionSequenceNumber",
-                                // Expected to be undefined
-                                lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
-                                // Expected to be same as op sequenceNumber
-                                electionSequenceNumber,
-                                sequenceNumber,
-                                previousClientId: electedClientId,
-                                previousParentId,
-                                electedParentId: this.electedParentId,
-                                electedClientId: this.electedClientId,
-                                opsSinceLastReport,
-                                maxOpsSinceLastSummary,
-                            });
-                        }
-                    }
-                }
-            }
-        });
-
-        // When a summary ack comes in, reset our op seq counter.
-        this.summaryCollection.on(MessageType.SummaryAck, (op) => {
-            this.lastSummaryAckSeqForClient = op.sequenceNumber;
-        });
-
-        // Use oldest client election for unanimously and deterministically deciding
-        // which client should summarize.
-        this.clientElection.on("election", (client, sequenceNumber) => {
-            this.lastSummaryAckSeqForClient = undefined;
-            if (client === undefined && this.clientElection.eligibleCount > 0) {
-                // If no client is valid for election, reset to the oldest again.
-                // Also make extra sure not to get stuck in an infinite loop here:
-                // If there are no eligible clients, just wait until a client joins
-                // and will be auto-elected.
-                this.clientElection.resetElectedClient(sequenceNumber);
-            }
-            // Election can trigger a change in SummaryManager state.
-            this.emit("electedSummarizerChanged");
-        });
-    }
-
-    public serialize(): ISerializedElection {
-        const { electedClientId, electedParentId, electionSequenceNumber } = this.clientElection.serialize();
-        return {
-            electedClientId,
-            electedParentId,
-            electionSequenceNumber: this.lastSummaryAckSeqForClient ?? electionSequenceNumber,
-        };
-    }
-
-    public static isClientEligible(client: ITrackedClient): boolean {
-        const details = client.client.details;
-        if (details === undefined) {
-            // Very old clients back-compat
-            return true;
-        }
-        return SummarizerClientElection.clientDetailsPermitElection(details);
-    }
-
-    public static readonly clientDetailsPermitElection = (details: IClientDetails): boolean =>
-        details.capabilities.interactive || details.type === summarizerClientType;
-}

package/src/summarizerHandle.ts

@@ -1,21 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { FluidObjectHandle } from "@fluidframework/datastore";
-import { IFluidHandle } from "@fluidframework/core-interfaces";
-
-// TODO #2425 Expose Summarizer handle as FluidObjectHandle w/ tests
-export class SummarizerHandle extends FluidObjectHandle {
-    public async get(): Promise<any> {
-        throw Error("Do not try to get a summarizer object from the handle. Reference it directly.");
-    }
-
-    public attach(): void {
-        return;
-    }
-
-    public bind(handle: IFluidHandle) {
-        return;
-    }
-}

package/src/summarizerHeuristics.ts

@@ -1,108 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { Timer } from "@fluidframework/common-utils";
-import { ISummaryConfigurationHeuristics } from "./containerRuntime";
-
-import {
-    ISummarizeHeuristicData,
-    ISummarizeHeuristicRunner,
-    ISummarizeAttempt,
-} from "./summarizerTypes";
-import { SummarizeReason } from "./summaryGenerator";
-
-/** Simple implementation of class for tracking summarize heuristic data. */
-export class SummarizeHeuristicData implements ISummarizeHeuristicData {
-    protected _lastAttempt: ISummarizeAttempt;
-    public get lastAttempt(): ISummarizeAttempt {
-        return this._lastAttempt;
-    }
-
-    protected _lastSuccessfulSummary: Readonly<ISummarizeAttempt>;
-    public get lastSuccessfulSummary(): Readonly<ISummarizeAttempt> {
-        return this._lastSuccessfulSummary;
-    }
-
-    constructor(
-        public lastOpSequenceNumber: number,
-        /** Baseline attempt data used for comparisons with subsequent attempts/calculations. */
-        attemptBaseline: ISummarizeAttempt,
-    ) {
-        this._lastAttempt = attemptBaseline;
-        this._lastSuccessfulSummary = { ...attemptBaseline };
-    }
-
-    public updateWithLastSummaryAckInfo(lastSummary: Readonly<ISummarizeAttempt>) {
-        this._lastAttempt = lastSummary;
-        this._lastSuccessfulSummary = { ...lastSummary };
-    }
-
-    public recordAttempt(refSequenceNumber?: number) {
-        this._lastAttempt = {
-            refSequenceNumber: refSequenceNumber ?? this.lastOpSequenceNumber,
-            summaryTime: Date.now(),
-        };
-    }
-
-    public markLastAttemptAsSuccessful() {
-        this._lastSuccessfulSummary = { ...this.lastAttempt };
-    }
-}
-
-/**
- * This class contains the heuristics for when to summarize.
- */
-export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
-    private readonly idleTimer: Timer;
-    private readonly minOpsForLastSummaryAttempt: number;
-
-    public constructor(
-        private readonly heuristicData: ISummarizeHeuristicData,
-        private readonly configuration: ISummaryConfigurationHeuristics,
-        private readonly trySummarize: (reason: SummarizeReason) => void,
-        private readonly logger: ITelemetryLogger,
-    ) {
-        this.idleTimer = new Timer(
-            this.configuration.idleTime,
-            () => this.trySummarize("idle"));
-        this.minOpsForLastSummaryAttempt = this.configuration.minOpsForLastSummaryAttempt;
-    }
-
-    public get opsSinceLastAck(): number {
-        return this.heuristicData.lastOpSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber;
-    }
-
-    public run() {
-        const timeSinceLastSummary = Date.now() - this.heuristicData.lastSuccessfulSummary.summaryTime;
-        const opsSinceLastAck = this.opsSinceLastAck;
-        if (timeSinceLastSummary > this.configuration.maxTime) {
-            this.idleTimer.clear();
-            this.trySummarize("maxTime");
-        } else if (opsSinceLastAck > this.configuration.maxOps) {
-            this.idleTimer.clear();
-            this.trySummarize("maxOps");
-        } else {
-            this.idleTimer.restart();
-        }
-    }
-
-    public shouldRunLastSummary(): boolean {
-        const opsSinceLastAck = this.opsSinceLastAck;
-        const minOpsForLastSummaryAttempt = this.minOpsForLastSummaryAttempt;
-
-        this.logger.sendTelemetryEvent({
-            eventName: "ShouldRunLastSummary",
-            opsSinceLastAck,
-            minOpsForLastSummaryAttempt,
-        });
-
-        return opsSinceLastAck >= minOpsForLastSummaryAttempt;
-    }
-
-    public dispose() {
-        this.idleTimer.clear();
-    }
-}