@tsplc/build 0.2.7 → 0.2.9

package/src/controller-session.ts

@@ -4,10 +4,13 @@ import { resolve } from "node:path";
 import { z } from "zod";
 import type { ResolvedConfig } from "./config";
 import {
+  type ControllerCredentials,
   controllerResultSchema,
   controllerTarget,
   explicitDownload,
+  failureReason,
   loginCommandSchema,
+  warmOperationSchema,
 } from "./controller-online";
 import {
   createCodesysWorker,
@@ -90,7 +93,33 @@ const readBaseline = async (
   return { baseline, project };
 };
 
-/** Called inside the builder container while its output-directory flock is held. */
+/** A CODESYS worker that handles the `online` request written to `requestDirectory` when `run`. */
+interface OnlineWorker {
+  requestDirectory: string;
+  run: () => Promise<unknown>;
+  /** A candidate generation copied from baseline generation `baseline`, which the worker has open. */
+  prepared?: { baseline: string; generation: string };
+}
+
+/** A worker started for one operation and stopped after it. */
+const oneShotWorker = (config: ResolvedConfig): OnlineWorker => {
+  const worker = createCodesysWorker(config);
+  return {
+    requestDirectory: resolve(config.outDir, ".codesys/controller"),
+    run: () =>
+      withWorkerShutdown(config, worker, () =>
+        withWorkerLock(config, async () =>
+          worker.request(await worker.launch(), { action: "online" }, config.timeouts.build),
+        ),
+      ),
+  };
+};
+
+/**
+ * Called inside the builder container, while its output-directory flock is held or, for a warm
+ * `worker`, while the agent runs nothing else. Without `credentials`, CODESYS reads the controller
+ * user from the environment variables `config.online` names.
+ */
 export const runControllerSession = async (
   config: ResolvedConfig,
   operation: "download" | "online-change" | "inspect",
@@ -99,7 +128,9 @@ export const runControllerSession = async (
     operationId: string;
     initializeUser?: boolean;
     read?: string[];
+    credentials?: ControllerCredentials;
   },
+  worker?: OnlineWorker,
 ) => {
   if (!config.online) {
     throw new Error("Controller operations require online settings");
@@ -119,12 +150,15 @@ export const runControllerSession = async (
   if (options.initializeUser && operation !== "download") {
     throw new Error("Initial user creation requires an explicit download");
   }
-  const generation = randomUUID();
+  const opened = worker?.prepared;
+  const prepared =
+    operation === "online-change" && opened?.baseline === baseline?.generation ? opened : undefined;
+  const generation = prepared?.generation ?? randomUUID();
   const candidate = resolve(root, "generations", generation);
   const project = resolve(candidate, "project", "Application.project");
   await mkdir(resolve(candidate, "project"), { recursive: true });
   // A download saves the template here, with its controller and device tree.
-  if (previous) {
+  if (previous && !prepared) {
     await cp(previous.project, resolve(candidate, "project"), {
       recursive: true,
     });
@@ -133,8 +167,19 @@ export const runControllerSession = async (
     ...config,
     outDir: resolve(root, "jobs", options.operationId),
   };
-  const requestDirectory = resolve(jobConfig.outDir, ".codesys/controller");
+  // The job directory keeps this operation's progress and descriptions; the worker its mailbox.
+  const jobDirectory = resolve(jobConfig.outDir, ".codesys/controller");
+  const online = worker ?? oneShotWorker(jobConfig);
+  const { requestDirectory } = online;
+  await mkdir(jobDirectory, { recursive: true });
   await mkdir(requestDirectory, { recursive: true });
+  await rm(resolve(requestDirectory, "result.json"), { force: true });
+  // Only this container reads it; the worker deletes it once CODESYS has the user.
+  const credentialsFile =
+    options.credentials && `/tmp/tsplc-credentials-${options.operationId}.json`;
+  if (credentialsFile) {
+    await writeFile(credentialsFile, JSON.stringify(options.credentials), { mode: 0o600 });
+  }
   const sources = operation === "inspect" ? undefined : await loadSources(config);
   const request = {
     libraryReferences: config.libraryReferences,
@@ -145,8 +190,8 @@ export const runControllerSession = async (
       // Kept across jobs: generating a device tree takes minutes, and the same inputs make the same one.
       caches: await toWindowsPath(root, config.codesys.wine),
       ...(config.deviceTree && {
-        deviceTree: await writeDeviceTree(config.deviceTree, requestDirectory),
-        devices: await toWindowsPath(requestDirectory, config.codesys.wine),
+        deviceTree: await writeDeviceTree(config.deviceTree, jobDirectory),
+        devices: await toWindowsPath(jobDirectory, config.codesys.wine),
       }),
     }),
     libraries: await Promise.all(
@@ -165,26 +210,25 @@ export const runControllerSession = async (
     online: config.online,
     controller: config.controller,
     project: await toWindowsPath(project, config.codesys.wine),
-    progress: await toWindowsPath(resolve(requestDirectory, "progress.log"), config.codesys.wine),
+    progress: await toWindowsPath(resolve(jobDirectory, "progress.log"), config.codesys.wine),
+    ...(credentialsFile && {
+      credentialsFile: await toWindowsPath(credentialsFile, config.codesys.wine),
+    }),
     baseline,
     read: options.read ?? [],
   };
   await writeFile(resolve(requestDirectory, "request.json"), JSON.stringify(request, null, 2));
-  const worker = createCodesysWorker(jobConfig);
-  return withWorkerShutdown(jobConfig, worker, async () => {
-    const result = await withWorkerLock(jobConfig, async () => {
-      const session = await worker.launch();
-      await worker.request(session, { action: "online" }, config.timeouts.build);
-      return z
-        .object({
-          applicationGuid: guid,
-          application: z.string().optional(),
-          controllerIds: z.strictObject({ codeId: guid, dataId: guid }),
-          state: z.string(),
-          values: z.record(z.string(), z.string()),
-        })
-        .parse(JSON.parse(await readFile(resolve(requestDirectory, "result.json"), "utf8")));
-    });
+  try {
+    await online.run();
+    const result = z
+      .object({
+        applicationGuid: guid,
+        application: z.string().optional(),
+        controllerIds: z.strictObject({ codeId: guid, dataId: guid }),
+        state: z.string(),
+        values: z.record(z.string(), z.string()),
+      })
+      .parse(JSON.parse(await readFile(resolve(requestDirectory, "result.json"), "utf8")));
     const receipt = controllerResultSchema.parse({
       ...result,
       application: result.application ?? baseline?.application,
@@ -237,11 +281,16 @@ export const runControllerSession = async (
     }
     await writeJson(resultPath, receipt);
     return receipt;
-  }).finally(async () => {
+  } finally {
+    if (credentialsFile) await rm(credentialsFile, { force: true });
+    // The worker closed an opened project this operation didn't use.
+    if (opened && opened !== prepared) {
+      await rm(resolve(root, "generations", opened.generation), { recursive: true, force: true });
+    }
     if (operation === "inspect") {
       await rm(candidate, { recursive: true, force: true });
     }
-  });
+  }
 };
 
 /**
@@ -284,6 +333,8 @@ export const serveControllerLogin = async (
       // The worker has one mailbox, so commands run one at a time.
       let previous: Promise<unknown> = Promise.resolve();
       const server = Bun.serve({
+        // The agent calls through `docker exec`, so nothing else on the network can.
+        hostname: "127.0.0.1",
         port: options.port,
         idleTimeout: 0,
         fetch: async (request) => {
@@ -297,10 +348,7 @@ export const serveControllerLogin = async (
           try {
             return Response.json({ ok: true, result: await result });
           } catch (error) {
-            // The worker reports a Python traceback; its last line names the failure.
-            const message = error instanceof Error ? error.message : String(error);
-            const reason = message.trim().split("\n").at(-1) ?? message;
-            return Response.json({ ok: false, error: reason.replace(/^\w+: /, "") });
+            return Response.json({ ok: false, error: failureReason(error) });
           } finally {
             if (close) closed.resolve();
           }
@@ -311,3 +359,84 @@ export const serveControllerLogin = async (
     }),
   );
 };
+
+/**
+ * Called inside the builder container: keeps one CODESYS worker running and serves downloads and
+ * online changes on `port`, so each skips starting the container and CODESYS. Each
+ * POST names its own config, written for that release. The agent runs one operation at a time, and
+ * none while a login is open, so this container doesn't hold the output directory's flock.
+ */
+export const serveWarmController = async (
+  config: ResolvedConfig,
+  options: {
+    imageId: string;
+    port: number;
+    loadConfig: (path: string) => Promise<ResolvedConfig>;
+  },
+) => {
+  const warmConfig = { ...config, outDir: resolve(config.outDir, ".codesys/controller/warm") };
+  // One container owns this directory at a time; a stopped one can leave its worker session behind.
+  await rm(warmConfig.outDir, { recursive: true, force: true });
+  const worker = createCodesysWorker(warmConfig);
+  const session = await worker.launch();
+  const root = resolve(config.outDir, ".codesys/controller");
+  const online: OnlineWorker = {
+    requestDirectory: resolve(warmConfig.outDir, ".codesys/controller"),
+    run: () => worker.request(session, { action: "online" }, config.timeouts.build),
+  };
+  /** Opens a copy of the committed baseline, so the next online change needn't open one. */
+  const prepare = async () => {
+    const pointer = await readFile(resolve(root, "current.json"), "utf8").catch(() => undefined);
+    if (!pointer) return;
+    const baseline = pointerSchema.parse(JSON.parse(pointer)).generation;
+    const generation = randomUUID();
+    const project = resolve(root, "generations", generation, "project");
+    await cp(resolve(root, "generations", baseline, "project"), project, { recursive: true });
+    await worker.request(
+      session,
+      {
+        action: "prepare",
+        project: await toWindowsPath(resolve(project, "Application.project"), config.codesys.wine),
+      },
+      config.timeouts.build,
+    );
+    online.prepared = { baseline, generation };
+  };
+  // A failed prepare only costs the next operation the time to open the project itself.
+  const prepareNext = () =>
+    prepare().catch((error: unknown) => {
+      console.error(`Could not open the next project ahead: ${failureReason(error)}`);
+    });
+  let preparing = prepareNext();
+  Bun.serve({
+    hostname: "127.0.0.1",
+    port: options.port,
+    idleTimeout: 0,
+    fetch: async (request) => {
+      if (request.method === "GET") return Response.json({ ok: true });
+      await preparing;
+      try {
+        const body = warmOperationSchema.parse(await request.json());
+        const result = await runControllerSession(
+          await options.loadConfig(body.request),
+          body.operation,
+          {
+            imageId: options.imageId,
+            operationId: body.operationId,
+            initializeUser: body.initializeUser,
+            credentials: body.credentials,
+          },
+          online,
+        );
+        return Response.json({ ok: true, result });
+      } catch (error) {
+        return Response.json({ ok: false, error: failureReason(error) });
+      } finally {
+        online.prepared = undefined;
+        preparing = prepareNext();
+      }
+    },
+  });
+  // Serves until the container stops; the next one clears what this one leaves behind.
+  await new Promise(() => {});
+};

package/src/docker-run.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { copyFile, cp, mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, posix, relative, resolve, sep } from "node:path";
 import type { ResolvedConfig } from "./config.ts";
 
@@ -39,7 +39,12 @@ export const runDocker = (args: string[], failure: (status: string | number | nu
 const bindMount = (source: string, target: string, readonly = false) =>
   `type=bind,"source=${source.replaceAll('"', '""')}",target=${target}${readonly ? ",readonly" : ""}`;
 
-async function mountLibraries(libraries: ResolvedConfig["libraries"], directory: string) {
+/** Copies the libraries to `directory`, which the container sees as `root`. */
+async function mountLibraries(
+  libraries: ResolvedConfig["libraries"],
+  directory: string,
+  root = "/input",
+) {
   if (!libraries?.length) return undefined;
   await mkdir(resolve(directory, "libraries"), { recursive: true });
   return Promise.all(
@@ -49,11 +54,57 @@ async function mountLibraries(libraries: ResolvedConfig["libraries"], directory:
         throw new Error(`Library changed after installation: ${library.title}`);
       const filename = `${library.sha256}-${basename(library.path)}`;
       await writeFile(resolve(directory, "libraries", filename), data);
-      return { ...library, path: `/input/libraries/${filename}` };
+      return { ...library, path: `${root}/libraries/${filename}` };
     }),
   );
 }
 
+/** The config a builder container reads: host-only settings removed, paths inside the container. */
+const containerConfig = (
+  config: ResolvedConfig,
+  paths: { sourceDir: string; template: string },
+  libraries: ResolvedConfig["libraries"] | [],
+) => ({
+  ...config,
+  libraries,
+  configFile: undefined,
+  docker: undefined,
+  codesys: undefined,
+  sourceDir: paths.sourceDir,
+  entry: posix.resolve(
+    paths.sourceDir,
+    relative(config.sourceDir, config.entry).split(sep).join("/"),
+  ),
+  template: paths.template,
+  outDir: "/output",
+  runtime: undefined,
+});
+
+/**
+ * Copies one operation's sources, template and libraries to `directory` in the output directory,
+ * which a warm container sees as `root`, and writes their config there. Returns its container path.
+ */
+export const writeOperationRequest = async (
+  config: ResolvedConfig,
+  directory: string,
+  root: string,
+) => {
+  await mkdir(directory, { recursive: true });
+  await cp(config.sourceDir, resolve(directory, "sources"), { recursive: true });
+  await copyFile(config.template, resolve(directory, "template.project"));
+  await writeFile(
+    resolve(directory, "config.json"),
+    JSON.stringify(
+      containerConfig(
+        config,
+        { sourceDir: `${root}/sources`, template: `${root}/template.project` },
+        await mountLibraries(config.libraries, directory, root),
+      ),
+    ),
+  );
+  return `${root}/config.json`;
+};
+
 /**
  * Write the builder container's request and return the `docker run` options that precede
  * the image; the caller chooses `--rm` or `--detach`. The request names only container paths;
@@ -67,21 +118,13 @@ export const prepareContainerRun = async (
 ) => {
   await writeFile(
     resolve(requestDirectory, "config.json"),
-    JSON.stringify({
-      ...config,
-      libraries: options.sources ? await mountLibraries(config.libraries, requestDirectory) : [],
-      configFile: undefined,
-      docker: undefined,
-      codesys: undefined,
-      sourceDir: "/sources",
-      entry: posix.resolve(
-        "/sources",
-        relative(config.sourceDir, config.entry).split(sep).join("/"),
+    JSON.stringify(
+      containerConfig(
+        config,
+        { sourceDir: "/sources", template: "/template.project" },
+        options.sources ? await mountLibraries(config.libraries, requestDirectory) : [],
       ),
-      template: "/template.project",
-      outDir: "/output",
-      runtime: undefined,
-    }),
+    ),
   );
   return [
     "--init",

package/src/host/codesys-worker.ts

@@ -32,6 +32,7 @@ type Session = z.infer<typeof sessionSchema>;
 
 type WorkerCommand =
   | { action: "build" | "online" | "ping" | "stop" }
+  | { action: "prepare"; project: string }
   | { action: "login"; arguments: Record<string, unknown> };
 
 const hasCode = (error: unknown, code: string) =>

package/src/index.ts

@@ -19,7 +19,9 @@ export {
   type LoginResult,
   loginResultSchema,
   openControllerLogin,
+  startWarmController,
   updateController,
+  updateWarmController,
 } from "./controller-online";
 export { type CodesysCompilerDiagnostic, CodesysCompilerError } from "./diagnostics";
 export { runProject } from "./run";