@fluidframework/container-runtime 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.3.1.0.125672

package/src/runWhileConnectedCoordinator.ts

@@ -4,11 +4,15 @@
  */
 
 import { assert, Deferred } from "@fluidframework/common-utils";
-import { SummarizerStopReason, IConnectableRuntime, ISummaryCancellationToken } from "./summarizerTypes";
+import {
+	SummarizerStopReason,
+	IConnectableRuntime,
+	ISummaryCancellationToken,
+} from "./summarizerTypes";
 
 /* Similar to AbortController, but using promise instead of events */
 export interface ICancellableSummarizerController extends ISummaryCancellationToken {
-    stop(reason: SummarizerStopReason): void;
+	stop(reason: SummarizerStopReason): void;
 }
 
 /**
@@ -16,8 +20,8 @@ export interface ICancellableSummarizerController extends ISummaryCancellationTo
  * This object implements ISummaryCancellationToken interface but cancellation is never leveraged.
  */
 export const neverCancelledSummaryToken: ISummaryCancellationToken = {
-    cancelled: false,
-    waitCancelled: new Promise(() => {}),
+	cancelled: false,
+	waitCancelled: new Promise(() => {}),
 };
 
 /**
@@ -26,81 +30,84 @@ export const neverCancelledSummaryToken: ISummaryCancellationToken = {
  * when disconnected or if stop() is called.
  */
 export class RunWhileConnectedCoordinator implements ICancellableSummarizerController {
-    private _cancelled = false;
-    private readonly stopDeferred = new Deferred<SummarizerStopReason>();
+	private _cancelled = false;
+	private readonly stopDeferred = new Deferred<SummarizerStopReason>();
 
-    public get cancelled() {
-        if (!this._cancelled) {
-            assert(this.runtime.deltaManager.active, 0x25d /* "We should never connect as 'read'" */);
+	public get cancelled() {
+		if (!this._cancelled) {
+			assert(
+				this.runtime.deltaManager.active,
+				0x25d /* "We should never connect as 'read'" */,
+			);
 
-            // This check can't be enabled in current design due to lastSummary flow, where
-            // summarizer for closed container stays around and can produce one more summary.
-            // Currently we solve the problem of overlapping summarizer by doing wait in
-            // SummaryManager.createSummarizer()
-            // Better solution would involve these steps:
-            // 1. Summarizer selection logic should chose summarizing client (with clientType === "summarizer")
-            // if such client exists.
-            // 2. Summarizer should be updated about such changes (to update onBehalfOfClientId)
-            //
-            // assert(this.runtime.summarizerClientId === this.onBehalfOfClientId ||
-            //    this.runtime.summarizerClientId === this.runtime.clientId, "onBehalfOfClientId");
-        }
+			// This check can't be enabled in current design due to lastSummary flow, where
+			// summarizer for closed container stays around and can produce one more summary.
+			// Currently we solve the problem of overlapping summarizer by doing wait in
+			// SummaryManager.createSummarizer()
+			// Better solution would involve these steps:
+			// 1. Summarizer selection logic should chose summarizing client (with clientType === "summarizer")
+			// if such client exists.
+			// 2. Summarizer should be updated about such changes (to update onBehalfOfClientId)
+			//
+			// assert(this.runtime.summarizerClientId === this.onBehalfOfClientId ||
+			//    this.runtime.summarizerClientId === this.runtime.clientId, "onBehalfOfClientId");
+		}
 
-        return this._cancelled;
-    }
+		return this._cancelled;
+	}
 
-    /**
-     * Returns a promise that resolves once stopped either externally or by disconnect.
-     */
-     public get waitCancelled(): Promise<SummarizerStopReason> {
-        return this.stopDeferred.promise;
-    }
+	/**
+	 * Returns a promise that resolves once stopped either externally or by disconnect.
+	 */
+	public get waitCancelled(): Promise<SummarizerStopReason> {
+		return this.stopDeferred.promise;
+	}
 
-    public static async create(runtime: IConnectableRuntime) {
-        const obj = new RunWhileConnectedCoordinator(runtime);
-        await obj.waitStart();
-        return obj;
-    }
+	public static async create(runtime: IConnectableRuntime) {
+		const obj = new RunWhileConnectedCoordinator(runtime);
+		await obj.waitStart();
+		return obj;
+	}
 
-    protected constructor(private readonly runtime: IConnectableRuntime) {
-    }
+	protected constructor(private readonly runtime: IConnectableRuntime) {}
 
-    /**
-     * Starts and waits for a promise which resolves when connected.
-     * The promise will also resolve if stopped either externally or by disconnect.
-     *
-     * We only listen on disconnected event for clientType === "summarizer" container!
-     * And only do it here - no other place should check it! That way we have only one place
-     * that controls policy and it's easy to change policy in the future if we want to!
-     * We do not listen for "main" (aka interactive) container disconnect here, as it's
-     * responsibility of SummaryManager to decide if that's material or not. There are cases
-     * like "lastSummary", or main client experiencing nacks / disconnects due to hitting limit
-     * of non-summarized ops, where can make determination to continue with summary even if main
-     * client is disconnected.
-     */
-    protected async waitStart() {
-        if (this.runtime.disposed) {
-            this.stop("summarizerClientDisconnected");
-            return;
-        }
+	/**
+	 * Starts and waits for a promise which resolves when connected.
+	 * The promise will also resolve if stopped either externally or by disconnect.
+	 *
+	 * We only listen on disconnected event for clientType === "summarizer" container!
+	 * And only do it here - no other place should check it! That way we have only one place
+	 * that controls policy and it's easy to change policy in the future if we want to!
+	 * We do not listen for "main" (aka interactive) container disconnect here, as it's
+	 * responsibility of SummaryManager to decide if that's material or not. There are cases
+	 * like "lastSummary", or main client experiencing nacks / disconnects due to hitting limit
+	 * of non-summarized ops, where can make determination to continue with summary even if main
+	 * client is disconnected.
+	 */
+	protected async waitStart() {
+		if (this.runtime.disposed) {
+			this.stop("summarizerClientDisconnected");
+			return;
+		}
 
-        this.runtime.once("dispose", () => this.stop("summarizerClientDisconnected"));
+		this.runtime.once("dispose", () => this.stop("summarizerClientDisconnected"));
 
-        if (!this.runtime.connected) {
-            const waitConnected = new Promise<void>((resolve) =>
-                this.runtime.once("connected", resolve));
-            await Promise.race([waitConnected, this.waitCancelled]);
-        }
-        this.runtime.once("disconnected", () => this.stop("summarizerClientDisconnected"));
-    }
+		if (!this.runtime.connected) {
+			const waitConnected = new Promise<void>((resolve) =>
+				this.runtime.once("connected", resolve),
+			);
+			await Promise.race([waitConnected, this.waitCancelled]);
+		}
+		this.runtime.once("disconnected", () => this.stop("summarizerClientDisconnected"));
+	}
 
-    /**
-     * Stops running.
-     */
-    public stop(reason: SummarizerStopReason): void {
-        if (!this._cancelled) {
-            this._cancelled = true;
-            this.stopDeferred.resolve(reason);
-        }
-    }
+	/**
+	 * Stops running.
+	 */
+	public stop(reason: SummarizerStopReason): void {
+		if (!this._cancelled) {
+			this._cancelled = true;
+			this.stopDeferred.resolve(reason);
+		}
+	}
 }