@fluidframework/container-runtime 0.56.0 → 0.57.0-51086

package/src/dataStore.ts

@@ -0,0 +1,187 @@
+/*!
+ * 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 { IFluidRouter, IRequest, IResponse } from "@fluidframework/core-interfaces";
+import { 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";
+};
+
+/**
+ * Encapsulates the return codes of the aliasing API
+ */
+export enum AliasResult {
+    /**
+     * The datastore has been successfully aliased
+     */
+    Success = "Success",
+    /**
+     * There is already a datastore bound to the provided alias
+     */
+    Conflict = "Conflict",
+    /**
+     * The datastore is currently in the process of being aliased
+     */
+    Aliasing = "Aliasing",
+    /**
+     * The datastore has been attempted to be aliased before
+     */
+    AlreadyAliased = "AlreadyAliased",
+}
+
+/**
+ * A fluid router with the capability of being assigned an alias
+ */
+ export interface IDataStore extends IFluidRouter {
+    /**
+     * Attempt to assign an alias to the datastore.
+     * If the operation succeeds, the datastore can be referenced
+     * by the supplied alias.
+     *
+     * @param alias - Given alias for this datastore.
+     */
+    trySetAlias(alias: string): Promise<AliasResult>;
+}
+
+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 AliasResult.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 ? AliasResult.Success : AliasResult.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 ? AliasResult.Success : AliasResult.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 ? AliasResult.Success : AliasResult.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

@@ -750,7 +750,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;
 

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,11 @@ 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, packagePath?: readonly string[]) => void,
         private readonly aliasMap: Map<string, string>,
         private readonly writeGCDataAtRoot: boolean,
         private readonly contexts: DataStoreContexts = new DataStoreContexts(baseLogger),
@@ -290,7 +266,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 +387,7 @@ 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}`, context.isLoaded ? context.packagePath : undefined);
     }
 
     public async getDataStore(id: string, wait: boolean): Promise<FluidDataStoreContext> {
@@ -582,9 +558,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 +572,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 +603,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, "Data store with given id does not exist");
+        return context.isLoaded ? context.packagePath : undefined;
+    }
 }
 
 export function getSummaryForDatastores(