@milaboratories/pl-middle-layer 1.74.14 → 1.74.16

package/src/middle_layer/folders.ts

@@ -152,21 +152,26 @@ export const foldersFieldFilter: Filter = treeFilter.resourceTypeEq(FoldersResou
 export async function createFolderList(
   pl: PlClient,
   rid: SignedResourceId,
-  projectsTree: SynchronizedTreeState,
-  templatesTree: SynchronizedTreeState,
+  projectsTreeP: Promise<SynchronizedTreeState>,
+  templatesTreeP: Promise<SynchronizedTreeState>,
   openedProjects: WatchableValue<ProjectId[]>,
   env: MiddleLayerEnvironment,
 ): Promise<TreeAndComputableU<FoldersListing>> {
-  const tree = await SynchronizedTreeState.init(
-    pl,
-    rid,
-    {
-      ...env.ops.defaultTreeOptions,
-      pruning: FoldersTreePruningFunction,
-      fieldFilter: foldersFieldFilter,
-    },
-    env.logger,
-  );
+  // The other two trees are promises so the folder tree loads alongside them, not after them.
+  const [tree, projectsTree, templatesTree] = await Promise.all([
+    SynchronizedTreeState.init(
+      pl,
+      rid,
+      {
+        ...env.ops.defaultTreeOptions,
+        pruning: FoldersTreePruningFunction,
+        fieldFilter: foldersFieldFilter,
+      },
+      env.logger,
+    ),
+    projectsTreeP,
+    templatesTreeP,
+  ]);
 
   const c = Computable.make((ctx) => {
     const projectsNode = ctx.accessor(projectsTree.entry()).node();

package/src/middle_layer/init_latency_benchmark.test.ts

@@ -0,0 +1,102 @@
+import net from "node:net";
+import path from "path";
+import { randomUUID } from "node:crypto";
+import type { PlClient } from "@milaboratories/pl-client";
+import { plAddressToConfig, TestHelpers } from "@milaboratories/pl-client";
+import { test } from "vitest";
+import { MiddleLayer } from "./middle_layer";
+
+// Times MiddleLayer.init against a local http backend through a proxy that delays every chunk by
+// PL_PROXY_LATENCY_MS each way (default 25). No-ops without PL_ML_INIT_BENCH=1:
+//   PL_ML_INIT_BENCH=1 PL_PROXY_LATENCY_MS=50 pnpm vitest run src/middle_layer/init_latency_benchmark.test.ts
+test.skipIf(process.env.PL_ML_INIT_BENCH !== "1")(
+  "MiddleLayer.init latency",
+  { timeout: 300_000 },
+  async () => {
+    const { hostAndPort, ssl } = plAddressToConfig(TestHelpers.getTestConfig().address);
+    const [host, port] = hostAndPort.split(":");
+    if (ssl || (host !== "127.0.0.1" && host !== "localhost")) {
+      console.warn("*** skipping benchmark, PL_ADDRESS is not a local http backend", hostAndPort);
+      return;
+    }
+    const proxy = await startLinkProxy(
+      host,
+      Number(port),
+      Number(process.env.PL_PROXY_LATENCY_MS ?? 25),
+    );
+    // Only the dialed address changes; everything else PL_ADDRESS sets (timeouts, auth) still applies.
+    const viaProxy = { hostAndPort: `127.0.0.1:${proxy.port}` };
+    const tempRoot = `test_${Date.now()}_${randomUUID()}`;
+    const totals: number[] = [];
+    try {
+      // Run 0 is a first-time user on a fresh temp root. The rest run on the test user's own root,
+      // whose singletons persist like a returning user's (run 1 too may create them on a fresh
+      // backend), and they load whatever other tests left there, so they vary between machines.
+      for (let run = 0; run < 5; run++) {
+        const client = await TestHelpers.getTestClient(run === 0 ? tempRoot : undefined, viaProxy);
+        if (run === 0) await logPingRtt(client);
+        const t0 = performance.now();
+        const stamp = (msg: unknown) =>
+          console.log(`  +${(performance.now() - t0).toFixed(0).padStart(5)}ms ${String(msg)}`);
+        let ml: MiddleLayer;
+        try {
+          ml = await MiddleLayer.init(client, path.resolve(`work/${randomUUID()}`), {
+            localSecret: MiddleLayer.generateLocalSecret(),
+            localProjections: [],
+            openFileDialogCallback: () => {
+              throw new Error("Not implemented.");
+            },
+            logger: { info: stamp, warn: stamp, error: stamp },
+          });
+        } catch (e) {
+          await client.close();
+          throw e;
+        }
+        try {
+          totals.push(performance.now() - t0);
+          stamp(`run ${run}: init done`);
+        } finally {
+          // Closes the client too.
+          await ml.close();
+        }
+      }
+    } finally {
+      proxy.close();
+      const owner = await TestHelpers.getTestClient();
+      try {
+        await owner.deleteAlternativeRoot(tempRoot);
+      } finally {
+        await owner.close();
+      }
+    }
+    console.log(`init ms per run: ${totals.map((t) => t.toFixed(0)).join(" ")}`);
+  },
+);
+
+async function logPingRtt(pl: PlClient) {
+  const rtts: number[] = [];
+  for (let i = 0; i < 5; i++) {
+    const t = performance.now();
+    await pl.ping();
+    rtts.push(performance.now() - t);
+  }
+  console.log(`ping rtt ms: ${rtts.map((r) => r.toFixed(0)).join(" ")}`);
+}
+
+/** A TCP proxy behaving like a link with a fixed one-way delay: every chunk is forwarded `latency`
+ *  ms after it arrives, so back-to-back chunks overlap instead of queueing behind each other. */
+async function startLinkProxy(targetHost: string, targetPort: number, latency: number) {
+  const delayed = (from: net.Socket, to: net.Socket) => {
+    from.on("data", (chunk) => setTimeout(() => to.write(chunk), latency));
+    from.on("end", () => setTimeout(() => to.end(), latency));
+    from.on("error", () => to.destroy());
+  };
+  const server = net.createServer((socket) => {
+    const upstream = net.connect(targetPort, targetHost);
+    delayed(socket, upstream);
+    delayed(upstream, socket);
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const port = (server.address() as net.AddressInfo).port;
+  return { port, close: () => server.close() };
+}

package/src/middle_layer/middle_layer.ts

@@ -1898,55 +1898,65 @@ export class MiddleLayer {
     )
       ops.defaultTreeOptions.traversalMode = getDebugFlags().treeTraversalMode;
 
-    const { projects, templates, sharingOutbox, sharingState, folders } = await pl.withWriteTx(
-      "MLInitialization",
-      async (tx) => {
-        // Lazily create each clientRoot-attached singleton resource. Returns the existing
-        // resource id if the field is already populated, otherwise creates + locks + sets it.
-        // A created resource's id is known only once the transaction commits.
-        type Singleton = { existing: SignedResourceId } | { ref: ResourceRef };
-        const lazyInit = async (
-          fieldName: string,
-          type: { name: string; version: string },
-        ): Promise<Singleton> => {
-          const f = field(tx.clientRoot, fieldName);
-          tx.createField(f, "Dynamic");
-          const fData = await tx.getField(f);
-          if (isNullSignedResourceId(fData.value)) {
-            const ref = tx.createEphemeral(type);
-            tx.lock(ref);
-            tx.setField(f, ref);
-            return { ref };
-          }
-          return { existing: fData.value };
-        };
+    const initTxP = pl.withWriteTx("MLInitialization", async (tx) => {
+      // Lazily create each clientRoot-attached singleton resource. Returns the existing
+      // resource id if the field is already populated, otherwise creates + locks + sets it.
+      // A created resource's id is known only once the transaction commits.
+      type Singleton = { existing: SignedResourceId } | { ref: ResourceRef };
+      const lazyInit = async (
+        fieldName: string,
+        type: { name: string; version: string },
+      ): Promise<Singleton> => {
+        const f = field(tx.clientRoot, fieldName);
+        tx.createField(f, "Dynamic");
+        const fData = await tx.getField(f);
+        if (isNullSignedResourceId(fData.value)) {
+          const ref = tx.createEphemeral(type);
+          tx.lock(ref);
+          tx.setField(f, ref);
+          return { ref };
+        }
+        return { existing: fData.value };
+      };
 
-        const projectsR = await lazyInit(ProjectsField, ProjectsResourceType);
-        const templatesR = await lazyInit(TemplatesField, TemplatesResourceType);
-        const outboxR = await lazyInit(SharingOutboxField, SharingOutboxResourceType);
-        const stateR = await lazyInit(SharingStateField, SharingStateResourceType);
+      // All five in flight at once: the transaction pipelines its requests, so this costs one
+      // round trip instead of five.
+      const [projectsR, templatesR, outboxR, stateR, foldersR] = await Promise.all([
+        lazyInit(ProjectsField, ProjectsResourceType),
+        lazyInit(TemplatesField, TemplatesResourceType),
+        lazyInit(SharingOutboxField, SharingOutboxResourceType),
+        lazyInit(SharingStateField, SharingStateResourceType),
         // The folder tree gets its own root-attached singleton rather than a field on the
         // projects resource: an extra field there is walked by the released project-list reader
         // and dereferenced as a project, which takes the whole list down, not just the folders.
-        const foldersR = await lazyInit(FoldersField, FoldersResourceType);
+        lazyInit(FoldersField, FoldersResourceType),
+      ]);
 
-        await tx.commit();
+      await tx.commit();
 
-        const idOf = async (r: Singleton) => ("existing" in r ? r.existing : await r.ref.globalId);
-        return {
-          projects: await idOf(projectsR),
-          templates: await idOf(templatesR),
-          sharingState: await idOf(stateR),
-          sharingOutbox: await idOf(outboxR),
-          folders: await idOf(foldersR),
-        };
-      },
-    );
+      const idOf = async (r: Singleton) => ("existing" in r ? r.existing : await r.ref.globalId);
+      const [projects, templates, sharingState, sharingOutbox, folders] = await Promise.all([
+        idOf(projectsR),
+        idOf(templatesR),
+        idOf(stateR),
+        idOf(outboxR),
+        idOf(foldersR),
+      ]);
+      return { projects, templates, sharingState, sharingOutbox, folders };
+    });
+    // The driver kit needs nothing from the transaction, so it starts alongside it.
+    const driverKitP = initDriverKit(pl, workdir, ops.frontendDownloadPath, ops);
+    const [initTx, driverKitR] = await Promise.allSettled([initTxP, driverKitP]);
+    if (initTx.status === "rejected") {
+      if (driverKitR.status === "fulfilled") await driverKitR.value.dispose();
+      throw initTx.reason;
+    }
+    if (driverKitR.status === "rejected") throw driverKitR.reason;
+    const { projects, templates, sharingOutbox, sharingState, folders } = initTx.value;
+    const driverKit = driverKitR.value;
 
     const logger = ops.logger;
 
-    const driverKit = await initDriverKit(pl, workdir, ops.frontendDownloadPath, ops);
-
     // passed to components having no own retry logic
     const retryHttpDispatcher = new RetryAgent(pl.httpDispatcher);
 
@@ -2020,21 +2030,33 @@ export class MiddleLayer {
     };
 
     const openedProjects = new WatchableValue<ProjectId[]>([]);
-    const projectListTC = await createProjectList(pl, projects, openedProjects, env);
-    const templateListTC = await createTemplateList(pl, templates, env);
-    const foldersTC = await createFolderList(
-      pl,
-      folders,
-      projectListTC.tree,
-      templateListTC.tree,
-      openedProjects,
-      env,
-    );
-
-    // Project sharing trees and reactive views.
-    const outgoingTC = await createOutgoingShares(pl, sharingOutbox, env);
-    const sharingStateTree = await createSharingStateTree(pl, sharingState, env);
-    const availableSharesTree = await createAvailableSharesTree(pl, env);
+    // Each tree's first load is a round trip of its own; they are independent, so they all load
+    // at once rather than one after another.
+    const projectListP = createProjectList(pl, projects, openedProjects, env);
+    const templateListP = createTemplateList(pl, templates, env);
+    const [
+      projectListTC,
+      templateListTC,
+      foldersTC,
+      // Project sharing trees and reactive views.
+      outgoingTC,
+      sharingStateTree,
+      availableSharesTree,
+    ] = await Promise.all([
+      projectListP,
+      templateListP,
+      createFolderList(
+        pl,
+        folders,
+        projectListP.then((tc) => tc.tree),
+        templateListP.then((tc) => tc.tree),
+        openedProjects,
+        env,
+      ),
+      createOutgoingShares(pl, sharingOutbox, env),
+      createSharingStateTree(pl, sharingState, env),
+      createAvailableSharesTree(pl, env),
+    ]);
     const availableShares = createAvailableSharesComputable(
       availableSharesTree,
       sharingStateTree,