@fluidframework/container-runtime 0.52.0 → 0.54.0-47413

package/src/index.ts

@@ -3,10 +3,28 @@
  * Licensed under the MIT License.
  */
 
-export * from "./containerRuntime";
+export {
+    ContainerMessageType,
+    IChunkedOp,
+    ContainerRuntimeMessage,
+    IGCRuntimeOptions,
+    ISummaryRuntimeOptions,
+    IContainerRuntimeOptions,
+    isRuntimeMessage,
+    unpackRuntimeMessage,
+    ScheduleManager,
+    agentSchedulerId,
+    ContainerRuntime,
+} from "./containerRuntime";
 export * from "./deltaScheduler";
 export * from "./dataStoreRegistry";
-export { IGarbageCollectionRuntime, IGCStats, IUsedStateStats } from "./garbageCollection";
+export {
+    gcBlobPrefix,
+    gcTreeKey,
+    IGarbageCollectionRuntime,
+    IGCStats,
+    IUsedStateStats,
+} from "./garbageCollection";
 export * from "./pendingStateManager";
 export * from "./summarizer";
 export * from "./summarizerTypes";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "0.52.0";
+export const pkgVersion = "0.54.0-47413";

package/src/pendingStateManager.ts

@@ -71,7 +71,6 @@ export class PendingStateManager implements IDisposable {
     private readonly initialStates: Deque<IPendingState>;
     private readonly previousClientIds = new Set<string>();
     private readonly firstStashedCSN: number = -1;
-    private stashedCount = 0;
     private readonly disposeOnce = new Lazy<void>(() => {
         this.initialStates.clear();
         this.pendingStates.clear();
@@ -127,7 +126,6 @@ export class PendingStateManager implements IDisposable {
             // get stashed op count and client sequence number of first op
             const messages = initialState.pendingStates
                 .filter((state) => state.type === "message") as IPendingMessage[];
-            this.stashedCount = messages.length;
             this.firstStashedCSN = messages[0].clientSequenceNumber;
         }
     }
@@ -290,7 +288,6 @@ export class PendingStateManager implements IDisposable {
                 // if it's not a message just drop it and keep looking
                 if (nextState.type === "message") {
                     this.assertOpMatch(nextState, message, isOriginalClientId);
-                    --this.stashedCount;
                     return { localAck: true, localOpMetadata: nextState.localOpMetadata };
                 }
             }
@@ -454,7 +451,6 @@ export class PendingStateManager implements IDisposable {
         // This assert suggests we are about to send same ops twice, which will result in data loss.
         assert(this.clientId !== this.containerRuntime.clientId,
             0x173 /* "replayPendingStates called twice for same clientId!" */);
-        const prevClientId = this.clientId;
         this.clientId = this.containerRuntime.clientId;
 
         assert(this.initialStates.isEmpty(), 0x174 /* "initial states should be empty before replaying pending" */);
@@ -464,45 +460,6 @@ export class PendingStateManager implements IDisposable {
             return;
         }
 
-        if (!prevClientId && this.stashedCount > 0) {
-            // this is first connect, verify we are about to "resubmit" only stashed ops
-            assert(this.pendingStates.toArray().filter((s) => s.type === "message").length === this.stashedCount,
-                0x290 /* "unexpected message queued before first connect" */);
-
-            Array.from(this.previousClientIds).map((id) =>
-                assert(this.containerRuntime.getQuorum().getMember(id) === undefined,
-                    0x291 /* "client with stashed ops already connected" */));
-
-            // send rejoin op with stashed client ID if we have it
-            if (this.previousClientIds.size > 0) {
-                const clientId = Array.from(this.previousClientIds)[0];
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                this.pendingStates.unshift({
-                    type: "message",
-                    messageType: ContainerMessageType.Rejoin,
-                    content: { clientId },
-                } as IPendingMessage);
-                ++pendingStatesCount;
-            }
-        }
-
-        if (prevClientId) {
-            // add a rejoin op so future clients provided with our stashed pending ops can recognize them
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const firstState = this.pendingStates.peekFront()!;
-            if (firstState.type !== "message" || firstState.messageType !== ContainerMessageType.Rejoin) {
-                // if there is already a rejoin op in the queue, just resubmit same op under new client ID
-                // otherwise, add one to the queue
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                this.pendingStates.unshift({
-                    type: "message",
-                    messageType: ContainerMessageType.Rejoin,
-                    content: { clientId: prevClientId },
-                } as IPendingMessage);
-                ++pendingStatesCount;
-            }
-        }
-
         // Reset the pending message count because all these messages will be removed from the queue.
         this.pendingMessagesCount = 0;
 

package/src/runningSummarizer.ts

@@ -5,6 +5,7 @@
 
 import { IDisposable, ITelemetryLogger, ITelemetryProperties } from "@fluidframework/common-definitions";
 import { assert, delay, Deferred, PromiseTimer } from "@fluidframework/common-utils";
+import { UsageError } from "@fluidframework/container-utils";
 import {
     ISequencedDocumentMessage,
     ISummaryConfiguration,
@@ -18,7 +19,6 @@ import {
     ISummarizeHeuristicData,
     ISummarizeHeuristicRunner,
     ISummarizerOptions,
-    OnDemandSummarizeResult,
     IOnDemandSummarizeOptions,
     EnqueueSummarizeResult,
     SummarizerStopReason,
@@ -408,25 +408,27 @@ export class RunningSummarizer implements IDisposable {
     }
 
     /** {@inheritdoc (ISummarizer:interface).summarizeOnDemand} */
-    public summarizeOnDemand({
-        reason,
-        ...options
-    }: IOnDemandSummarizeOptions): OnDemandSummarizeResult {
+    public summarizeOnDemand(
+        resultsBuilder: SummarizeResultBuilder = new SummarizeResultBuilder(),
+        {
+            reason,
+            ...options
+        }: IOnDemandSummarizeOptions): ISummarizeResults {
         if (this.stopping) {
-            const failBuilder = new SummarizeResultBuilder();
-            failBuilder.fail("RunningSummarizer stopped or disposed", undefined);
-            return failBuilder.build();
+            resultsBuilder.fail("RunningSummarizer stopped or disposed", undefined);
+            return resultsBuilder.build();
         }
         // Check for concurrent summary attempts. If one is found,
         // return a promise that caller can await before trying again.
         if (this.summarizingLock !== undefined) {
             // The heuristics are blocking concurrent summarize attempts.
-            return { alreadyRunning: this.summarizingLock };
+            throw new UsageError("Attempted to run an already-running summarizer on demand");
         }
         const result = this.trySummarizeOnce(
             { summarizeReason: `onDemand/${reason}` },
             options,
-            this.cancellationToken);
+            this.cancellationToken,
+            resultsBuilder);
         return result;
     }
 

package/src/summarizer.ts

@@ -6,19 +6,23 @@
 import { EventEmitter } from "events";
 import { Deferred } from "@fluidframework/common-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ILoader, LoaderHeader } from "@fluidframework/container-definitions";
+import { UsageError } from "@fluidframework/container-utils";
+import { DriverHeader } from "@fluidframework/driver-definitions";
+import { requestFluidObject } from "@fluidframework/runtime-utils";
 import { ChildLogger, IFluidErrorBase, LoggingError, wrapErrorAndLog } from "@fluidframework/telemetry-utils";
 import {
-    IRequest,
-    IResponse,
+    FluidObject,
     IFluidHandleContext,
     IFluidHandle,
+    IRequest,
 } from "@fluidframework/core-interfaces";
 import {
     ISequencedDocumentMessage,
     ISummaryConfiguration,
 } from "@fluidframework/protocol-definitions";
-import { create404Response } from "@fluidframework/runtime-utils";
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
+import { summarizerClientType } from "./summarizerClientElection";
 import { SummaryCollection } from "./summaryCollection";
 import { SummarizerHandle } from "./summarizerHandle";
 import { RunningSummarizer } from "./runningSummarizer";
@@ -31,6 +35,7 @@ import {
     SummarizerStopReason,
 } from "./summarizerTypes";
 import { SummarizeHeuristicData } from "./summarizerHeuristics";
+import { SummarizeResultBuilder } from "./summaryGenerator";
 import { IConnectableRuntime } from ".";
 
 const summarizingError = "summarizingError";
@@ -63,7 +68,6 @@ export const createSummarizingWarning =
  */
 export class Summarizer extends EventEmitter implements ISummarizer {
     public get IFluidLoadable() { return this; }
-    public get IFluidRouter() { return this; }
     public get ISummarizer() { return this; }
 
     private readonly logger: ITelemetryLogger;
@@ -71,6 +75,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
     private systemOpListener?: (op: ISequencedDocumentMessage) => void;
     private opListener?: (error: any, op: ISequencedDocumentMessage) => void;
     private _disposed: boolean = false;
+    private starting: boolean = false;
 
     private readonly innerHandle: IFluidHandle<this>;
 
@@ -98,6 +103,40 @@ export class Summarizer extends EventEmitter implements ISummarizer {
         this.innerHandle = new SummarizerHandle(this, url, handleContext);
     }
 
+    /**
+     * Creates a Summarizer and its underlying client.
+     * Note that different implementations of ILoader will handle the URL differently.
+     * ILoader provided by a ContainerRuntime is a RelativeLoader, which will treat URL's
+     * starting with "/" as relative to the Container. The general ILoader
+     * interface will expect an absolute URL and will not handle "/".
+     * @param loader - the loader that resolves the request
+     * @param url - the URL used to resolve the container
+     */
+    public static async create(
+        loader: ILoader,
+        url: string): Promise<ISummarizer> {
+        const request: IRequest = {
+            headers: {
+                [LoaderHeader.cache]: false,
+                [LoaderHeader.clientDetails]: {
+                    capabilities: { interactive: false },
+                    type: summarizerClientType,
+                },
+                [DriverHeader.summarizingClient]: true,
+                [LoaderHeader.reconnect]: false,
+            },
+            url,
+        };
+
+        const resolvedContainer = await loader.resolve(request);
+        const fluidObject =
+            await requestFluidObject<FluidObject<ISummarizer>>(resolvedContainer, { url: "_summarizer" });
+        if (fluidObject.ISummarizer === undefined) {
+            throw new UsageError("Fluid object does not implement ISummarizer");
+        }
+        return fluidObject.ISummarizer;
+    }
+
     public async run(
         onBehalfOf: string,
         options?: Readonly<Partial<ISummarizerOptions>>): Promise<SummarizerStopReason> {
@@ -121,27 +160,9 @@ export class Summarizer extends EventEmitter implements ISummarizer {
         this.stopDeferred.resolve(reason);
     }
 
-    public async request(request: IRequest): Promise<IResponse> {
-        if (request.url === "/" || request.url === "") {
-            return {
-                mimeType: "fluid/object",
-                status: 200,
-                value: this,
-            };
-        }
-        return create404Response(request);
-    }
-
     private async runCore(
         onBehalfOf: string,
         options?: Readonly<Partial<ISummarizerOptions>>): Promise<SummarizerStopReason> {
-        // Initialize values and first ack (time is not exact)
-        this.logger.sendTelemetryEvent({
-            eventName: "RunningSummarizer",
-            onBehalfOf,
-            initSummarySeqNumber: this.runtime.deltaManager.initialSequenceNumber,
-        });
-
         const runCoordinator: ICancellableSummarizerController = await this.runCoordinatorCreateFn(this.runtime);
 
         // Wait for either external signal to cancel, or loss of connectivity.
@@ -158,10 +179,70 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             return runCoordinator.waitCancelled;
         }
 
+        const runningSummarizer = await this.start(onBehalfOf, runCoordinator, options);
+
+        // Wait for either external signal to cancel, or loss of connectivity.
+        const stopReason = await stopP;
+
+        // There are two possible approaches here:
+        // 1. Propagate cancellation from this.stopDeferred to runCoordinator. This will ensure that we move to the exit
+        //    faster, including breaking out of the RunningSummarizer.trySummarize() faster.
+        //    We could create new coordinator and pass it to waitStop() -> trySummarizeOnce("lastSummary") flow.
+        //    The con of this approach is that we might cancel active summary, and lastSummary will fail because it
+        //    did not wait for ack/nack from previous summary. Plus we disregard any 429 kind of info from service
+        //    that way (i.e. trySummarize() loop might have been waiting for 5 min because storage told us so).
+        //    In general, it's more wasted resources.
+        // 2. We can not do it and make waitStop() do last summary only if there was no active summary. This ensures
+        //    that client behaves properly (from server POV) and we do not waste resources. But, it may mean we wait
+        //    substantially longer for trySummarize() retries to play out and thus this summary loop may run into
+        //    conflict with new summarizer client starting on different client.
+        // As of now, #2 is implemented. It's more forward looking, as issue #7279 suggests changing design for new
+        // summarizer client to not be created until current summarizer fully moves to exit, and that would reduce
+        // cons of #2 substantially.
+
+        // Cleanup after running
+        await runningSummarizer.waitStop(!runCoordinator.cancelled /* allowLastSummary */);
+
+        // Propagate reason and ensure that if someone is waiting for cancellation token, they are moving to exit
+        runCoordinator.stop(stopReason);
+
+        return stopReason;
+    }
+
+    /**
+     * Put the summarizer in a started state, including creating and initializing the RunningSummarizer.
+     * The start request can come either from the SummaryManager (in the auto-summarize case) or from the user
+     * (in the on-demand case).
+     * @param onBehalfOf - ID of the client that requested that the summarizer start
+     * @param runCoordinator - cancellation token
+     * @param options - options to forward to the RunningSummarizer
+     * @returns - Promise that is fulfilled when the RunningSummarizer is ready
+     */
+    private async start(
+        onBehalfOf: string,
+        runCoordinator: ICancellableSummarizerController,
+        options?: Readonly<Partial<ISummarizerOptions>>): Promise<RunningSummarizer> {
+        if (this.runningSummarizer) {
+            if (this.runningSummarizer.disposed) {
+                throw new UsageError("Starting a disposed summarizer");
+            }
+            return this.runningSummarizer;
+        }
+        if (this.starting) {
+            throw new UsageError("Attempting to start a summarizer that is already starting");
+        }
+        this.starting = true;
+        // Initialize values and first ack (time is not exact)
+        this.logger.sendTelemetryEvent({
+            eventName: "RunningSummarizer",
+            onBehalfOf,
+            initSummarySeqNumber: this.runtime.deltaManager.initialSequenceNumber,
+        });
+
         // Summarizing container ID (with clientType === "summarizer")
         const clientId = this.runtime.clientId;
         if (clientId === undefined) {
-            throw Error("clientId should be defined if connected.");
+            throw new UsageError("clientId should be defined if connected.");
         }
 
         const runningSummarizer = await RunningSummarizer.start(
@@ -187,6 +268,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             options,
         );
         this.runningSummarizer = runningSummarizer;
+        this.starting = false;
 
         // Handle summary acks
         // Note: no exceptions are thrown from handleSummaryAcks handler as it handles all exceptions
@@ -201,32 +283,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
         this.opListener = (error: any, op: ISequencedDocumentMessage) => runningSummarizer.handleOp(error, op);
         this.runtime.on("batchEnd", this.opListener);
 
-        // Wait for either external signal to cancel, or loss of connectivity.
-        const stopReason = await stopP;
-
-        // There are two possible approaches here:
-        // 1. Propagate cancellation from this.stopDeferred to runCoordinator. This will ensure that we move to the exit
-        //    faster, including breaking out of the RunningSummarizer.trySummarize() faster.
-        //    We could create new coordinator and pass it to waitStop() -> trySummarizeOnce("lastSummary") flow.
-        //    The con of this approach is that we might cancel active summary, and lastSummary will fail because it
-        //    did not wait for ack/nack from previous summary. Plus we disregard any 429 kind of info from service
-        //    that way (i.e. trySummarize() loop might have been waiting for 5 min because storage told us so).
-        //    In general, it's more wasted resources.
-        // 2. We can not do it and make waitStop() do last summary only if there was no active summary. This ensures
-        //    that client behaves properly (from server POV) and we do not waste resources. But, it may mean we wait
-        //    substantially longer for trySummarize() retries to play out and thus this summary loop may run into
-        //    conflict with new summarizer client starting on different client.
-        // As of now, #2 is implemented. It's more forward looking, as issue #7279 suggests changing design for new
-        // summarizer client to not be created until current summarizer fully moves to exit, and that would reduce
-        // cons of #2 substantially.
-
-        // Cleanup after running
-        await runningSummarizer.waitStop(!runCoordinator.cancelled /* allowLastSummary */);
-
-        // Propagate reason and ensure that if someone is waiting for cancellation token, they are moving to exit
-        runCoordinator.stop(stopReason);
-
-        return stopReason;
+        return runningSummarizer;
     }
 
     /**
@@ -253,15 +310,59 @@ export class Summarizer extends EventEmitter implements ISummarizer {
     }
 
     public readonly summarizeOnDemand: ISummarizer["summarizeOnDemand"] = (...args) => {
-        if (this._disposed || this.runningSummarizer === undefined || this.runningSummarizer.disposed) {
-            throw Error("Summarizer is not running or already disposed.");
+        try {
+            if (this._disposed || this.runningSummarizer?.disposed) {
+                throw new UsageError("Summarizer is already disposed.");
+            }
+            if (this.runtime.summarizerClientId !== undefined &&
+                this.runtime.summarizerClientId !== this.runtime.clientId) {
+                // If there is an elected summarizer, and it's not this one, don't allow on-demand summary.
+                // This is to prevent the on-demand summary and heuristic-based summary from stepping on
+                // each other.
+                throw new UsageError("On-demand summary attempted while an elected summarizer is present");
+            }
+            const builder = new SummarizeResultBuilder();
+            if (this.runningSummarizer) {
+                // Summarizer is already running. Go ahead and start.
+                return this.runningSummarizer.summarizeOnDemand(builder, ...args);
+            }
+
+            // Summarizer isn't running, so we need to start it, which is an async operation.
+            // Manage the promise related to creating the cancellation token here.
+            // The promises related to starting, summarizing,
+            // and submitting are communicated to the caller through the results builder.
+            const coordinatorCreateP = this.runCoordinatorCreateFn(this.runtime);
+
+            coordinatorCreateP.then((runCoordinator) => {
+                // Successully created the cancellation token. Start the summarizer.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const startP = this.start(this.runtime.clientId!, runCoordinator, { disableHeuristics: true });
+                startP.then(async (runningSummarizer) => {
+                    // Successfully started the summarizer. Run it.
+                    runningSummarizer.summarizeOnDemand(builder, ...args);
+                    // Wait for a command to stop or loss of connectivity before tearing down the summarizer and client.
+                    const stopReason = await Promise.race([this.stopDeferred.promise, runCoordinator.waitCancelled]);
+                    await runningSummarizer.waitStop(false);
+                    runCoordinator.stop(stopReason);
+                    this.dispose();
+                    this.runtime.closeFn();
+                }).catch((reason) => {
+                    builder.fail("Failed to start summarizer", reason);
+                });
+            }).catch((reason) => {
+                builder.fail("Failed to create cancellation token", reason);
+            });
+
+            return builder.build();
+        }
+        catch (error) {
+            throw SummarizingWarning.wrap(error, "summarizerRun", false /* logged */, this.logger);
         }
-        return this.runningSummarizer.summarizeOnDemand(...args);
     };
 
     public readonly enqueueSummarize: ISummarizer["enqueueSummarize"] = (...args) => {
         if (this._disposed || this.runningSummarizer === undefined || this.runningSummarizer.disposed) {
-            throw Error("Summarizer is not running or already disposed.");
+            throw new UsageError("Summarizer is not running or already disposed.");
         }
         return this.runningSummarizer.enqueueSummarize(...args);
     };

package/src/summarizerTypes.ts

@@ -9,7 +9,6 @@ import {
     ITelemetryLogger,
 } from "@fluidframework/common-definitions";
 import {
-    IFluidRouter,
     IFluidLoadable,
 } from "@fluidframework/core-interfaces";
 import { ContainerWarning, IDeltaManager } from "@fluidframework/container-definitions";
@@ -239,14 +238,6 @@ export interface ISummarizeResults {
     readonly receivedSummaryAckOrNack: Promise<SummarizeResultPart<IAckSummaryResult, INackSummaryResult>>;
 }
 
-export type OnDemandSummarizeResult = (ISummarizeResults & {
-    /** Indicates that an already running summarize attempt does not exist. */
-    readonly alreadyRunning?: undefined;
-}) | {
-    /** Resolves when an already running summarize attempt completes. */
-    readonly alreadyRunning: Promise<void>;
-};
-
 export type EnqueueSummarizeResult = (ISummarizeResults & {
     /**
      * Indicates that another summarize attempt is not already enqueued,
@@ -296,8 +287,9 @@ export interface ISummarizerEvents extends IEvent {
 }
 
 export interface ISummarizer extends
-    IEventProvider<ISummarizerEvents>, IFluidRouter, IFluidLoadable, Partial<IProvideSummarizer>{
+    IEventProvider<ISummarizerEvents>, IFluidLoadable, Partial<IProvideSummarizer>{
     stop(reason: SummarizerStopReason): void;
+
     run(onBehalfOf: string, options?: Readonly<Partial<ISummarizerOptions>>): Promise<SummarizerStopReason>;
 
     /**
@@ -309,7 +301,7 @@ export interface ISummarizer extends
      * that resolve as the summarize attempt progresses. They will resolve with success
      * false if a failure is encountered.
      */
-    summarizeOnDemand(options: IOnDemandSummarizeOptions): OnDemandSummarizeResult;
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
     /**
      * Enqueue an attempt to summarize after the specified sequence number.
      * If afterSequenceNumber is provided, the summarize attempt is "enqueued"

package/src/summaryFormat.ts

@@ -75,7 +75,7 @@ export function hasIsolatedChannels(attributes: ReadFluidDataStoreAttributes): b
 }
 
 export type GCVersion = number;
-export interface IContainerRuntimeMetadata {
+export interface IContainerRuntimeMetadata extends ICreateContainerMetadata {
     readonly summaryFormatVersion: 1;
     /** The last message processed at the time of summary. Only primitive propertiy types are added to the summary. */
     readonly message: ISummaryMetadataMessage | undefined;
@@ -83,6 +83,15 @@ export interface IContainerRuntimeMetadata {
     readonly disableIsolatedChannels?: true;
     /** 0 to disable GC, > 0 to enable GC, undefined defaults to disabled. */
     readonly gcFeature?: GCVersion;
+    /** Counter of the last summary happened, increments every time we summarize */
+    readonly summaryCount?: number;
+}
+
+export interface ICreateContainerMetadata {
+    /** Runtime version of the container when it was first created */
+    createContainerRuntimeVersion?: string;
+    /** Timestamp of the container when it was first created */
+    createContainerTimestamp?: number;
 }
 
 /** The properties of an ISequencedDocumentMessage to be stored in the metadata blob in summary. */
@@ -126,6 +135,7 @@ export function getMetadataFormatVersion(metadata?: IContainerRuntimeMetadata):
     return metadata?.summaryFormatVersion ?? 0;
 }
 
+export const aliasBlobName = ".aliases";
 export const metadataBlobName = ".metadata";
 export const chunksBlobName = ".chunks";
 export const electedSummarizerBlobName = ".electedSummarizer";

package/src/summaryGenerator.ts

@@ -346,10 +346,9 @@ export class SummaryGenerator {
                 }});
             } else {
                 // Check for retryDelay in summaryNack response.
-                // back-compat: cast needed until dep on protocol-definitions version bump
                 assert(ackNackOp.type === MessageType.SummaryNack, 0x274 /* "type check" */);
-                const summaryNack = ackNackOp.contents as { message?: string; retryAfter?: number; };
-                const message = summaryNack.message ?? ackNackOp.contents.errorMessage;
+                const summaryNack = ackNackOp.contents;
+                const message = summaryNack?.message;
                 const retryAfterSeconds = summaryNack?.retryAfter;
 
                 const error = new LoggingError(`summaryNack: ${message}`, { retryAfterSeconds });

package/src/summaryManager.ts

@@ -6,12 +6,9 @@
 import { IDisposable, IEvent, IEventProvider, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { TypedEventEmitter, assert } from "@fluidframework/common-utils";
 import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
-import { FluidObject, IFluidRouter, IRequest } from "@fluidframework/core-interfaces";
-import { LoaderHeader } from "@fluidframework/container-definitions";
-import { DriverHeader, DriverErrorType } from "@fluidframework/driver-definitions";
-import { requestFluidObject } from "@fluidframework/runtime-utils";
+import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { createSummarizingWarning } from "./summarizer";
-import { ISummarizerClientElection, summarizerClientType } from "./summarizerClientElection";
+import { ISummarizerClientElection } from "./summarizerClientElection";
 import { IThrottler } from "./throttler";
 import {
     ISummarizer,
@@ -371,47 +368,3 @@ export class SummaryManager extends TypedEventEmitter<ISummaryManagerEvents> imp
         this._disposed = true;
     }
 }
-
-export interface ISummarizerRequestOptions {
-    cache: boolean,
-    reconnect: boolean,
-    summarizingClient: boolean,
-}
-
-/**
- * Forms a function that will request a Summarizer.
- * @param loaderRouter - the loader acting as an IFluidRouter
- * @param lastSequenceNumber - the last sequence number (e.g., from DeltaManager)
- * @param cache - use cache to retrieve summarizer
- * @param summarizingClient - is summarizer client
- * @param reconnect - can reconnect on connection loss
- */
-export const formRequestSummarizerFn = (
-    loaderRouter: IFluidRouter,
-    lastSequenceNumber: number,
-    { cache, reconnect, summarizingClient }: ISummarizerRequestOptions,
-) => async () => {
-    // TODO eventually we may wish to spawn an execution context from which to run this
-    const request: IRequest = {
-        headers: {
-            [LoaderHeader.cache]: cache,
-            [LoaderHeader.clientDetails]: {
-                capabilities: { interactive: false },
-                type: summarizerClientType,
-            },
-            [DriverHeader.summarizingClient]: summarizingClient,
-            [LoaderHeader.reconnect]: reconnect,
-            [LoaderHeader.sequenceNumber]: lastSequenceNumber,
-        },
-        url: "/_summarizer",
-    };
-
-    const fluidObject = await requestFluidObject<FluidObject<ISummarizer>>(loaderRouter, request);
-    const summarizer = fluidObject.ISummarizer;
-
-    if (!summarizer) {
-        return Promise.reject(new Error("Fluid object does not implement ISummarizer"));
-    }
-
-    return summarizer;
-};

package/dist/localStorageFeatureGates.d.ts

@@ -1,13 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-export declare function getLocalStorageFeatureGate(key: string): boolean | undefined;
-//# sourceMappingURL=localStorageFeatureGates.d.ts.map

package/dist/localStorageFeatureGates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"localStorageFeatureGates.d.ts","sourceRoot":"","sources":["../src/localStorageFeatureGates.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAc3E"}

package/dist/localStorageFeatureGates.js

@@ -1,31 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLocalStorageFeatureGate = void 0;
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-function getLocalStorageFeatureGate(key) {
-    try {
-        if (typeof localStorage === "object" && localStorage !== null) {
-            const itemValue = localStorage.getItem(key);
-            if (itemValue === "1") {
-                return true;
-            }
-            if (itemValue === "0") {
-                return false;
-            }
-        }
-    }
-    catch (e) { }
-    return undefined;
-}
-exports.getLocalStorageFeatureGate = getLocalStorageFeatureGate;
-//# sourceMappingURL=localStorageFeatureGates.js.map