@fluidframework/container-loader 2.0.0-internal.4.0.6 → 2.0.0-internal.4.1.1

package/src/containerContext.ts

@@ -21,7 +21,6 @@ import {
 	IProvideFluidCodeDetailsComparer,
 	ICodeDetailsLoader,
 	IFluidModuleWithDetails,
-	ISnapshotTreeWithBlobContents,
 	IBatchMessage,
 } from "@fluidframework/container-definitions";
 import { IRequest, IResponse, FluidObject } from "@fluidframework/core-interfaces";
@@ -221,7 +220,7 @@ export class ContainerContext implements IContainerContext {
 		public readonly scope: FluidObject,
 		private readonly codeLoader: ICodeDetailsLoader,
 		private readonly _codeDetails: IFluidCodeDetails,
-		private _baseSnapshot: ISnapshotTree | undefined,
+		private readonly _baseSnapshot: ISnapshotTree | undefined,
 		public readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
 		quorum: IQuorum,
 		public readonly loader: ILoader,
@@ -375,10 +374,8 @@ export class ContainerContext implements IContainerContext {
 		return true;
 	}
 
-	public notifyAttaching(snapshot: ISnapshotTreeWithBlobContents) {
-		this._baseSnapshot = snapshot;
-		this.runtime.notifyAttaching?.(snapshot);
-		this.runtime.setAttachState(AttachState.Attaching);
+	public async notifyOpReplay(message: ISequencedDocumentMessage): Promise<void> {
+		return this.runtime.notifyOpReplay?.(message);
 	}
 
 	// #region private
@@ -406,6 +403,9 @@ export class ContainerContext implements IContainerContext {
 	}
 
 	private attachListener() {
+		this.container.once("attaching", () => {
+			this.runtime.setAttachState(AttachState.Attaching);
+		});
 		this.container.once("attached", () => {
 			this.runtime.setAttachState(AttachState.Attached);
 		});

package/src/containerStorageAdapter.ts

@@ -4,7 +4,7 @@
  */
 
 import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert } from "@fluidframework/common-utils";
+import { assert, bufferToString, stringToBuffer } from "@fluidframework/common-utils";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
 import {
 	FetchSource,
@@ -25,12 +25,20 @@ import { IDetachedBlobStorage } from "./loader";
 import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
 import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
 
+/**
+ * Stringified blobs from a summary/snapshot tree.
+ * @deprecated this is an internal interface and will not longer be exported in future versions
+ * @internal
+ */
+export interface ISerializableBlobContents {
+	[id: string]: string;
+}
+
 /**
  * This class wraps the actual storage and make sure no wrong apis are called according to
  * container attach state.
  */
 export class ContainerStorageAdapter implements IDocumentStorageService, IDisposable {
-	private readonly blobContents: { [id: string]: ArrayBufferLike } = {};
 	private _storageService: IDocumentStorageService & Partial<IDisposable>;
 
 	private _summarizeProtocolTree: boolean | undefined;
@@ -53,6 +61,10 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 	public constructor(
 		detachedBlobStorage: IDetachedBlobStorage | undefined,
 		private readonly logger: ITelemetryLogger,
+		/**
+		 * ArrayBufferLikes or utf8 encoded strings, containing blobs from a snapshot
+		 */
+		private readonly blobContents: { [id: string]: ArrayBufferLike | string } = {},
 		private readonly addProtocolSummaryIfMissing: (summaryTree: ISummaryTree) => ISummaryTree,
 		forceEnableSummarizeProtocolTree: boolean | undefined,
 	) {
@@ -128,9 +140,13 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 	}
 
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
-		const blob = this.blobContents[id];
-		if (blob !== undefined) {
-			return blob;
+		const maybeBlob = this.blobContents[id];
+		if (maybeBlob !== undefined) {
+			if (typeof maybeBlob === "string") {
+				const blob = stringToBuffer(maybeBlob, "utf8");
+				return blob;
+			}
+			return maybeBlob;
 		}
 		return this._storageService.readBlob(id);
 	}
@@ -212,3 +228,70 @@ class BlobOnlyStorage implements IDocumentStorageService {
 		}
 	}
 }
+
+// runtime will write a tree to the summary containing only "attachment" type entries
+// which reference attachment blobs by ID. However, some drivers do not support this type
+// and will convert them to "blob" type entries. We want to avoid saving these to reduce
+// the size of stashed change blobs.
+const blobsTreeName = ".blobs";
+
+/**
+ * Get blob contents of a snapshot tree from storage (or, ideally, cache)
+ */
+export async function getBlobContentsFromTree(
+	snapshot: ISnapshotTree,
+	storage: IDocumentStorageService,
+): Promise<ISerializableBlobContents> {
+	const blobs = {};
+	await getBlobContentsFromTreeCore(snapshot, blobs, storage);
+	return blobs;
+}
+
+async function getBlobContentsFromTreeCore(
+	tree: ISnapshotTree,
+	blobs: ISerializableBlobContents,
+	storage: IDocumentStorageService,
+	root = true,
+) {
+	const treePs: Promise<any>[] = [];
+	for (const [key, subTree] of Object.entries(tree.trees)) {
+		if (!root || key !== blobsTreeName) {
+			treePs.push(getBlobContentsFromTreeCore(subTree, blobs, storage, false));
+		}
+	}
+	for (const id of Object.values(tree.blobs)) {
+		const blob = await storage.readBlob(id);
+		// ArrayBufferLike will not survive JSON.stringify()
+		blobs[id] = bufferToString(blob, "utf8");
+	}
+	return Promise.all(treePs);
+}
+
+/**
+ * Extract blob contents from a snapshot tree with blob contents
+ */
+export function getBlobContentsFromTreeWithBlobContents(
+	snapshot: ISnapshotTreeWithBlobContents,
+): ISerializableBlobContents {
+	const blobs = {};
+	getBlobContentsFromTreeWithBlobContentsCore(snapshot, blobs);
+	return blobs;
+}
+
+function getBlobContentsFromTreeWithBlobContentsCore(
+	tree: ISnapshotTreeWithBlobContents,
+	blobs: ISerializableBlobContents,
+	root = true,
+) {
+	for (const [key, subTree] of Object.entries(tree.trees)) {
+		if (!root || key !== blobsTreeName) {
+			getBlobContentsFromTreeWithBlobContentsCore(subTree, blobs, false);
+		}
+	}
+	for (const id of Object.values(tree.blobs)) {
+		const blob = tree.blobsContents[id];
+		assert(blob !== undefined, 0x2ec /* "Blob must be present in blobsContents" */);
+		// ArrayBufferLike will not survive JSON.stringify()
+		blobs[id] = bufferToString(blob, "utf8");
+	}
+}

package/src/deltaManager.ts

@@ -41,8 +41,9 @@ import {
 	extractSafePropertiesFromMessage,
 	DataProcessingError,
 } from "@fluidframework/container-utils";
-import { DeltaQueue } from "./deltaQueue";
 import { IConnectionManagerFactoryArgs, IConnectionManager } from "./contracts";
+import { DeltaQueue } from "./deltaQueue";
+import { OnlyValidTermValue } from "./protocol";
 
 export interface IConnectionArgs {
 	mode?: ConnectionMode;
@@ -123,7 +124,6 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	private lastObservedSeqNumber: number = 0;
 	private lastProcessedSequenceNumber: number = 0;
 	private lastProcessedMessage: ISequencedDocumentMessage | undefined;
-	private baseTerm: number = 0;
 
 	/** count number of noops sent by the client which may not be acked */
 	private noOpCount: number = 0;
@@ -187,10 +187,6 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		return this.lastObservedSeqNumber;
 	}
 
-	public get referenceTerm(): number {
-		return this.baseTerm;
-	}
-
 	public get minimumSequenceNumber(): number {
 		return this.minSequenceNumber;
 	}
@@ -465,13 +461,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	public async attachOpHandler(
 		minSequenceNumber: number,
 		sequenceNumber: number,
-		term: number,
 		handler: IDeltaHandlerStrategy,
 		prefetchType: "cached" | "all" | "none" = "none",
 	) {
 		this.initSequenceNumber = sequenceNumber;
 		this.lastProcessedSequenceNumber = sequenceNumber;
-		this.baseTerm = term;
 		this.minSequenceNumber = minSequenceNumber;
 		this.lastQueuedSequenceNumber = sequenceNumber;
 		this.lastObservedSeqNumber = sequenceNumber;
@@ -986,9 +980,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 
 		// Back-compat for older server with no term
 		if (message.term === undefined) {
-			message.term = 1;
+			message.term = OnlyValidTermValue;
 		}
-		this.baseTerm = message.term;
 
 		if (this.handler === undefined) {
 			throw new Error("Attempted to process an inbound message without a handler attached");

package/src/index.ts

@@ -5,11 +5,12 @@
 
 export { ConnectionState } from "./connectionState";
 export {
-	IContainerLoadOptions,
 	IContainerConfig,
+	IContainerLoadOptions,
 	IPendingContainerState,
 	waitContainerToCatchUp,
 } from "./container";
+export { ISerializableBlobContents } from "./containerStorageAdapter";
 export {
 	ICodeDetailsLoader,
 	IDetachedBlobStorage,
@@ -18,5 +19,6 @@ export {
 	ILoaderProps,
 	ILoaderServices,
 	Loader,
+	requestResolvedObjectFromContainer,
 } from "./loader";
 export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol";

package/src/loader.ts

@@ -273,7 +273,10 @@ export async function requestResolvedObjectFromContainer(
 		throw new Error(`Invalid URL ${container.resolvedUrl.url}`);
 	}
 
-	return container.request({
+	const entryPoint: FluidObject<IFluidRouter> | undefined = await container.getEntryPoint?.();
+	const router = entryPoint?.IFluidRouter ?? container.IFluidRouter;
+
+	return router.request({
 		url: `${parsedUrl.path}${parsedUrl.query}`,
 		headers,
 	});

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-internal.4.0.6";
+export const pkgVersion = "2.0.0-internal.4.1.1";

package/src/protocol.ts

@@ -20,6 +20,9 @@ import {
 } from "@fluidframework/protocol-definitions";
 import { canBeCoalescedByService } from "@fluidframework/driver-utils";
 
+// "term" was an experimental feature that is being removed.  The only safe value to use is 1.
+export const OnlyValidTermValue = 1 as const;
+
 // ADO: #1986: Start using enum from protocol-base.
 export enum SignalType {
 	ClientJoin = "join", // same value as MessageType.ClientJoin,
@@ -51,7 +54,7 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		super(
 			attributes.minimumSequenceNumber,
 			attributes.sequenceNumber,
-			attributes.term,
+			OnlyValidTermValue,
 			quorumSnapshot.members,
 			quorumSnapshot.proposals,
 			quorumSnapshot.values,

package/src/utils.ts

@@ -126,7 +126,9 @@ export function convertProtocolAndAppSummaryToSnapshotTree(
 
 // This function converts the snapshot taken in detached container(by serialize api) to snapshotTree with which
 // a detached container can be rehydrated.
-export const getSnapshotTreeFromSerializedContainer = (detachedContainerSnapshot: ISummaryTree) => {
+export const getSnapshotTreeFromSerializedContainer = (
+	detachedContainerSnapshot: ISummaryTree,
+): ISnapshotTreeWithBlobContents => {
 	assert(
 		isCombinedAppAndProtocolSummary(detachedContainerSnapshot),
 		0x1e0 /* "Protocol and App summary trees should be present" */,