Support Skipping Context Reload when New Code is Compatible with Old

packages/loader/container-definitions/src/fluidModule.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { IFluidObject } from "@fluidframework/core-interfaces";
+import { IFluidObject, IProvideFluidCodeDetailsComparer } from "@fluidframework/core-interfaces";
 
 export interface IFluidModule {
-    fluidExport: IFluidObject;
+    fluidExport: IFluidObject & Partial<Readonly<IProvideFluidCodeDetailsComparer>>;
 }

packages/loader/container-definitions/src/loader.ts

@@ -3,7 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { IRequest, IResponse, IFluidRouter, IFluidCodeDetails, IFluidPackage } from "@fluidframework/core-interfaces";
+import {
+    IRequest,
+    IResponse,
+    IFluidRouter,
+    IFluidCodeDetails,
+    IFluidPackage,
+    IProvideFluidCodeDetailsComparer,
+} from "@fluidframework/core-interfaces";
 import {
     IClientDetails,
     IDocumentMessage,
@@ -21,7 +28,7 @@ import { AttachState } from "./runtime";
 /**
  * Code loading interface
  */
-export interface ICodeLoader {
+export interface ICodeLoader extends Partial<IProvideFluidCodeDetailsComparer> {
     /**
      * Loads the package specified by code details and returns a promise to its entry point exports.
      */

packages/loader/container-definitions/src/runtime.ts

@@ -9,6 +9,7 @@ import {
     IFluidConfiguration,
     IRequest,
     IResponse,
+    IFluidCodeDetails,
 } from "@fluidframework/core-interfaces";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 import {
@@ -117,6 +118,7 @@ export interface IContainerContext extends IDisposable {
     readonly configuration: IFluidConfiguration;
     readonly clientId: string | undefined;
     readonly clientDetails: IClientDetails;
+    readonly codeDetails: IFluidCodeDetails;
     readonly parentBranch: string | null;
     readonly storage: IDocumentStorageService | undefined | null;
     readonly connected: boolean;

packages/loader/container-loader/src/container.ts

@@ -41,13 +41,13 @@ import {
 } from "@fluidframework/driver-definitions";
 import {
     BlobCacheStorageService,
-    buildSnapshotTree,
     readAndParse,
     OnlineStatus,
     isOnline,
     ensureFluidResolvedUrl,
     combineAppAndProtocolSummary,
     readAndParseFromBlobs,
+    buildSnapshotTree,
 } from "@fluidframework/driver-utils";
 import {
     isSystemMessage,
@@ -803,21 +803,36 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
         }
 
+        if (this.codeLoader.IFluidCodeDetailsComparer) {
+            const comparision = await this.codeLoader.IFluidCodeDetailsComparer.compare(
+                codeDetails,
+                this.getCodeDetailsFromQuorum());
+            if (comparision !== undefined && comparision <= 0) {
+                throw new Error("Proposed code details should be greater than the current");
+            }
+        }
+
         return this.getQuorum().propose("code", codeDetails)
             .then(()=>true)
             .catch(()=>false);
     }
 
     private async reloadContextCore(): Promise<void> {
+        const codeDetails = this.getCodeDetailsFromQuorum();
+
         await Promise.all([
             this.deltaManager.inbound.systemPause(),
             this.deltaManager.inboundSignal.systemPause()]);
 
+        if (await this.context.satisfies(codeDetails) === true) {
+            this.deltaManager.inbound.systemResume();
+            this.deltaManager.inboundSignal.systemResume();
+            return;
+        }
+
         const previousContextState = await this.context.snapshotRuntimeState();
         this.context.dispose(new Error("ContextDisposedForReload"));
 
-        const codeDetails = this.getCodeDetailsFromQuorum();
-
         // don't fire this event if we are transitioning from a null runtime to a real runtime
         // with detached container we no longer need the null runtime, but for legacy
         // reasons need to keep it around (old documents without summary before code proposal).

packages/loader/container-loader/src/containerContext.ts

@@ -11,6 +11,7 @@ import {
     IRequest,
     IResponse,
     IFluidCodeDetails,
+    IFluidCodeDetailsComparer,
 } from "@fluidframework/core-interfaces";
 import {
     IAudience,
@@ -23,6 +24,7 @@ import {
     ICriticalContainerError,
     ContainerWarning,
     AttachState,
+    IFluidModule,
 } from "@fluidframework/container-definitions";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 import {
@@ -40,6 +42,7 @@ import {
     IVersion,
 } from "@fluidframework/protocol-definitions";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { LazyPromise } from "@fluidframework/common-utils";
 import { Container } from "./container";
 import { NullChaincode, NullRuntime } from "./nullRuntime";
 
@@ -165,6 +168,21 @@ export class ContainerContext implements IContainerContext {
         return this._disposed;
     }
 
+    private readonly fluidModuleP = new LazyPromise<IFluidModule>(async () => {
+        if (this.codeDetails === undefined) {
+            const fluidExport =  new NullChaincode();
+            return {
+                fluidExport,
+            };
+        }
+
+        const fluidModule = await PerformanceEvent.timedExecAsync(this.logger, { eventName: "CodeLoad" },
+            async () => this.codeLoader.load(this.codeDetails),
+        );
+
+        return fluidModule;
+    });
+
     constructor(
         private readonly container: Container,
         public readonly scope: IFluidObject,
@@ -270,18 +288,43 @@ export class ContainerContext implements IContainerContext {
         return this.container.getAbsoluteUrl(relativeUrl);
     }
 
-    private async load() {
-        if (this.codeDetails === undefined) {
-            const nullChaincode =  new NullChaincode();
-            this._runtime = await nullChaincode.instantiateRuntime(this);
-            return;
+    /**
+     * Determines if the current code details of the context
+     * satisfy the incoming constraint code details
+     */
+    public async satisfies(constraintCodeDetails: IFluidCodeDetails) {
+        const comparers: IFluidCodeDetailsComparer[] = [];
+
+        const maybeCompareCodeLoader = this.codeLoader;
+        if (maybeCompareCodeLoader.IFluidCodeDetailsComparer !== undefined) {
+            comparers.push(maybeCompareCodeLoader.IFluidCodeDetailsComparer);
         }
 
-        const fluidModule = await PerformanceEvent.timedExecAsync(this.logger, { eventName: "CodeLoad" },
-            async () => this.codeLoader.load(this.codeDetails),
-        );
+        const maybeCompareExport = (await this.fluidModuleP).fluidExport;
+        if (maybeCompareExport?.IFluidCodeDetailsComparer !== undefined) {
+            comparers.push(maybeCompareExport.IFluidCodeDetailsComparer);
+        }
 
-        const maybeFactory = fluidModule?.fluidExport?.IRuntimeFactory;
+        // if there are not comparers it is not possible to know
+        // if the current satisfy the incoming, so return false,
+        // as assuming they do not satisfy is safer .e.g we will
+        // reload, rather than potentially running with
+        // incompatible code
+        if (comparers.length === 0) {
+            return false;
+        }
+
+        for (const comparer of comparers) {
+            const satisfies = await comparer.satisfies(this.codeDetails, constraintCodeDetails);
+            if (satisfies === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private async load() {
+        const maybeFactory = (await this.fluidModuleP).fluidExport.IRuntimeFactory;
         if (maybeFactory === undefined) {
             throw new Error(PackageNotFactoryError);
         }

packages/loader/core-interfaces/src/fluidPackage.ts

@@ -59,7 +59,7 @@ export interface IFluidPackage {
 }
 
 /**
- * Check if the package.json defines a Fluid module, which requires a `fluid` entry
+ * Check if the package.json defines a Fluid package
  * @param pkg - the package json data to check if it is a Fluid package.
  */
 export const isFluidPackage = (pkg: any): pkg is Readonly<IFluidPackage> =>
@@ -96,3 +96,35 @@ export const isFluidCodeDetails = (details: unknown): details is Readonly<IFluid
         && (typeof maybeCodeDetails?.package === "string" || isFluidPackage(maybeCodeDetails?.package))
         && (maybeCodeDetails?.config === undefined || typeof maybeCodeDetails?.config === "object");
 };
+
+export const IFluidCodeDetailsComparer: keyof IProvideFluidCodeDetailsComparer = "IFluidCodeDetailsComparer";
+
+export interface IProvideFluidCodeDetailsComparer {
+    readonly IFluidCodeDetailsComparer: IFluidCodeDetailsComparer ;
+}
+
+/**
+ * Provides capability to compare Fluid code details.
+ */
+export interface IFluidCodeDetailsComparer extends IProvideFluidCodeDetailsComparer {
+
+    /**
+     * Determines if the `candidate` code details satisfy the constraints specified in `constraint` code details.
+     *
+     * Similar semantics to:
+     *      https://github.com/npm/node-semver#usage
+     */
+    satisfies(candidate: IFluidCodeDetails, constraint: IFluidCodeDetails): Promise<boolean>;
+
+    /**
+     * Return a number representing the ascending sort order of the `a` and `b` code details;
+     *      `< 0` if `a < b`.
+     *      `= 0` if `a === b`.
+     *      `> 0` if `a > b`.
+     *      `undefined` if `a` is not comparable to `b`.
+     *
+     * Similar semantics to:
+     *      https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Description
+     */
+    compare(a: IFluidCodeDetails, b: IFluidCodeDetails): Promise<number | undefined>;
+}

packages/runtime/container-runtime-definitions/src/containerRuntime.ts

@@ -73,6 +73,7 @@ export interface IContainerRuntime extends
     readonly options: any;
     readonly clientId: string | undefined;
     readonly clientDetails: IClientDetails;
+    readonly codeDetails: IFluidCodeDetails;
     readonly parentBranch: string | null;
     readonly connected: boolean;
     readonly leader: boolean;

packages/runtime/container-runtime/src/containerRuntime.ts

@@ -15,6 +15,7 @@ import {
     IRequest,
     IResponse,
     IFluidHandle,
+    IFluidCodeDetails,
 } from "@fluidframework/core-interfaces";
 import {
     IAudience,
@@ -612,6 +613,10 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
     public readonly IFluidHandleContext: IFluidHandleContext;
 
+    public get codeDetails(): IFluidCodeDetails {
+        return this.context.codeDetails ?? this.getQuorum().get("code") as IFluidCodeDetails;
+    }
+
     // internal logger for ContainerRuntime
     private readonly _logger: ITelemetryLogger;
     // publicly visible logger, to be used by stores, summarize, etc.