@fluidframework/container-runtime 2.70.0-361788 → 2.71.0

package/lib/channelCollection.js

@@ -25,9 +25,11 @@ import { nonDataStorePaths, rootHasIsolatedChannels, } from "./summary/index.js"
  */
 export const AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in the enum above, but avoiding the breaking change
 /**
- * Creates a shallow wrapper of {@link IFluidParentContext}. The wrapper can then have its methods overwritten as needed
+ * Creates a shallow wrapper of {@link IFluidParentContextPrivate} or
+ * {@link IFluidRootParentContextPrivate} with `submitMessage` and `submitSignal`
+ * methods replaced with the provided overrides.
  */
-export function wrapContext(context) {
+export function formParentContext(context, overrides) {
     return {
         get IFluidDataStoreRegistry() {
             return context.IFluidDataStoreRegistry;
@@ -67,12 +69,8 @@ export function wrapContext(context) {
         getAudience: (...args) => {
             return context.getAudience(...args);
         },
-        submitMessage: (...args) => {
-            return context.submitMessage(...args);
-        },
-        submitSignal: (...args) => {
-            return context.submitSignal(...args);
-        },
+        submitMessage: overrides.submitMessage.bind(overrides),
+        submitSignal: overrides.submitSignal,
         makeLocallyVisible: (...args) => {
             return context.makeLocallyVisible(...args);
         },
@@ -92,36 +90,34 @@ export function wrapContext(context) {
             return context.setChannelDirty(address);
         },
         minVersionForCollab: context.minVersionForCollab,
+        getExtension: context.getExtension.bind(context),
     };
 }
 /**
- * Creates a wrapper of a {@link IFluidParentContext} to be provided to the inner datastore channels.
+ * Creates a wrapper of a {@link IFluidRootParentContextPrivate} to be provided to the inner datastore channels.
  * The wrapper will have the submit methods overwritten with the appropriate id as the destination address.
  *
  * @param id - the id of the channel
- * @param parentContext - the {@link IFluidParentContext} to wrap
+ * @param parentContext - the {@link IFluidRootParentContextPrivate} to wrap
  * @returns A wrapped {@link IFluidParentContext}
  */
 function wrapContextForInnerChannel(id, parentContext) {
-    const context = wrapContext(parentContext);
-    context.submitMessage = (type, content, localOpMetadata) => {
-        const fluidDataStoreContent = {
-            content,
-            type,
-        };
-        const envelope = {
-            address: id,
-            contents: fluidDataStoreContent,
-        };
-        parentContext.submitMessage(ContainerMessageType.FluidDataStoreOp, envelope, localOpMetadata);
-    };
-    context.submitSignal = (type, contents, targetClientId) => {
-        const envelope = {
-            address: id,
-            contents,
-        };
-        parentContext.submitSignal(type, envelope, targetClientId);
-    };
+    const context = formParentContext(parentContext, {
+        submitMessage: (type, content, localOpMetadata) => {
+            const fluidDataStoreContent = {
+                content,
+                type,
+            };
+            const envelope = {
+                address: id,
+                contents: fluidDataStoreContent,
+            };
+            parentContext.submitMessage({ type: ContainerMessageType.FluidDataStoreOp, contents: envelope }, localOpMetadata);
+        },
+        submitSignal: (type, content, targetClientId) => {
+            parentContext.submitSignal({ address: id, contents: { type, content } }, targetClientId);
+        },
+    });
     return context;
 }
 /**
@@ -136,7 +132,7 @@ export function getLocalDataStoreType(localDataStore) {
  * @internal
  */
 export class ChannelCollection {
-    constructor(baseSnapshot, parentContext, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, provideEntryPoint) {
+    constructor(baseSnapshot, parentContext, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap) {
         this.baseSnapshot = baseSnapshot;
         this.parentContext = parentContext;
         this.gcNodeUpdated = gcNodeUpdated;
@@ -153,9 +149,49 @@ export class ChannelCollection {
          * For sampling. Only log once per container
          */
         this.shouldSendAttachLog = true;
+        this.reSubmitContainerMessage = (message, localOpMetadata, squash) => {
+            switch (message.type) {
+                case ContainerMessageType.Attach:
+                case ContainerMessageType.Alias: {
+                    this.parentContext.submitMessage(message, localOpMetadata);
+                    return;
+                }
+                case ContainerMessageType.FluidDataStoreOp: {
+                    return this.resubmitDataStoreOp(message.contents, localOpMetadata, squash);
+                }
+                default: {
+                    assert(false, 0x907 /* unknown op type */);
+                }
+            }
+        };
+        this.resubmitDataStoreOp = (envelope, localOpMetadata, squash) => {
+            const context = this.contexts.get(envelope.address);
+            // If the data store has been deleted, log an error and throw an error. If there are local changes for a
+            // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
+            if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "resubmitDataStoreOp")) {
+                throw new DataCorruptionError("Context is deleted!", {
+                    callSite: "resubmitDataStoreOp",
+                    ...tagCodeArtifacts({ id: envelope.address }),
+                });
+            }
+            assert(!!context, 0x160 /* "There should be a store context for the op" */);
+            context.reSubmit(envelope.contents, localOpMetadata, squash);
+        };
+        this.rollbackDataStoreOp = (envelope, localOpMetadata) => {
+            const context = this.contexts.get(envelope.address);
+            // If the data store has been deleted, log an error and throw an error. If there are local changes for a
+            // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
+            if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "rollbackDataStoreOp")) {
+                throw new DataCorruptionError("Context is deleted!", {
+                    callSite: "rollbackDataStoreOp",
+                    ...tagCodeArtifacts({ id: envelope.address }),
+                });
+            }
+            assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
+            context.rollback(envelope.contents, localOpMetadata);
+        };
         this.mc = createChildMonitoringContext({ logger: baseLogger });
         this.contexts = new DataStoreContexts(baseLogger);
-        this.entryPoint = new FluidObjectHandle(new LazyPromise(async () => provideEntryPoint(this)), "", this.parentContext.IFluidHandleContext);
         this.aliasedDataStores = new Set(aliasMap.values());
         // Extract stores stored inside the snapshot
         const fluidDataStores = new Map();
@@ -398,7 +434,7 @@ export class ChannelCollection {
     submitAttachChannelOp(localContext) {
         const message = this.generateAttachMessage(localContext);
         this.pendingAttach.set(localContext.id, message);
-        this.parentContext.submitMessage(ContainerMessageType.Attach, message, undefined);
+        this.parentContext.submitMessage({ type: ContainerMessageType.Attach, contents: message }, undefined);
         this.attachOpFiredForDataStore.add(localContext.id);
     }
     /**
@@ -472,52 +508,6 @@ export class ChannelCollection {
     dispose() {
         return this.disposeOnce.value;
     }
-    reSubmit(type, content, localOpMetadata, squash) {
-        switch (type) {
-            case ContainerMessageType.Attach:
-            case ContainerMessageType.Alias: {
-                this.parentContext.submitMessage(type, content, localOpMetadata);
-                return;
-            }
-            case ContainerMessageType.FluidDataStoreOp: {
-                return this.reSubmitChannelOp(type, content, localOpMetadata, squash);
-            }
-            default: {
-                assert(false, 0x907 /* unknown op type */);
-            }
-        }
-    }
-    reSubmitChannelOp(type, content, localOpMetadata, squash) {
-        const envelope = content;
-        const context = this.contexts.get(envelope.address);
-        // If the data store has been deleted, log an error and throw an error. If there are local changes for a
-        // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
-        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "resubmitDataStoreOp")) {
-            throw new DataCorruptionError("Context is deleted!", {
-                callSite: "resubmitDataStoreOp",
-                ...tagCodeArtifacts({ id: envelope.address }),
-            });
-        }
-        assert(!!context, 0x160 /* "There should be a store context for the op" */);
-        const innerContents = envelope.contents;
-        context.reSubmit(innerContents.type, innerContents.content, localOpMetadata, squash);
-    }
-    rollback(type, content, localOpMetadata) {
-        assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e8 /* type */);
-        const envelope = content;
-        const context = this.contexts.get(envelope.address);
-        // If the data store has been deleted, log an error and throw an error. If there are local changes for a
-        // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
-        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "rollbackDataStoreOp")) {
-            throw new DataCorruptionError("Context is deleted!", {
-                callSite: "rollbackDataStoreOp",
-                ...tagCodeArtifacts({ id: envelope.address }),
-            });
-        }
-        assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
-        const innerContents = envelope.contents;
-        context.rollback(innerContents.type, innerContents.content, localOpMetadata);
-    }
     async applyStashedOp(content) {
         const opContents = content;
         switch (opContents.type) {
@@ -1229,7 +1219,50 @@ export function detectOutboundReferences(address, contents, addedOutboundReferen
         addedOutboundReference(fromPath, toPath);
     }
 }
+// #region Experimentation
+// The code below here is for experimentation (and one test) only.
 /**
+ * @privateRemarks This class is only used for experimentation/testing.
+ */
+export class ComposableChannelCollection extends ChannelCollection {
+    constructor(baseSnapshot, parentContext, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, provideEntryPoint) {
+        super(baseSnapshot, 
+        /* [root] parentContext */
+        formParentContext(parentContext, {
+            submitMessage: (containerRuntimeMessage, localOpMetadata) => {
+                // Note that here our message format is reconfigured.
+                // While `ContainerRuntime*Message`s use `contents`
+                // as `FluidDataStoreMessage`s, the content is
+                // stored in `content`.
+                parentContext.submitMessage(containerRuntimeMessage.type, containerRuntimeMessage.contents, localOpMetadata);
+            },
+            submitSignal: (envelope, targetClientId) => {
+                parentContext.submitSignal(envelope.contents.type, {
+                    address: envelope.address,
+                    contents: envelope.contents.content,
+                }, targetClientId);
+            },
+        }), baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap);
+        this.entryPoint = new FluidObjectHandle(new LazyPromise(async () => provideEntryPoint(this)), "", this.parentContext.IFluidHandleContext);
+    }
+    reSubmit(type, content, localOpMetadata, squash) {
+        // If the cast is incorrect and type is not one of the three supported,
+        // reSubmitContainerMessage will assert.
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Need to force conversion
+        const message = {
+            type,
+            contents: content,
+        };
+        this.reSubmitContainerMessage(message, localOpMetadata, squash);
+    }
+    rollback(type, content, localOpMetadata) {
+        assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e8 /* type */);
+        this.rollbackDataStoreOp(content, localOpMetadata);
+    }
+}
+/**
+ * @privateRemarks This factory is only used for experimentation/testing.
+ *
  * @internal
  */
 export class ChannelCollectionFactory {
@@ -1254,10 +1287,10 @@ export class ChannelCollectionFactory {
         // this factory and the container runtime are
         // from the same package.
         assert(context instanceof FluidDataStoreContext, 0xb8f /* we don't support the layer boundary here today */);
-        const runtime = new ChannelCollection(context.baseSnapshot, context, // parentContext
-        context.baseLogger, () => { }, // gcNodeUpdated
-        (_nodePath) => false, // isDataStoreDeleted
-        new Map(), // aliasMap
+        const runtime = new ComposableChannelCollection(context.baseSnapshot, 
+        /* parentContext */ context, context.baseLogger, 
+        /* gcNodeUpdated */ () => { }, 
+        /* isDataStoreDeleted */ (_nodePath) => false, new Map(), // aliasMap
         this.provideEntryPoint);
         return runtime;
     }