@tsplc/build 0.2.2 → 0.2.3

package/python/test_build.py

@@ -4,7 +4,7 @@ import tempfile
 import unittest
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 from decimal import Decimal
 from build import CompilerError, build, diagnostic
 
@@ -80,6 +80,9 @@ class Controller:
 	def __init__(self, installed):
 		self.installed = installed
 		self.identity = SimpleNamespace(type=4096, id="0000 1008", version="4.22.0.0")
+		self.devices = []
+	def get_children(self, recursive):
+		return self.devices
 	def get_device_identification(self):
 		return self.identity
 	def update(self, type, id, version):
@@ -94,6 +97,7 @@ class CompilerFixture:
 	def __init__(self):
 		self.opened = []
 		self.installed = {(4102, "0000 0005", "4.22.0.0")}
+		self.device_tasks = []
 		self.fail_compile = False
 		self.empty_output = False
 		self.engine = SimpleNamespace(
@@ -101,6 +105,7 @@ class CompilerFixture:
 			DutType=SimpleNamespace(Structure="structure", Enumeration="enumeration", Union="union", Alias="alias"),
 			Severity=SimpleNamespace(Error=1, FatalError=2),
 			KindOfTask=SimpleNamespace(Cyclic=1),
+			ArchiveCategories=SimpleNamespace(devices="devices", libraries="libraries"),
 			system=SimpleNamespace(get_message_categories=lambda: ["compiler"], get_message_objects=lambda category, severity: [], clear_messages=Mock()),
 		)
 	def open(self, path, primary):
@@ -114,6 +119,12 @@ class CompilerFixture:
 		app.create("Symbols", "symbols")
 		app.create("PLC_PRG", "program")
 		controller = Controller(self.installed)
+		app.parent = controller
+		for name, task, call in self.device_tasks:
+			controller.devices.append(SimpleNamespace(is_device=True, get_name=lambda name=name: name))
+			cycle = configuration.create_task(task)
+			cycle.children.clear()
+			cycle.create(call, "task_call")
 		project = SimpleNamespace(path=path, close=Mock(), active_application=app, controller=controller,
 			get_children=lambda: [controller])
 		def save(): Path(project.path).write_text("compiled project")
@@ -124,7 +135,7 @@ class CompilerFixture:
 			if self.fail_compile: raise RuntimeError("Fixture compiler error")
 		def export(destination, update, compact):
 			Path(destination).write_text("" if self.empty_output else "boot application")
-		project.save, project.save_as = save, save_as
+		project.save, project.save_as, project.save_archive = save, save_as, Mock()
 		app.clean, app.rebuild, app.generate_code = Mock(), rebuild, Mock()
 		app.create_boot_application = export
 		self.opened.append(project)
@@ -142,6 +153,8 @@ class BuildTests(unittest.TestCase):
 		self.root = Path(self.temp.name)
 		self.template = self.root / "Template.project"
 		self.template.write_text("original template")
+		self.worker = self.root / "worker"
+		self.worker.mkdir()
 		self.compiler = CompilerFixture()
 		self.loaded = {}
 		self.counter = 0
@@ -157,7 +170,7 @@ class BuildTests(unittest.TestCase):
 		return request
 	def run_build(self, **overrides):
 		request = self.request(**overrides)
-		build(self.compiler.engine, request, self.loaded, str(self.root))
+		build(self.compiler.engine, request, self.loaded, str(self.worker))
 		return request
 	def find(self, name):
 		return self.loaded["project"].active_application.find_ignore_transient_objects(name, True)[0]
@@ -177,6 +190,11 @@ class BuildTests(unittest.TestCase):
 		self.assertEqual(task.calls, ["Second", "Main"])
 		self.assertEqual(self.loaded["project"].active_application.find_ignore_transient_objects("BackgroundTask", True), [])
 		self.assertEqual(json.loads(Path(request["receipt"]).read_text())["tasks"], tasks)
+	def test_explicit_tasks_keep_the_device_trees_own_tasks(self):
+		self.compiler.device_tasks = [("EtherNet_IP_Scanner", "ENIPScannerIOTask", "EtherNet_IP_Scanner.IOCycle")]
+		self.run_build(tasks=[dict(name="MainTask", intervalNanoseconds="10000000", priority=0, programs=["Main"])])
+		self.assertEqual(self.find("ENIPScannerIOTask").calls, ["EtherNet_IP_Scanner.IOCycle"])
+		self.assertEqual(self.loaded["project"].active_application.find_ignore_transient_objects("BackgroundTask", True), [])
 	def test_creates_missing_tasks_and_reloads_for_schedule_changes(self):
 		self.objects.append(spec("program", "Second", implementation="RETURN;"))
 		tasks = [dict(name="FastTask", intervalNanoseconds="10000000", priority=1, programs=["Main"]),
@@ -235,7 +253,7 @@ class BuildTests(unittest.TestCase):
 		self.assertEqual(len(self.compiler.opened), 2)
 		self.assertEqual(self.compiler.opened[0].path, self.compiler.opened[1].path)
 		self.compiler.opened[0].close.assert_called_once()
-		self.assertEqual([p.name for p in self.root.glob("project*")], ["project"])
+		self.assertEqual([p.name for p in self.worker.glob("project*")], ["project"])
 	def test_updates_the_template_controller_and_reloads_when_it_changes(self):
 		self.run_build(controller=LINUX_SL)
 		self.assertEqual(vars(self.loaded["project"].controller.identity), LINUX_SL)
@@ -281,7 +299,7 @@ class BuildTests(unittest.TestCase):
 		self.compiler.fail_compile = True
 		request = self.request()
 		with self.assertRaisesRegex(RuntimeError, "Fixture compiler error"):
-			build(self.compiler.engine, request, self.loaded, str(self.root))
+			build(self.compiler.engine, request, self.loaded, str(self.worker))
 		self.assertEqual(self.loaded, {})
 		self.assertFalse(Path(request["receipt"]).exists())
 		self.compiler.opened[0].close.assert_called_once()
@@ -300,6 +318,35 @@ class BuildTests(unittest.TestCase):
 		with self.assertRaisesRegex(RuntimeError, "Unresolved identifier"):
 			self.run_build()
 
+	def tree_build(self, tree):
+		"""A build in a new container, with the tree's generation and EDS imports recorded."""
+		self.loaded = {}
+		with patch("build.configure_device_tree", return_value={}) as generate, patch("build.import_device_description") as describe:
+			self.run_build(deviceTree=tree, archive="Application.projectarchive")
+		return generate.call_count, describe.call_count, self.compiler.opened[-1].path
+
+	def test_generates_a_device_tree_once_and_reuses_it_in_later_containers(self):
+		tree = dict(devices=[dict(name="Io", eds="devices/Io.eds", address="10.0.0.2")])
+		self.assertEqual(self.tree_build(tree)[:2], (1, 0))
+		generated, described, opened = self.tree_build(tree)
+		self.assertEqual((generated, described), (0, 1))
+		self.assertEqual(Path(opened), self.worker / "project" / "Application.project")
+
+	def test_regenerates_a_changed_tree_and_keeps_only_the_newest(self):
+		self.tree_build(dict(devices=[dict(name="Io", eds="devices/Io.eds", address="10.0.0.2")]))
+		moved = dict(devices=[dict(name="Io", eds="devices/Io.eds", address="10.0.0.3")])
+		self.assertEqual(self.tree_build(moved)[0], 1)
+		self.assertEqual(len(list((self.root / "device-tree").iterdir())), 1)
+		self.assertEqual(self.tree_build(moved)[0], 0)
+
+	def test_keeps_no_tree_from_a_failed_build(self):
+		tree = dict(devices=[dict(name="Io", eds="devices/Io.eds")])
+		self.compiler.fail_compile = True
+		with self.assertRaisesRegex(RuntimeError, "Fixture compiler error"):
+			self.tree_build(tree)
+		self.compiler.fail_compile = False
+		self.assertEqual(self.tree_build(tree)[0], 1)
+
 	def test_preserves_compiler_position_metadata_without_decoding(self):
 		project = SimpleNamespace(path="C:\\scratch\\Application.project", is_root=True, active_application=None)
 		folder = SimpleNamespace(get_name=lambda: "Functions", is_root=False, parent=project)

package/python/test_codesys_online.py

@@ -83,6 +83,8 @@ class OnlineLifecycleTests(unittest.TestCase):
         replacements = {
             'apply_controller': Mock(side_effect=lambda *args: self.events.append('controller')),
             'import_objects': Mock(side_effect=imported),
+            'configure_device_tree': Mock(side_effect=lambda *args: self.events.append('device tree') or {'%IB0': 'channel'}),
+            'verify_pinned': Mock(),
             'core_application': Mock(return_value=self.core),
             'session_login': Mock(),
             'controller_ids': Mock(return_value=self.ids),
@@ -116,6 +118,13 @@ class OnlineLifecycleTests(unittest.TestCase):
         self.project.close.assert_called_once()
         self.app.build.assert_not_called()
 
+    def test_download_generates_the_device_tree_after_importing_and_verifies_its_channels(self):
+        self.request.update(deviceTree={'devices': []}, devices='C:\\request')
+        codesys_online.run_online(self.engine, self.request)
+        self.assertEqual(self.events, ['import', 'device tree', 'clean', 'compile', 'generate', 'online-wrapper'])
+        self.assertEqual(codesys_online.configure_device_tree.call_args.args[2:4], ({'devices': []}, 'C:\\request'))
+        codesys_online.verify_pinned.assert_called_once_with({'%IB0': 'channel'})
+
     def test_download_switches_the_template_controller_before_importing(self):
         self.request['controller'] = {'type': 4102, 'id': '0000 0005', 'version': '4.22.0.0'}
         codesys_online.run_online(self.engine, self.request)

package/src/build.ts

@@ -4,6 +4,7 @@ import { resolve } from "node:path";
 import { buildFiles, publishBuild, readBuild } from "./artifacts";
 import { dockerImage, type ResolvedConfig } from "./config";
 import { buildInDocker } from "./docker-build";
+import { writeDeviceTree } from "./device-tree";
 import { createCodesysWorker, withWorkerLock } from "./host/codesys-worker";
 import { loadSources } from "./sources";
 import { toWindowsPath } from "./host/windows-path.ts";
@@ -28,19 +29,7 @@ export const buildInContainer = async (config: ResolvedConfig) => {
     await mkdir(resolve(directory, "runtime"), { recursive: true });
     const template = resolve(directory, "Template.project");
     await copyFile(config.template, template);
-    // CODESYS imports each adapter's EDS from the build directory.
-    const deviceTree = config.deviceTree && {
-      ...config.deviceTree,
-      devices: await Promise.all(
-        config.deviceTree.devices.map(async (device) => {
-          const eds = `${buildFiles.devices}/${device.name}.eds`;
-          await mkdir(resolve(directory, buildFiles.devices), { recursive: true });
-          await writeFile(resolve(directory, eds), device.eds);
-          // The digest keys project reuse on the description's content.
-          return { ...device, eds, sha256: createHash("sha256").update(device.eds).digest("hex") };
-        }),
-      ),
-    };
+    const deviceTree = config.deviceTree && (await writeDeviceTree(config.deviceTree, directory));
     const request = {
       libraryReferences: config.libraryReferences,
       libraries: await Promise.all(

package/src/controller-online.ts

@@ -28,6 +28,10 @@ export const controllerResultSchema = z.strictObject({
     gateway: endpointSchema,
     device: endpointSchema,
     controller: controllerSchema.optional(),
+    deviceTree: z
+      .string()
+      .regex(/^[a-f0-9]{64}$/)
+      .optional(),
   }),
   generation: z.string().nonempty(),
   application: z.string().nonempty(),
@@ -45,6 +49,23 @@ export type ControllerUpdateOptions = {
   read?: string[];
 };
 
+/**
+ * What a download binds the controller to. An online change needs the same connection, controller
+ * and device tree, because it only recompiles the program into the downloaded project.
+ */
+export const controllerTarget = (
+  config: ResolvedConfig,
+  online: NonNullable<ResolvedConfig["online"]>,
+) => ({
+  network: online.network,
+  gateway: online.gateway,
+  device: online.device,
+  controller: config.controller,
+  ...(config.deviceTree && {
+    deviceTree: createHash("sha256").update(JSON.stringify(config.deviceTree)).digest("hex"),
+  }),
+});
+
 /** Checks the settings every engineering connection needs and names its builder image and target. */
 const controllerConnection = async (config: ResolvedConfig) => {
   if (!config.docker || !config.online) {
@@ -76,12 +97,7 @@ const controllerConnection = async (config: ResolvedConfig) => {
     templateHash: createHash("sha256")
       .update(await readFile(config.template))
       .digest("hex"),
-    target: {
-      network: config.online.network,
-      gateway: config.online.gateway,
-      device: config.online.device,
-      controller: config.controller,
-    },
+    target: controllerTarget(config, config.online),
   };
 };
 

package/src/controller-session.ts

@@ -3,13 +3,19 @@ import { copyFile, cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/p
 import { resolve } from "node:path";
 import { z } from "zod";
 import type { ResolvedConfig } from "./config";
-import { controllerResultSchema, explicitDownload, loginCommandSchema } from "./controller-online";
+import {
+  controllerResultSchema,
+  controllerTarget,
+  explicitDownload,
+  loginCommandSchema,
+} from "./controller-online";
 import {
   createCodesysWorker,
   withWorkerLock,
   withWorkerShutdown,
   writeJson,
 } from "./host/codesys-worker";
+import { writeDeviceTree } from "./device-tree";
 import { toWindowsPath } from "./host/windows-path";
 import { loadSources } from "./sources";
 
@@ -74,7 +80,7 @@ const readBaseline = async (
     JSON.stringify(baseline.target) !== JSON.stringify(expected.target)
   ) {
     throw new Error(
-      `Downloaded baseline uses a different image, template or controller; ${explicitDownload}`,
+      `Downloaded baseline uses a different image, template, controller or device tree; ${explicitDownload}`,
     );
   }
   const project = resolve(previous, "project");
@@ -103,9 +109,8 @@ export const runControllerSession = async (
   const resultPath = resolve(root, "result.json");
   await rm(resultPath, { force: true });
   const templateHash = sha256(await readFile(config.template));
-  const { network, gateway, device } = config.online;
-  // A different development controller needs a fresh download from the template.
-  const target = { network, gateway, device, controller: config.controller };
+  // A different controller or device tree needs a fresh download from the template.
+  const target = controllerTarget(config, config.online);
   const previous =
     operation === "download"
       ? undefined
@@ -133,6 +138,13 @@ export const runControllerSession = async (
   await mkdir(requestDirectory, { recursive: true });
   const sources = operation === "inspect" ? undefined : await loadSources(config);
   const request = {
+    libraryReferences: config.libraryReferences,
+    // A download starts from the template; an online change keeps the downloaded project's tree.
+    ...(config.deviceTree &&
+      operation === "download" && {
+        deviceTree: await writeDeviceTree(config.deviceTree, requestDirectory),
+        devices: await toWindowsPath(requestDirectory, config.codesys.wine),
+      }),
     libraries: await Promise.all(
       (config.libraries ?? []).map(async (library) => ({
         ...library,

package/src/device-tree.ts

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { buildFiles } from "./artifacts";
+import type { ResolvedConfig } from "./config";
+
+/** Writes each adapter's EDS into `directory`, where CODESYS imports it, and returns the tree the worker reads. */
+export const writeDeviceTree = async (
+  deviceTree: NonNullable<ResolvedConfig["deviceTree"]>,
+  directory: string,
+) => {
+  await mkdir(resolve(directory, buildFiles.devices), { recursive: true });
+  return {
+    ...deviceTree,
+    devices: await Promise.all(
+      deviceTree.devices.map(async (device) => {
+        const eds = `${buildFiles.devices}/${device.name}.eds`;
+        await writeFile(resolve(directory, eds), device.eds);
+        // The digest keys project reuse on the description's content.
+        return { ...device, eds, sha256: createHash("sha256").update(device.eds).digest("hex") };
+      }),
+    ),
+  };
+};