@fluidframework/container-runtime 0.59.4000-71130 → 1.0.0

package/src/pendingStateManager.ts

@@ -5,13 +5,15 @@
 
 import { IDisposable } from "@fluidframework/common-definitions";
 import { assert, Lazy } from "@fluidframework/common-utils";
+import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { DataProcessingError } from "@fluidframework/container-utils";
 import {
     ISequencedDocumentMessage,
 } from "@fluidframework/protocol-definitions";
 import { FlushMode } from "@fluidframework/runtime-definitions";
+import { wrapError } from "@fluidframework/telemetry-utils";
 import Deque from "double-ended-queue";
-import { ContainerRuntime, ContainerMessageType, isRuntimeMessage } from "./containerRuntime";
+import { ContainerMessageType } from "./containerRuntime";
 
 /**
  * This represents a message that has been submitted and is added to the pending queue when `submit` is called on the
@@ -47,16 +49,31 @@ export interface IPendingFlush {
 export type IPendingState = IPendingMessage | IPendingFlushMode | IPendingFlush;
 
 export interface IPendingLocalState {
-    /**
-     * client ID we most recently connected with, or undefined if we never connected
-     */
-    clientId?: string;
     /**
      * list of pending states, including ops and batch information
      */
     pendingStates: IPendingState[];
 }
 
+export interface IRuntimeStateHandler{
+    connected(): boolean;
+    clientId(): string | undefined;
+    flushMode(): FlushMode;
+    setFlushMode(mode: FlushMode): void;
+    close(error?: ICriticalContainerError): void;
+    applyStashedOp: (type: ContainerMessageType, content: ISequencedDocumentMessage) => Promise<unknown>;
+    flush(): void;
+    reSubmit(
+        type: ContainerMessageType,
+        content: any,
+        localOpMetadata: unknown,
+        opMetadata: Record<string, unknown> | undefined): void;
+    rollback(
+        type: ContainerMessageType,
+        content: any,
+        localOpMetadata: unknown): void;
+}
+
 /**
  * PendingStateManager is responsible for maintaining the messages that have not been sent or have not yet been
  * acknowledged by the server. It also maintains the batch information for both automatically and manually flushed
@@ -69,15 +86,16 @@ export interface IPendingLocalState {
 export class PendingStateManager implements IDisposable {
     private readonly pendingStates = new Deque<IPendingState>();
     private readonly initialStates: Deque<IPendingState>;
-    private readonly previousClientIds = new Set<string>();
-    private readonly firstStashedCSN: number = -1;
     private readonly disposeOnce = new Lazy<void>(() => {
         this.initialStates.clear();
         this.pendingStates.clear();
     });
 
     // Maintains the count of messages that are currently unacked.
-    private pendingMessagesCount: number = 0;
+    private _pendingMessagesCount: number = 0;
+    public get pendingMessagesCount(): number {
+        return this._pendingMessagesCount;
+    }
 
     // Indicates whether we are processing a batch.
     private isProcessingBatch: boolean = false;
@@ -95,22 +113,18 @@ export class PendingStateManager implements IDisposable {
 
     private clientId: string | undefined;
 
-    private get connected(): boolean {
-        return this.containerRuntime.connected;
-    }
-
     /**
      * Called to check if there are any pending messages in the pending state queue.
      * @returns A boolean indicating whether there are messages or not.
      */
     public hasPendingMessages(): boolean {
-        return this.pendingMessagesCount !== 0;
+        return this._pendingMessagesCount !== 0 || !this.initialStates.isEmpty();
     }
 
     public getLocalState(): IPendingLocalState | undefined {
+        assert(this.initialStates.isEmpty(), 0x2e9 /* "Must call getLocalState() after applying initial states" */);
         if (this.hasPendingMessages()) {
             return {
-                clientId: this.clientId,
                 pendingStates: this.pendingStates.toArray().map(
                     // delete localOpMetadata since it may not be serializable
                     // and will be regenerated by applyStashedOp()
@@ -120,23 +134,12 @@ export class PendingStateManager implements IDisposable {
     }
 
     constructor(
-        private readonly containerRuntime: ContainerRuntime,
-        private readonly applyStashedOp: (type, content) => Promise<unknown>,
+        private readonly stateHandler: IRuntimeStateHandler,
         initialFlushMode: FlushMode,
         initialLocalState: IPendingLocalState | undefined,
     ) {
         this.initialStates = new Deque<IPendingState>(initialLocalState?.pendingStates ?? []);
 
-        if (initialLocalState) {
-            if (initialLocalState?.clientId) {
-                this.previousClientIds.add(initialLocalState.clientId);
-            }
-            // get stashed op count and client sequence number of first op
-            const messages = initialLocalState.pendingStates
-                .filter((state) => state.type === "message") as IPendingMessage[];
-            this.firstStashedCSN = messages[0].clientSequenceNumber;
-        }
-
         this.flushModeForNextMessage = initialFlushMode;
         this.onFlushModeUpdated(initialFlushMode);
     }
@@ -172,7 +175,7 @@ export class PendingStateManager implements IDisposable {
 
         this.pendingStates.push(pendingMessage);
 
-        this.pendingMessagesCount++;
+        this._pendingMessagesCount++;
     }
 
     /**
@@ -189,7 +192,7 @@ export class PendingStateManager implements IDisposable {
     public onFlush() {
         // If the FlushMode is Immediate, we don't need to track an explicit flush call because every message is
         // automatically flushed. So, flush is a no-op.
-        if (this.containerRuntime.flushMode === FlushMode.Immediate) {
+        if (this.stateHandler.flushMode() === FlushMode.Immediate) {
             return;
         }
 
@@ -205,21 +208,25 @@ export class PendingStateManager implements IDisposable {
 
     /**
      * Applies stashed ops at their reference sequence number so they are ready to be ACKed or resubmitted
+     * @param seqNum - Sequence number at which to apply ops. Will apply all ops if seqNum is undefined.
      */
-    public async applyStashedOpsAt(seqNum: number) {
+    public async applyStashedOpsAt(seqNum?: number) {
         // apply stashed ops at sequence number
         while (!this.initialStates.isEmpty()) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const nextState = this.initialStates.peekFront()!;
             if (nextState.type === "message") {
-                if (nextState.referenceSequenceNumber > seqNum) {
-                    break; // nothing left to do at this sequence number
-                } else if (nextState.referenceSequenceNumber > 0 && nextState.referenceSequenceNumber < seqNum) {
-                    throw new Error("loaded from snapshot too recent to apply stashed ops");
+                if (seqNum !== undefined) {
+                    if (nextState.referenceSequenceNumber > seqNum) {
+                        break; // nothing left to do at this sequence number
+                    } else if (nextState.referenceSequenceNumber < seqNum) {
+                        throw new Error("loaded from snapshot too recent to apply stashed ops");
+                    }
                 }
 
                 // applyStashedOp will cause the DDS to behave as if it has sent the op but not actually send it
-                const localOpMetadata = await this.applyStashedOp(nextState.messageType, nextState.content);
+                const localOpMetadata =
+                    await this.stateHandler.applyStashedOp(nextState.messageType, nextState.content);
                 nextState.localOpMetadata = localOpMetadata;
             }
 
@@ -229,88 +236,12 @@ export class PendingStateManager implements IDisposable {
         }
     }
 
-    /**
-     * Processes a local message once it's ack'd by the server to verify that there was no data corruption and that
-     * the batch information was preserved for batch messages. Also process remote messages that might have been
-     * sent from a previous container.
-     * @param message - The message that got ack'd and needs to be processed.
-     */
-    public processMessage(message: ISequencedDocumentMessage, local: boolean) {
-        // Do not process chunked ops until all pieces are available.
-        if (message.type === ContainerMessageType.ChunkedOp) {
-            return { localAck: false, localOpMetadata: undefined };
-        }
-
-        if (local) {
-            return { localAck: false, localOpMetadata: this.processPendingLocalMessage(message) };
-        } else {
-            return this.processRemoteMessage(message);
-        }
-    }
-
-    /**
-     * Listens for ACKs of stashed ops
-     */
-    private processRemoteMessage(message: ISequencedDocumentMessage) {
-        if (!isRuntimeMessage(message)) {
-            return { localAck: false, localOpMetadata: undefined };
-        }
-
-        // this message was a pending op that was actually sent successfully
-        const isOriginalClientId = message.clientId === Array.from(this.previousClientIds)[0] &&
-            message.clientSequenceNumber >= this.firstStashedCSN;
-        // this message is a pending or stashed op that was resubmitted
-        const isNewClientId = Array.from(this.previousClientIds).indexOf(message.clientId) > 0;
-
-        // if this is an ack for a stashed op, dequeue one message.
-        // we should have seen its ref seq num by now and the DDS should be ready for it to be ACKed
-        if (isOriginalClientId || isNewClientId) {
-            assert(this.clientId === undefined, 0x28b /* "multiple clients connected with stashed ops" */);
-            while (!this.pendingStates.isEmpty()) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const nextState = this.pendingStates.shift()!;
-                // if it's not a message just drop it and keep looking
-                if (nextState.type === "message") {
-                    this.assertOpMatch(nextState, message, isOriginalClientId);
-                    return { localAck: true, localOpMetadata: nextState.localOpMetadata };
-                }
-            }
-        }
-
-        if (message.type === ContainerMessageType.Rejoin && this.previousClientIds.has(message.contents?.clientId)) {
-            this.previousClientIds.add(message.clientId);
-        }
-
-        return { localAck: false, localOpMetadata: undefined };
-    }
-
-    private assertOpMatch(state: IPendingMessage, message: ISequencedDocumentMessage, isOriginalClientId: boolean) {
-        assert(message.type === state.messageType, 0x28c /* "different message type" */);
-        assert(message.clientSequenceNumber === state.clientSequenceNumber || !isOriginalClientId,
-            0x28d /* "client sequence number doesn't match" */);
-        switch (message.type) {
-            case ContainerMessageType.Attach:
-                assert(message.contents.id === state.content.id, 0x28e /* "datastore ID doesn't match" */);
-                break;
-            case ContainerMessageType.FluidDataStoreOp:
-                assert(message.contents.address === state.content.address, 0x28f /* "address doesn't match" */);
-                break;
-            case ContainerMessageType.BlobAttach:
-                // todo: assert we have blob storage, assert blob IDs match, remove blob from blob storage since it made
-                // it through successfully
-                break;
-            case ContainerMessageType.Rejoin:
-            default:
-                throw new Error(`${message.type} not expected`);
-        }
-    }
-
     /**
      * Processes a local message once its ack'd by the server. It verifies that there was no data corruption and that
      * the batch information was preserved for batch messages.
      * @param message - The message that got ack'd and needs to be processed.
      */
-    private processPendingLocalMessage(message: ISequencedDocumentMessage): unknown {
+    public processPendingLocalMessage(message: ISequencedDocumentMessage): unknown {
         // Pre-processing part - This may be the start of a batch.
         this.maybeProcessBatchBegin(message);
 
@@ -330,11 +261,11 @@ export class PendingStateManager implements IDisposable {
                 { expectedClientSequenceNumber: pendingState.clientSequenceNumber },
             );
 
-            this.containerRuntime.closeFn(error);
+            this.stateHandler.close(error);
             return;
         }
 
-        this.pendingMessagesCount--;
+        this._pendingMessagesCount--;
 
         // Post-processing part - If we are processing a batch then this could be the last message in the batch.
         this.maybeProcessBatchEnd(message);
@@ -446,6 +377,31 @@ export class PendingStateManager implements IDisposable {
         this.isProcessingBatch = false;
     }
 
+    /**
+     * Capture the pending state at this point
+     */
+    public checkpoint() {
+        const checkpointHead = this.pendingStates.peekBack();
+        return {
+            rollback: () => {
+                try {
+                    while (this.pendingStates.peekBack() !== checkpointHead) {
+                        this.rollbackNextPendingState();
+                    }
+                } catch (err) {
+                    const error = wrapError(err, (message) => {
+                        return DataProcessingError.create(
+                            `RollbackError: ${message}`,
+                            "checkpointRollback",
+                            undefined) as DataProcessingError;
+                    });
+                    this.stateHandler.close(error);
+                    throw error;
+                }
+            },
+        };
+    }
+
     /**
      * Returns the next pending state from the pending state queue.
      */
@@ -455,17 +411,42 @@ export class PendingStateManager implements IDisposable {
         return nextPendingState;
     }
 
+    /**
+     * Undo the last pending state
+     */
+    private rollbackNextPendingState() {
+        const pendingStatesCount = this.pendingStates.length;
+        if (pendingStatesCount === 0) {
+            return;
+        }
+
+        this._pendingMessagesCount--;
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const pendingState = this.pendingStates.pop()!;
+        switch (pendingState.type) {
+            case "message":
+                this.stateHandler.rollback(
+                    pendingState.messageType,
+                    pendingState.content,
+                    pendingState.localOpMetadata);
+                break;
+            default:
+                throw new Error(`Can't rollback state ${pendingState.type}`);
+        }
+    }
+
     /**
      * Called when the Container's connection state changes. If the Container gets connected, it replays all the pending
      * states in its queue. This includes setting the FlushMode and triggering resubmission of unacked ops.
      */
     public replayPendingStates() {
-        assert(this.connected, 0x172 /* "The connection state is not consistent with the runtime" */);
+        assert(this.stateHandler.connected(), 0x172 /* "The connection state is not consistent with the runtime" */);
 
         // This assert suggests we are about to send same ops twice, which will result in data loss.
-        assert(this.clientId !== this.containerRuntime.clientId,
+        assert(this.clientId !== this.stateHandler.clientId(),
             0x173 /* "replayPendingStates called twice for same clientId!" */);
-        this.clientId = this.containerRuntime.clientId;
+        this.clientId = this.stateHandler.clientId();
 
         assert(this.initialStates.isEmpty(), 0x174 /* "initial states should be empty before replaying pending" */);
 
@@ -475,14 +456,14 @@ export class PendingStateManager implements IDisposable {
         }
 
         // Reset the pending message count because all these messages will be removed from the queue.
-        this.pendingMessagesCount = 0;
+        this._pendingMessagesCount = 0;
 
         // Save the current FlushMode so that we can revert it back after replaying the states.
-        const savedFlushMode = this.containerRuntime.flushMode;
+        const savedFlushMode = this.stateHandler.flushMode();
 
         // Set the flush mode for the next message. This step is important because the flush mode may have been changed
         // after the next pending message was sent.
-        this.containerRuntime.setFlushMode(this.flushModeForNextMessage);
+        this.stateHandler.setFlushMode(this.flushModeForNextMessage);
 
         // Process exactly `pendingStatesCount` items in the queue as it represents the number of states that were
         // pending when we connected. This is important because the `reSubmitFn` might add more items in the queue
@@ -492,17 +473,17 @@ export class PendingStateManager implements IDisposable {
             const pendingState = this.pendingStates.shift()!;
             switch (pendingState.type) {
                 case "message":
-                    this.containerRuntime.reSubmitFn(
+                    this.stateHandler.reSubmit(
                         pendingState.messageType,
                         pendingState.content,
                         pendingState.localOpMetadata,
                         pendingState.opMetadata);
                     break;
                 case "flushMode":
-                    this.containerRuntime.setFlushMode(pendingState.flushMode);
+                    this.stateHandler.setFlushMode(pendingState.flushMode);
                     break;
                 case "flush":
-                    this.containerRuntime.flush();
+                    this.stateHandler.flush();
                     break;
                 default:
                     break;
@@ -511,6 +492,6 @@ export class PendingStateManager implements IDisposable {
         }
 
         // Revert the FlushMode.
-        this.containerRuntime.setFlushMode(savedFlushMode);
+        this.stateHandler.setFlushMode(savedFlushMode);
     }
 }

package/src/runningSummarizer.ts

@@ -8,17 +8,18 @@ import { assert, delay, Deferred, PromiseTimer } from "@fluidframework/common-ut
 import { UsageError } from "@fluidframework/container-utils";
 import {
     ISequencedDocumentMessage,
-    ISummaryConfiguration,
     MessageType,
 } from "@fluidframework/protocol-definitions";
 import { ChildLogger } from "@fluidframework/telemetry-utils";
+import {
+    ISummaryConfiguration,
+} from "./containerRuntime";
 import { SummarizeHeuristicRunner } from "./summarizerHeuristics";
 import {
     IEnqueueSummarizeOptions,
     ISummarizeOptions,
     ISummarizeHeuristicData,
     ISummarizeHeuristicRunner,
-    ISummarizerOptions,
     IOnDemandSummarizeOptions,
     EnqueueSummarizeResult,
     SummarizerStopReason,
@@ -57,7 +58,6 @@ export class RunningSummarizer implements IDisposable {
         summaryCollection: SummaryCollection,
         cancellationToken: ISummaryCancellationToken,
         stopSummarizerCallback: (reason: SummarizerStopReason) => void,
-        options?: Readonly<Partial<ISummarizerOptions>>,
     ): Promise<RunningSummarizer> {
         const summarizer = new RunningSummarizer(
             logger,
@@ -68,8 +68,7 @@ export class RunningSummarizer implements IDisposable {
             raiseSummarizingError,
             summaryCollection,
             cancellationToken,
-            stopSummarizerCallback,
-            options);
+            stopSummarizerCallback);
 
         await summarizer.waitStart();
 
@@ -107,7 +106,6 @@ export class RunningSummarizer implements IDisposable {
         private readonly summaryCollection: SummaryCollection,
         private readonly cancellationToken: ISummaryCancellationToken,
         private readonly stopSummarizerCallback: (reason: SummarizerStopReason) => void,
-        { disableHeuristics = false }: Readonly<Partial<ISummarizerOptions>> = {},
     ) {
         const telemetryProps: ISummarizeRunnerTelemetry = {
             summarizeCount: () => this.summarizeCount,
@@ -121,15 +119,23 @@ export class RunningSummarizer implements IDisposable {
             },
         );
 
-        if (!disableHeuristics) {
+        if (configuration.state !== "disableHeuristics") {
+            assert(this.configuration.state === "enabled", 0x2ea /* "Configuration state should be enabled" */);
             this.heuristicRunner = new SummarizeHeuristicRunner(
                 heuristicData,
-                configuration,
-                (reason) => this.trySummarize(reason));
+                this.configuration,
+                (reason) => this.trySummarize(reason),
+                this.logger);
         }
 
+        assert(
+            this.configuration.state !== "disabled",
+            0x2eb /* "Summary not supported with configuration disabled" */,
+        );
+
         // Cap the maximum amount of time client will wait for a summarize op ack to maxSummarizeAckWaitTime
         // configuration.maxAckWaitTime is composed from defaults, server values, and runtime overrides
+
         const maxAckWaitTime = Math.min(this.configuration.maxAckWaitTime, maxSummarizeAckWaitTime);
 
         this.pendingAckTimer = new PromiseTimer(
@@ -360,7 +366,11 @@ export class RunningSummarizer implements IDisposable {
                     return;
                 }
 
-                summaryAttempts++;
+                // We only want to attempt 1 summary when reason is "lastSummary"
+                if (++summaryAttempts > 1 && reason === "lastSummary") {
+                    return;
+                }
+
                 summaryAttemptsPerPhase++;
 
                 const { delaySeconds: regularDelaySeconds = 0, ...options } = attempts[summaryAttemptPhase];

package/src/serializedSnapshotStorage.ts

@@ -0,0 +1,146 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert, bufferToString, stringToBuffer } from "@fluidframework/common-utils";
+import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
+import {
+    ICreateBlobResponse,
+    ISnapshotTree,
+    ISummaryHandle,
+    ISummaryTree,
+    IVersion,
+} from "@fluidframework/protocol-definitions";
+import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
+
+/**
+ * Serialized blobs from a snapshot. Used to load offline.
+ */
+export interface ISerializedBaseSnapshotBlobs {
+    [id: string]: string;
+}
+
+/**
+ * A storage wrapper that can serialize blobs from a snapshot tree and then use them to rehydrate.
+ * Used in offline load/attached dehydration to save snapshot blobs that are still needed but may have been deleted.
+ */
+export class SerializedSnapshotStorage implements IDocumentStorageService {
+    constructor(
+        private readonly storageGetter: () => IDocumentStorageService,
+        private readonly blobs: ISerializedBaseSnapshotBlobs,
+    ) { }
+
+    public static async serializeTree(
+        snapshot: ISnapshotTree,
+        storage: IDocumentStorageService,
+    ): Promise<ISerializedBaseSnapshotBlobs> {
+        const blobs = {};
+        await this.serializeTreeCore(snapshot, blobs, storage);
+        return blobs;
+    }
+
+    private static async serializeTreeCore(
+        tree: ISnapshotTree,
+        blobs: ISerializedBaseSnapshotBlobs,
+        storage: IDocumentStorageService,
+    ) {
+        const treePs: Promise<any>[] = [];
+        for (const subTree of Object.values(tree.trees)) {
+            treePs.push(this.serializeTreeCore(subTree, blobs, storage));
+        }
+        for (const id of Object.values(tree.blobs)) {
+            const blob = await storage.readBlob(id);
+            // ArrayBufferLike will not survive JSON.stringify()
+            blobs[id] = bufferToString(blob, "utf8");
+        }
+        return Promise.all(treePs);
+    }
+
+    public static serializeTreeWithBlobContents(
+        snapshot: ISnapshotTreeWithBlobContents,
+    ): ISerializedBaseSnapshotBlobs {
+        const blobs = {};
+        this.serializeTreeWithBlobContentsCore(snapshot, blobs);
+        return blobs;
+    }
+
+    private static serializeTreeWithBlobContentsCore(
+        tree: ISnapshotTreeWithBlobContents,
+        blobs: ISerializedBaseSnapshotBlobs,
+    ) {
+        for (const subTree of Object.values(tree.trees)) {
+            this.serializeTreeWithBlobContentsCore(subTree, blobs);
+        }
+        for (const id of Object.values(tree.blobs)) {
+            const blob = tree.blobsContents[id];
+            assert(!!blob, 0x2ec /* "Blob must be present in blobsContents" */);
+            // ArrayBufferLike will not survive JSON.stringify()
+            blobs[id] = bufferToString(blob, "utf8");
+        }
+    }
+
+    private _storage?: IDocumentStorageService;
+    private get storage(): IDocumentStorageService {
+        // avoid calling it until we need it since it will be undefined if we're not connected
+        // and we shouldn't need it in this case anyway
+        if (this._storage) {
+            return this._storage;
+        }
+        this._storage = this.storageGetter();
+        return this._storage;
+    }
+
+    public get repositoryUrl(): string { return this.storage.repositoryUrl; }
+
+    /**
+     * Reads the object with the given ID, returns content in arrayBufferLike
+     */
+    public async readBlob(id: string): Promise<ArrayBufferLike> {
+        if (this.blobs[id] !== undefined) {
+            return stringToBuffer(this.blobs[id], "utf8");
+        }
+        return this.storage.readBlob(id);
+    }
+
+    /**
+     * Returns the snapshot tree.
+     */
+    // eslint-disable-next-line @rushstack/no-new-null
+    public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null> {
+        return this.storage.getSnapshotTree(version);
+    }
+
+    /**
+     * Retrieves all versions of the document starting at the specified versionId - or null if from the head
+     */
+    // eslint-disable-next-line @rushstack/no-new-null
+    public async getVersions(versionId: string | null, count: number): Promise<IVersion[]> {
+        return this.storage.getVersions(versionId, count);
+    }
+
+    /**
+     * Creates a blob out of the given buffer
+     */
+    public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
+        return this.storage.createBlob(file);
+    }
+
+    /**
+     * Uploads a summary tree to storage using the given context for reference of previous summary handle.
+     * The ISummaryHandles in the uploaded tree should have paths to indicate which summary object they are
+     * referencing from the previously acked summary.
+     * Returns the uploaded summary handle.
+     */
+    public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
+        return this.storage.uploadSummaryWithContext(summary, context);
+    }
+
+    /**
+     * Retrieves the commit that matches the packfile handle. If the packfile has already been committed and the
+     * server has deleted it this call may result in a broken promise.
+     */
+    public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
+        return this.storage.downloadSummary(handle);
+    }
+}