@fluidframework/container-runtime 0.56.7 → 0.57.1

package/src/dataStore.ts

@@ -0,0 +1,151 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { unreachableCase } from "@fluidframework/common-utils";
+import { AttachState } from "@fluidframework/container-definitions";
+import { IRequest, IResponse } from "@fluidframework/core-interfaces";
+import { AliasResult, IDataStore, IFluidDataStoreChannel } from "@fluidframework/runtime-definitions";
+import { TelemetryDataTag } from "@fluidframework/telemetry-utils";
+import { ContainerRuntime } from "./containerRuntime";
+import { DataStores } from "./dataStores";
+
+/**
+ * Interface for an op to be used for assigning an
+ * alias to a datastore
+ */
+export interface IDataStoreAliasMessage {
+    /** The internal id of the datastore */
+    readonly internalId: string;
+    /** The alias name to be assigned to the datastore */
+    readonly alias: string;
+}
+
+/**
+ * Type guard that returns true if the given alias message is actually an instance of
+ * a class which implements @see IDataStoreAliasMessage
+ * @param maybeDataStoreAliasMessage - message object to be validated
+ * @returns True if the @see IDataStoreAliasMessage is fully implemented, false otherwise
+ */
+ export const isDataStoreAliasMessage = (
+    maybeDataStoreAliasMessage: any,
+): maybeDataStoreAliasMessage is IDataStoreAliasMessage => {
+    return typeof maybeDataStoreAliasMessage?.internalId === "string"
+        && typeof maybeDataStoreAliasMessage?.alias === "string";
+};
+
+export const channelToDataStore = (
+    fluidDataStoreChannel: IFluidDataStoreChannel,
+    internalId: string,
+    runtime: ContainerRuntime,
+    datastores: DataStores,
+    logger: ITelemetryLogger,
+): IDataStore => new DataStore(fluidDataStoreChannel, internalId, runtime, datastores, logger);
+
+enum AliasState {
+    Aliased = "Aliased",
+    Aliasing = "Aliasing",
+    None = "None",
+}
+
+class DataStore implements IDataStore {
+    private aliasState: AliasState = AliasState.None;
+    private alias: string | undefined;
+
+    async trySetAlias(alias: string): Promise<AliasResult> {
+        switch (this.aliasState) {
+            // If we're already aliasing, throw an exception
+            case AliasState.Aliasing:
+                return "Aliasing";
+            // If this datastore is already aliased, return true only if this
+            // is a repeated call for the same alias
+            case AliasState.Aliased:
+                return this.alias === alias ? "Success" : "AlreadyAliased";
+            // There is no current or past alias operation for this datastore,
+            // it is safe to continue execution
+            case AliasState.None: break;
+            default: unreachableCase(this.aliasState);
+        }
+
+        this.aliasState = AliasState.Aliasing;
+        const message: IDataStoreAliasMessage = {
+            internalId: this.internalId,
+            alias,
+        };
+
+        this.fluidDataStoreChannel.bindToContext();
+
+        if (this.runtime.attachState === AttachState.Detached) {
+            const localResult = this.datastores.processAliasMessageCore(message);
+            // Explicitly Lock-out future attempts of aliasing,
+            // regardless of result
+            this.aliasState = AliasState.Aliased;
+            return localResult ? "Success" : "Conflict";
+        }
+
+        const aliased = await this.ackBasedPromise<boolean>((resolve) => {
+            this.runtime.submitDataStoreAliasOp(message, resolve);
+        }).then((succeeded) => {
+            // Explicitly Lock-out future attempts of aliasing,
+            // regardless of result
+            this.aliasState = AliasState.Aliased;
+            if (succeeded) {
+                this.alias = alias;
+            }
+
+            return succeeded;
+        }).catch((error) => {
+            this.logger.sendErrorEvent({
+                eventName: "AliasingException",
+                alias: {
+                    value: alias,
+                    tag: TelemetryDataTag.UserData,
+                },
+                internalId: {
+                    value: this.internalId,
+                    tag: TelemetryDataTag.PackageData,
+                },
+            }, error);
+            this.aliasState = AliasState.None;
+            return false;
+        });
+
+        return aliased ? "Success" : "Conflict";
+    }
+
+    async request(request: IRequest): Promise<IResponse> {
+        return this.fluidDataStoreChannel.request(request);
+    }
+
+    constructor(
+        private readonly fluidDataStoreChannel: IFluidDataStoreChannel,
+        private readonly internalId: string,
+        private readonly runtime: ContainerRuntime,
+        private datastores: DataStores,
+        private readonly logger: ITelemetryLogger,
+    ) { }
+    public get IFluidRouter() { return this.fluidDataStoreChannel; }
+
+    private async ackBasedPromise<T>(
+        executor: (resolve: (value: T | PromiseLike<T>) => void,
+        reject: (reason?: any) => void) => void,
+    ): Promise<T> {
+        let rejectBecauseDispose: () => void;
+        return new Promise<T>((resolve, reject) => {
+            rejectBecauseDispose =
+                () => reject(new Error("ContainerRuntime disposed while this ack-based Promise was pending"));
+
+            if (this.runtime.disposed) {
+                rejectBecauseDispose();
+                return;
+            }
+
+            this.runtime.on("dispose", rejectBecauseDispose);
+            executor(resolve, reject);
+        }).finally(() => {
+            this.runtime.off("dispose", rejectBecauseDispose);
+        });
+    }
+}

package/src/dataStoreContext.ts

@@ -106,11 +106,6 @@ export function createAttributesBlob(
 
 interface ISnapshotDetails {
     pkg: readonly string[];
-    /**
-     * This tells whether a data store is root. Root data stores are never collected.
-     * Non-root data stores may be collected if they are not used.
-     */
-    isRootDataStore: boolean;
     snapshot?: ISnapshotTree;
 }
 
@@ -212,7 +207,10 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     }
 
     public async isRoot(): Promise<boolean> {
-        return (await this.getInitialSnapshotDetails()).isRootDataStore;
+        // This call updates this.isRootDataStore if it has not yet been updated
+        // The initial value is stored in the initial snapshot of the data store
+        await this.getInitialSnapshotDetails();
+        return this.isRootDataStore;
     }
 
     protected registry: IFluidDataStoreRegistry | undefined;
@@ -225,6 +223,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     protected channelDeferred: Deferred<IFluidDataStoreChannel> | undefined;
     private _baseSnapshot: ISnapshotTree | undefined;
     protected _attachState: AttachState;
+    protected isRootDataStore: boolean = false;
     protected readonly summarizerNode: ISummarizerNodeWithGC;
     private readonly subLogger: ITelemetryLogger;
     private readonly thresholdOpsCounter: ThresholdCounter;
@@ -450,8 +449,8 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         }
 
         // Add data store's attributes to the summary.
-        const { pkg, isRootDataStore } = await this.getInitialSnapshotDetails();
-        const attributes = createAttributes(pkg, isRootDataStore, this.disableIsolatedChannels);
+        const { pkg } = await this.getInitialSnapshotDetails();
+        const attributes = createAttributes(pkg, this.isRootDataStore, this.disableIsolatedChannels);
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
 
         // Add GC data to the summary if it's not written at the root.
@@ -729,7 +728,6 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
 }
 
 export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
-    private isRootDataStore: boolean | undefined;
     private readonly initSnapshotValue: ISnapshotTree | string | undefined;
     private readonly baseGCDetailsP: Promise<IGarbageCollectionDetailsBase>;
 
@@ -750,7 +748,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
         });
     }
 
-    private readonly initialSnapshotDetailsP =  new LazyPromise<ISnapshotDetails>(async () => {
+    private readonly initialSnapshotDetailsP = new LazyPromise<ISnapshotDetails>(async () => {
         let tree: ISnapshotTree | undefined;
         let isRootDataStore = true;
 
@@ -804,11 +802,12 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
             }
         }
 
+        this.isRootDataStore = isRootDataStore;
+
         return {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             pkg: this.pkg!,
             snapshot: tree,
-            isRootDataStore,
         };
     });
 
@@ -846,7 +845,6 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
  */
 export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     private readonly snapshotTree: ISnapshotTree | undefined;
-    protected isRootDataStore: boolean | undefined;
     /**
      * @deprecated 0.16 Issue #1635, #3631
      */
@@ -862,7 +860,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         );
 
         this.snapshotTree = props.snapshotTree;
-        this.isRootDataStore = props.isRootDataStore;
+        this.isRootDataStore = props.isRootDataStore ?? false;
         this.createProps = props.createProps;
         this.attachListeners();
     }
@@ -938,7 +936,6 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         return {
             pkg: this.pkg,
             snapshot,
-            isRootDataStore: this.isRootDataStore,
         };
     }
 

package/src/dataStores.ts

@@ -50,34 +50,10 @@ import {
     LocalDetachedFluidDataStoreContext,
 } from "./dataStoreContext";
 import { IContainerRuntimeMetadata, nonDataStorePaths, rootHasIsolatedChannels } from "./summaryFormat";
-import { IUsedStateStats } from "./garbageCollection";
+import { IDataStoreAliasMessage, isDataStoreAliasMessage } from "./dataStore";
 
 type PendingAliasResolve = (success: boolean) => void;
 
-/**
- * Interface for an op to be used for assigning an
- * alias to a datastore
- */
-interface IDataStoreAliasMessage {
-    /** The internal id of the datastore */
-    readonly internalId: string;
-    /** The alias name to be assigned to the datastore */
-    readonly alias: string;
-}
-
-/**
- * Type guard that returns true if the given alias message is actually an instance of
- * a class which implements @see IDataStoreAliasMessage
- * @param maybeDataStoreAliasMessage - message object to be validated
- * @returns True if the @see IDataStoreAliasMessage is fully implemented, false otherwise
- */
-const isDataStoreAliasMessage = (
-    maybeDataStoreAliasMessage: any,
-): maybeDataStoreAliasMessage is IDataStoreAliasMessage => {
-    return typeof maybeDataStoreAliasMessage?.internalId === "string"
-        && typeof maybeDataStoreAliasMessage?.alias === "string";
-};
-
  /**
   * This class encapsulates data store handling. Currently it is only used by the container runtime,
   * but eventually could be hosted on any channel once we formalize the channel api boundary.
@@ -111,11 +87,12 @@ export class DataStores implements IDisposable {
         private readonly runtime: ContainerRuntime,
         private readonly submitAttachFn: (attachContent: any) => void,
         private readonly getCreateChildSummarizerNodeFn:
-            (id: string, createParam: CreateChildSummarizerNodeParam)  => CreateChildSummarizerNodeFn,
+            (id: string, createParam: CreateChildSummarizerNodeParam) => CreateChildSummarizerNodeFn,
         private readonly deleteChildSummarizerNodeFn: (id: string) => void,
         baseLogger: ITelemetryBaseLogger,
         getBaseGCDetails: () => Promise<Map<string, IGarbageCollectionDetailsBase>>,
-        private readonly dataStoreChanged: (id: string) => void,
+        private readonly dataStoreChanged: (
+            dataStorePath: string, timestampMs: number, packagePath?: readonly string[]) => void,
         private readonly aliasMap: Map<string, string>,
         private readonly writeGCDataAtRoot: boolean,
         private readonly contexts: DataStoreContexts = new DataStoreContexts(baseLogger),
@@ -290,7 +267,7 @@ export class DataStores implements IDisposable {
         }
     }
 
-    private processAliasMessageCore(aliasMessage: IDataStoreAliasMessage): boolean {
+    public processAliasMessageCore(aliasMessage: IDataStoreAliasMessage): boolean {
         if (this.alreadyProcessed(aliasMessage.alias)) {
             return false;
         }
@@ -411,7 +388,11 @@ export class DataStores implements IDisposable {
         context.process(transformed, local, localMessageMetadata);
 
         // Notify that a data store changed. This is used to detect if a deleted data store is being used.
-        this.dataStoreChanged(envelope.address);
+        this.dataStoreChanged(
+            `/${envelope.address}`,
+            message.timestamp,
+            context.isLoaded ? context.packagePath : undefined,
+        );
     }
 
     public async getDataStore(id: string, wait: boolean): Promise<FluidDataStoreContext> {
@@ -582,9 +563,8 @@ export class DataStores implements IDisposable {
      * @param usedRoutes - The routes that are used in all data stores in this Container.
      * @param gcTimestamp - The time when GC was run that generated these used routes. If any node node becomes
      * unreferenced as part of this GC run, this should be used to update the time when it happens.
-     * @returns the statistics of the used state of the data stores.
      */
-    public updateUsedRoutes(usedRoutes: string[], gcTimestamp?: number): IUsedStateStats {
+    public updateUsedRoutes(usedRoutes: string[], gcTimestamp?: number) {
         // Get a map of data store ids to routes used in it.
         const usedDataStoreRoutes = unpackChildNodesUsedRoutes(usedRoutes);
 
@@ -597,13 +577,6 @@ export class DataStores implements IDisposable {
         for (const [contextId, context] of this.contexts) {
             context.updateUsedRoutes(usedDataStoreRoutes.get(contextId) ?? [], gcTimestamp);
         }
-
-        // Return the number of data stores that are unused.
-        const dataStoreCount = this.contexts.size;
-        return {
-            totalNodeCount: dataStoreCount,
-            unusedNodeCount: dataStoreCount - usedDataStoreRoutes.size,
-        };
     }
 
     /**
@@ -635,6 +608,18 @@ export class DataStores implements IDisposable {
         }
         return outboundRoutes;
     }
+
+    /**
+     * Returns the package path of the node with the given path. This is used by GC to log when an inactive / deleted
+     * node is used.
+     */
+    public getNodePackagePath(nodePath: string): readonly string[] | undefined {
+        // Currently, only return the data store package path for the node since GC is only interested in data stores.
+        const dataStoreId = nodePath.split("/")[1];
+        const context = this.contexts.get(dataStoreId);
+        assert(context !== undefined, 0x2b9 /* "Data store with given id does not exist" */);
+        return context.isLoaded ? context.packagePath : undefined;
+    }
 }
 
 export function getSummaryForDatastores(