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

package/src/collabWindowTracker.ts

@@ -1,102 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert, Timer } from "@fluidframework/common-utils";
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { isRuntimeMessage } from "@fluidframework/driver-utils";
-
-const defaultNoopTimeFrequency = 2000;
-const defaultNoopCountFrequency = 50;
-
-// Here are key considerations when deciding conditions for when to send non-immediate noops:
-// 1. Sending them too often results in increase in file size and bandwidth, as well as catch up performance
-// 2. Sending too infrequently ensures that collab window is large, and as result Sequence DDS would have
-//    large catchUp blobs - see Issue #6364
-// 3. Similarly, processes that rely on "core" snapshot (and can't parse trailing ops, including above), like search
-//    parser in SPO, will result in non-accurate results due to presence of catch up blobs.
-// 4. Ordering service used 250ms timeout to coalesce non-immediate noops. It was changed to 2000 ms to allow more
-//    aggressive noop sending from client side.
-// 5. Number of ops sent by all clients is proportional to number of "write" clients (every client sends noops),
-//    but number of sequenced noops is a function of time (one op per 2 seconds at most).
-//    We should consider impact to both outbound traffic (might be huge, depends on number of clients) and file size.
-// Please also see Issue #5629 for more discussions.
-//
-// With that, the current algorithm is as follows:
-// 1. Sent noop 2000 ms of receiving an op if no ops were sent by this client within this timeframe.
-//    This will ensure that MSN moves forward with reasonable speed. If that results in too many sequenced noops,
-//    server timeout of 2000ms should be reconsidered to be increased.
-// 2. If there are more than 50 ops received without sending any ops, send noop to keep collab window small.
-//    Note that system ops (including noops themselves) are excluded, so it's 1 noop per 50 real ops.
-export class CollabWindowTracker {
-    private opsCountSinceNoop = 0;
-    private readonly timer: Timer | undefined;
-
-    constructor(
-        private readonly submit: (type: MessageType, contents: any) => void,
-        NoopTimeFrequency: number = defaultNoopTimeFrequency,
-        private readonly NoopCountFrequency: number = defaultNoopCountFrequency,
-    ) {
-        if (NoopTimeFrequency !== Infinity) {
-            this.timer = new Timer(NoopTimeFrequency, () => {
-                // Can get here due to this.stopSequenceNumberUpdate() not resetting timer.
-                // Also timer callback can fire even after timer cancellation if it was queued before cancellation.
-                if (this.opsCountSinceNoop !== 0) {
-                    this.submitNoop(false /* immediate */);
-                }
-            });
-        }
-    }
-
-    /**
-     * Schedules as ack to the server to update the reference sequence number
-     */
-    public scheduleSequenceNumberUpdate(message: ISequencedDocumentMessage, immediateNoOp: boolean): void {
-        // While processing a message, an immediate no-op can be requested.
-        // i.e. to expedite approve or commit phase of quorum.
-        if (immediateNoOp) {
-            this.submitNoop(true /* immediate */);
-            return;
-        }
-
-        // We don't acknowledge no-ops to avoid acknowledgement cycles (i.e. ack the MSN
-        // update, which updates the MSN, then ack the update, etc...).
-        // Intent here is for runtime (and DDSes) not to keep too much tracking state / memory
-        // due to runtime ops from other clients.
-        if (!isRuntimeMessage(message)) {
-            return;
-        }
-
-        this.opsCountSinceNoop++;
-        if (this.opsCountSinceNoop >= this.NoopCountFrequency) {
-            this.submitNoop(false /* immediate */);
-            return;
-        }
-
-        if (this.timer !== undefined) {
-            if (this.opsCountSinceNoop === 1) {
-                this.timer.restart();
-            }
-
-            assert(this.timer.hasTimer, 0x242 /* "has timer" */);
-        }
-    }
-
-    private submitNoop(immediate: boolean) {
-        // Anything other than null is immediate noop
-        this.submit(MessageType.NoOp, immediate ? "" : null);
-        assert(this.opsCountSinceNoop === 0,
-            0x243 /* "stopSequenceNumberUpdate should be called as result of sending any op!" */);
-    }
-
-    public stopSequenceNumberUpdate(): void {
-        this.opsCountSinceNoop = 0;
-        // Ideally, we cancel timer here. But that will result in too often set/reset cycle if this client
-        // keeps sending ops. In most cases it's actually better to let it expire (at most - 4 times per second)
-        // for nothing, then have a ton of set/reset cycles.
-        // Note that Timer.restart() is smart and will not change timer expiration if we keep extending timer
-        // expiration - it will restart the timer instead when it fires with adjusted expiration.
-        // this.timer.clear();
-    }
-}

package/src/deltaManagerProxy.ts

@@ -1,158 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import {
-    IDeltaManager,
-    IDeltaManagerEvents,
-    IDeltaQueue,
-    IDeltaSender,
-    IDeltaQueueEvents,
-    ReadOnlyInfo,
-} from "@fluidframework/container-definitions";
-import { EventForwarder } from "@fluidframework/common-utils";
-import {
-    IClientConfiguration,
-    IClientDetails,
-    IDocumentMessage,
-    ISequencedDocumentMessage,
-    ISignalMessage,
-} from "@fluidframework/protocol-definitions";
-
-/**
- * Proxy to the real IDeltaQueue - used to restrict access
- */
-export class DeltaQueueProxy<T> extends EventForwarder<IDeltaQueueEvents<T>> implements IDeltaQueue<T> {
-    public get paused(): boolean {
-        return this.queue.paused;
-    }
-
-    public get length(): number {
-        return this.queue.length;
-    }
-
-    public get idle(): boolean {
-        return this.queue.idle;
-    }
-
-    constructor(private readonly queue: IDeltaQueue<T>) {
-        super(queue);
-    }
-
-    public peek(): T | undefined {
-        return this.queue.peek();
-    }
-
-    public toArray(): T[] {
-        return this.queue.toArray();
-    }
-
-    // back-compat: usage removed in 0.33, remove in future versions
-    public async systemPause(): Promise<void> {
-        return this.pause();
-    }
-
-    public async pause(): Promise<void> {
-        return this.queue.pause();
-    }
-
-    // back-compat: usage removed in 0.33, remove in future versions
-    public async systemResume(): Promise<void> {
-        return this.resume();
-    }
-
-    public async resume(): Promise<void> {
-        this.queue.resume();
-    }
-
-    public async waitTillProcessingDone() {
-        return this.queue.waitTillProcessingDone();
-    }
-}
-
-/**
- * Proxy to the real IDeltaManager - used to restrict access
- */
-export class DeltaManagerProxy
-    extends EventForwarder<IDeltaManagerEvents>
-    implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage> {
-    public readonly inbound: IDeltaQueue<ISequencedDocumentMessage>;
-    public readonly outbound: IDeltaQueue<IDocumentMessage[]>;
-    public readonly inboundSignal: IDeltaQueue<ISignalMessage>;
-
-    public get IDeltaSender(): IDeltaSender {
-        return this;
-    }
-
-    public get minimumSequenceNumber(): number {
-        return this.deltaManager.minimumSequenceNumber;
-    }
-
-    public get lastSequenceNumber(): number {
-        return this.deltaManager.lastSequenceNumber;
-    }
-
-    public get lastMessage() {
-        return this.deltaManager.lastMessage;
-    }
-
-    public get lastKnownSeqNumber() {
-        return this.deltaManager.lastKnownSeqNumber;
-    }
-
-    public get initialSequenceNumber(): number {
-        return this.deltaManager.initialSequenceNumber;
-    }
-
-    public get hasCheckpointSequenceNumber() {
-        return this.deltaManager.hasCheckpointSequenceNumber;
-    }
-
-    public get clientDetails(): IClientDetails {
-        return this.deltaManager.clientDetails;
-    }
-
-    public get version(): string {
-        return this.deltaManager.version;
-    }
-
-    public get maxMessageSize(): number {
-        return this.deltaManager.maxMessageSize;
-    }
-
-    public get serviceConfiguration(): IClientConfiguration | undefined {
-        return this.deltaManager.serviceConfiguration;
-    }
-
-    public get active(): boolean {
-        return this.deltaManager.active;
-    }
-
-    public get readOnlyInfo(): ReadOnlyInfo {
-        return this.deltaManager.readOnlyInfo;
-    }
-
-    constructor(private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
-        super(deltaManager);
-
-        this.inbound = new DeltaQueueProxy(deltaManager.inbound);
-        this.outbound = new DeltaQueueProxy(deltaManager.outbound);
-        this.inboundSignal = new DeltaQueueProxy(deltaManager.inboundSignal);
-    }
-
-    public dispose(): void {
-        this.inbound.dispose();
-        this.outbound.dispose();
-        this.inboundSignal.dispose();
-        super.dispose();
-    }
-
-    public submitSignal(content: any): void {
-        return this.deltaManager.submitSignal(content);
-    }
-
-    public flush(): void {
-        return this.deltaManager.flush();
-    }
-}

package/tsconfig.esnext.json

@@ -1,7 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "./lib",
-        "module": "esnext"
-    },
-}