Container Rehydration from a snapshot taken from detached container.

packages/dds/cell/src/cell.ts

@@ -202,7 +202,7 @@ export class SharedCell<T extends Serializable = any> extends SharedObject<IShar
      * @returns - promise that resolved when the load is completed
      */
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService): Promise<void> {
         const rawContent = await storage.read(snapshotFileName);
 

packages/dds/cell/src/cellFactory.ts

@@ -8,6 +8,7 @@ import {
     IFluidDataStoreRuntime,
     IChannelServices,
     IChannelFactory,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { SharedCell } from "./cell";
 import { ISharedCell } from "./interfaces";
@@ -44,6 +45,17 @@ export class CellFactory implements IChannelFactory {
         return cell;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedCell> {
+        const cell = new SharedCell(id, runtime, attributes);
+        await cell.loadLocal(objectStorage);
+        return cell;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): ISharedCell {
         const cell = new SharedCell(id, document, this.attributes);
         cell.initializeLocal();

packages/dds/counter/src/counter.ts

@@ -135,7 +135,7 @@ export class SharedCounter extends SharedObject<ISharedCounterEvents> implements
      * @returns - promise that resolved when the load is completed
      */
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService): Promise<void> {
         const rawContent = await storage.read(snapshotFileName);
 

packages/dds/counter/src/counterFactory.ts

@@ -8,6 +8,7 @@ import {
     IFluidDataStoreRuntime,
     IChannelServices,
     IChannelFactory,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { SharedCounter } from "./counter";
 import { ISharedCounter } from "./interfaces";
@@ -44,6 +45,17 @@ export class CounterFactory implements IChannelFactory {
         return counter;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedCounter> {
+        const counter = new SharedCounter(id, runtime, attributes);
+        await counter.loadLocal(objectStorage);
+        return counter;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): ISharedCounter {
         const counter = new SharedCounter(id, document, this.attributes);
         counter.initializeLocal();

packages/dds/ink/src/ink.ts

@@ -154,7 +154,7 @@ export class Ink extends SharedObject<IInkEvents> implements IInk {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
      */
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService,
     ): Promise<void> {
         const header = await storage.read(snapshotFileName);

packages/dds/ink/src/inkFactory.ts

@@ -8,6 +8,7 @@ import {
     IFluidDataStoreRuntime,
     IChannelServices,
     IChannelFactory,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { ISharedObject } from "@fluidframework/shared-object-base";
 import { Ink } from "./ink";
@@ -61,6 +62,20 @@ export class InkFactory implements IChannelFactory {
         return ink;
     }
 
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#IChannelFactory.loadLocal}
+     */
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedObject> {
+        const ink = new Ink(runtime, id, attributes);
+        await ink.loadLocal(objectStorage);
+        return ink;
+    }
+
     /**
      * {@inheritDoc @fluidframework/shared-object-base#IChannelFactory.create}
      */

packages/dds/map/src/directory.ts

@@ -343,6 +343,21 @@ export class DirectoryFactory {
         return directory;
     }
 
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#IChannelFactory.loadLocal}
+     */
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedDirectory> {
+        const directory = new SharedDirectory(id, runtime, attributes);
+        await directory.loadLocal(objectStorage);
+
+        return directory;
+    }
+
     /**
      * {@inheritDoc @fluidframework/shared-object-base#IChannelFactory.create}
      */
@@ -653,7 +668,7 @@ export class SharedDirectory extends SharedObject<ISharedDirectoryEvents> implem
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
      */
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService) {
         const header = await storage.read(snapshotFileName);
         const data = JSON.parse(fromBase64ToUtf8(header));

packages/dds/map/src/map.ts

@@ -86,6 +86,21 @@ export class MapFactory implements IChannelFactory {
         return map;
     }
 
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#IChannelFactory.loadLocal}
+     */
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedMap> {
+        const map = new SharedMap(id, runtime, attributes);
+        await map.loadLocal(objectStorage);
+
+        return map;
+    }
+
     /**
    * {@inheritDoc @fluidframework/shared-object-base#IChannelFactory.create}
    */
@@ -321,7 +336,7 @@ export class SharedMap extends SharedObject<ISharedMapEvents> implements IShared
    * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
    */
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService) {
         const header = await storage.read(snapshotFileName);
 

packages/dds/matrix/src/matrix.ts

@@ -462,7 +462,7 @@ export class SharedMatrix<T extends Serializable = Serializable>
         debug(`${this.id} is now disconnected`);
     }
 
-    protected async loadCore(branchId: string, storage: IChannelStorageService) {
+    protected async loadCore(branchId: string | undefined, storage: IChannelStorageService) {
         try {
             await this.rows.load(this.runtime, new ObjectStoragePartition(storage, SnapshotPath.rows), branchId);
             await this.cols.load(this.runtime, new ObjectStoragePartition(storage, SnapshotPath.cols), branchId);

packages/dds/matrix/src/runtime.ts

@@ -9,6 +9,7 @@ import {
     IChannelServices,
     IChannel,
     IChannelFactory,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { pkgVersion } from "./packageVersion";
 import { SharedMatrix } from "./matrix";
@@ -42,6 +43,17 @@ export class SharedMatrixFactory implements IChannelFactory {
         return matrix;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<IChannel> {
+        const matrix = new SharedMatrix(runtime, id, attributes);
+        await matrix.loadLocal(objectStorage);
+        return matrix;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): IChannel {
         const matrix = new SharedMatrix(document, id, this.attributes);
         matrix.initializeLocal();

packages/dds/merge-tree/package.json

@@ -54,6 +54,7 @@
     "@fluidframework/common-definitions": "^0.18.1",
     "@fluidframework/common-utils": "^0.21.0",
     "@fluidframework/component-core-interfaces": "^0.25.0",
+    "@fluidframework/container-definitions": "^0.25.0",
     "@fluidframework/datastore-definitions": "^0.25.0",
     "@fluidframework/protocol-definitions": "^0.1010.0",
     "@fluidframework/telemetry-utils": "^0.25.0"

packages/dds/merge-tree/src/snapshotLoader.ts

@@ -9,6 +9,7 @@ import { ChildLogger } from "@fluidframework/telemetry-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { IFluidDataStoreRuntime, IChannelStorageService } from "@fluidframework/datastore-definitions";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { AttachState } from "@fluidframework/container-definitions";
 import { Client } from "./client";
 import { NonCollabClient, UniversalSequenceNumber } from "./constants";
 import { ISegment, MergeTree } from "./mergeTree";
@@ -139,11 +140,10 @@ export class SnapshotLoader {
         // a snapshot in any case (summary or attach message)
         // once we get a client id this will be called with that
         // clientId in the connected event
-        // TODO: this won't support rehydrating a detached container
-        // we need to think more holistically about the dds state machine
-        // now that we differentiate attached vs local
+        // However if we load a detached container from snapshot, then we don't supply a default clientId
+        // because we don't want to start collaboration.
         this.client.startOrUpdateCollaboration(
-            this.runtime.clientId ?? "snapshot",
+            this.runtime.attachState === AttachState.Detached ? undefined : this.runtime.clientId ?? "snapshot",
 
             // TODO: Make 'minSeq' non-optional once the new snapshot format becomes the default?
             //       (See https://github.com/microsoft/FluidFramework/issues/84)

packages/dds/ordered-collection/src/consensusOrderedCollection.ts

@@ -273,7 +273,7 @@ export class ConsensusOrderedCollection<T = any>
     }
 
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService): Promise<void> {
         assert(this.jobTracking.size === 0);
         const rawContentTracking = await storage.read(snapshotFileNameTracking);

packages/dds/ordered-collection/src/consensusOrderedCollectionFactory.ts

@@ -7,6 +7,7 @@ import {
     IChannelAttributes,
     IFluidDataStoreRuntime,
     IChannelServices,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { ConsensusQueue } from "./consensusQueue";
 import { IConsensusOrderedCollection, IConsensusOrderedCollectionFactory } from "./interfaces";
@@ -43,6 +44,17 @@ export class ConsensusQueueFactory implements IConsensusOrderedCollectionFactory
         return collection;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<IConsensusOrderedCollection> {
+        const collection = new ConsensusQueue(id, runtime, attributes);
+        await collection.loadLocal(objectStorage);
+        return collection;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): IConsensusOrderedCollection {
         const collection = new ConsensusQueue(id, document, this.attributes);
         collection.initializeLocal();

packages/dds/register-collection/src/consensusRegisterCollection.ts

@@ -210,7 +210,7 @@ export class ConsensusRegisterCollection<T>
     }
 
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService,
     ): Promise<void> {
         const header = await storage.read(snapshotFileName);

packages/dds/register-collection/src/consensusRegisterCollectionFactory.ts

@@ -7,6 +7,7 @@ import {
     IChannelAttributes,
     IFluidDataStoreRuntime,
     IChannelServices,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { ConsensusRegisterCollection } from "./consensusRegisterCollection";
 import { IConsensusRegisterCollection, IConsensusRegisterCollectionFactory } from "./interfaces";
@@ -43,6 +44,17 @@ export class ConsensusRegisterCollectionFactory implements IConsensusRegisterCol
         return collection;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<IConsensusRegisterCollection> {
+        const collection = new ConsensusRegisterCollection(id, runtime, attributes);
+        await collection.loadLocal(objectStorage);
+        return collection;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): IConsensusRegisterCollection {
         const collection = new ConsensusRegisterCollection(id, document, ConsensusRegisterCollectionFactory.Attributes);
         collection.initializeLocal();

packages/dds/sequence/src/sequence.ts

@@ -487,7 +487,7 @@ export abstract class SharedSegmentSequence<T extends MergeTree.ISegment>
     }
 
     protected async loadCore(
-        branchId: string,
+        branchId: string | undefined,
         storage: IChannelStorageService) {
         const header = await storage.read(snapshotFileName);
 

packages/dds/sequence/src/sequenceFactory.ts

@@ -9,6 +9,7 @@ import {
     IFluidDataStoreRuntime,
     IChannelServices,
     IChannelFactory,
+    IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import { ISharedObject } from "@fluidframework/shared-object-base";
 import { pkgVersion } from "./packageVersion";
@@ -55,6 +56,17 @@ export class SharedStringFactory implements IChannelFactory {
         return sharedString;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<SharedString> {
+        const sharedString = new SharedString(runtime, id, attributes);
+        await sharedString.loadLocal(objectStorage);
+        return sharedString;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): SharedString {
         const sharedString = new SharedString(document, id, this.attributes);
         sharedString.initializeLocal();
@@ -101,6 +113,17 @@ export class SharedObjectSequenceFactory implements IChannelFactory {
         return sharedSeq;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedObject> {
+        const sharedSeq = new SharedObjectSequence<object>(runtime, id, attributes);
+        await sharedSeq.loadLocal(objectStorage);
+        return sharedSeq;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): ISharedObject {
         const sharedString = new SharedObjectSequence(document, id, this.attributes);
         sharedString.initializeLocal();
@@ -147,6 +170,17 @@ export class SharedNumberSequenceFactory implements IChannelFactory {
         return sharedSeq;
     }
 
+    public async loadLocal(
+        runtime: IFluidDataStoreRuntime,
+        id: string,
+        objectStorage: IChannelStorageService,
+        attributes: IChannelAttributes,
+    ): Promise<ISharedObject> {
+        const sharedSeq = new SharedNumberSequence(runtime, id, attributes);
+        await sharedSeq.loadLocal(objectStorage);
+        return sharedSeq;
+    }
+
     public create(document: IFluidDataStoreRuntime, id: string): ISharedObject {
         const sharedString = new SharedNumberSequence(document, id, this.attributes);
         sharedString.initializeLocal();