@tsplc/build 0.0.0-stage → 0.2.0

package/python/test_installer_verification.py

@@ -0,0 +1,307 @@
+import importlib.util
+import io
+import json
+import os
+import runpy
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from contextlib import redirect_stderr, redirect_stdout
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+
+path = Path(__file__).parent.parent / 'docker' / 'install' / 'verify.py'
+spec = importlib.util.spec_from_file_location('installer_verification', path)
+verification = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(verification)
+
+
+# The bundled ARM64 Virtual Control description, which leaves byte-addressing at its default.
+DEVICE_DESCRIPTION = (
+    Path(__file__).parent.parent / 'docker' / 'install' / 'device' / 'codesyscontrol.devdesc.xml'
+).read_text(encoding='utf-8')
+
+
+def target_setting(name, value):
+    return (
+        '<ts:section name="memory-layout"><ts:setting name="{0}" type="boolean" access="hide">'
+        '<ts:value>{1}</ts:value></ts:setting></ts:section>'
+    ).format(name, value)
+
+
+class InstallerVerificationTests(unittest.TestCase):
+    def setUp(self):
+        patcher = patch.dict(sys.modules, {
+            'System': SimpleNamespace(Guid=lambda value: value),
+        })
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.description = DEVICE_DESCRIPTION
+        opener = patch.object(io, 'open', side_effect=lambda path, encoding: io.StringIO(self.description))
+        opener.start()
+        self.addCleanup(opener.stop)
+        self.events = []
+        self.messages = []
+        self.program = SimpleNamespace(
+            textual_declaration=SimpleNamespace(replace=Mock()),
+            textual_implementation=SimpleNamespace(replace=Mock()),
+        )
+        self.task = SimpleNamespace(pous=SimpleNamespace(add=Mock()))
+        self.manager = SimpleNamespace(
+            get_libraries=Mock(side_effect=lambda **args: self.events.append('libraries')),
+        )
+        task_configuration = SimpleNamespace(create_task=Mock(return_value=self.task))
+        self.application = SimpleNamespace(
+            create_program=Mock(return_value=self.program),
+            create_task_configuration=Mock(return_value=task_configuration),
+            create_symbol_config=Mock(),
+            get_library_manager=Mock(return_value=self.manager),
+            clean=Mock(side_effect=lambda: self.events.append('clean')),
+            rebuild=Mock(side_effect=lambda: self.events.append('compile')),
+            generate_code=Mock(side_effect=lambda: self.events.append('generate')),
+            create_boot_application=Mock(side_effect=lambda *args: self.events.append('boot')),
+        )
+        self.project = SimpleNamespace(
+            active_application=self.application,
+            add=Mock(),
+            save=Mock(),
+            close=Mock(side_effect=lambda: self.events.append('close')),
+        )
+
+        def opened(*args, **kwargs):
+            self.events.append('open')
+            return self.project
+
+        self.engine = SimpleNamespace(
+            projects=SimpleNamespace(
+                create=Mock(return_value=self.project),
+                open=Mock(side_effect=opened),
+            ),
+            device_repository=SimpleNamespace(
+                import_device=Mock(), sources=['repository'],
+                create_device_identification=lambda *identity: identity, get_device=Mock(return_value=object()),
+            ),
+            KindOfTask=SimpleNamespace(Cyclic='cyclic'),
+            Severity=SimpleNamespace(Error=1, FatalError=2),
+            ScriptPromptHandling=SimpleNamespace(LogPrompts='log'),
+            system=SimpleNamespace(
+                get_message_categories=lambda: ['compiler', 'libraries'],
+                get_message_objects=lambda category, severity: self.messages if category == 'libraries' else [],
+                clear_messages=lambda category: self.messages.clear(),
+                delay=Mock(side_effect=lambda duration: self.events.append('delay')),
+            ),
+        )
+
+    def test_compiles_published_program_for_each_controller_and_reopens_the_project(self):
+        verification.verify(self.engine)
+        self.assertEqual(
+            [call.kwargs['path'] for call in self.engine.device_repository.import_device.call_args_list],
+            [r'C:\codesys-device\codesyscontrol.devdesc.xml', r'C:\codesys-device-linux-sl\codesyscontrol.devdesc.xml'],
+        )
+        self.assertEqual([call.args for call in self.project.add.call_args_list], [
+            ('Device', 4096, '0000 1008', '4.22.0.0'), ('Device', 4102, '0000 0005', '4.22.0.0'),
+        ])
+        self.assertIn(
+            "{attribute 'symbol' := 'readwrite'}",
+            self.program.textual_declaration.replace.call_args.args[0],
+        )
+        self.assertEqual(self.task.kind_of_task, 'cyclic')
+        self.assertEqual(self.task.interval, '20')
+        self.task.pous.add.assert_called_with('PLC_PRG')
+        self.assertEqual(self.application.create_symbol_config.call_args.args[:2], (True, True))
+        self.assertEqual(self.events, [
+            'clean', 'compile', 'generate', 'boot', 'close',
+            'open', 'libraries', 'delay', 'close',
+            'clean', 'compile', 'generate', 'boot', 'close',
+        ])
+        self.manager.get_libraries.assert_called_with(recursive=True)
+
+    def test_reads_byte_addressing_like_codesys(self):
+        self.assertFalse(verification.uses_byte_addressing(DEVICE_DESCRIPTION))
+        self.assertTrue(verification.uses_byte_addressing(target_setting('byte-addressing', 'TRUE')))
+        self.assertFalse(verification.uses_byte_addressing(target_setting('byte-addressing', 'false')))
+        self.assertFalse(verification.uses_byte_addressing(target_setting('bit-byte-addressing', 'true')))
+
+    def test_rejects_a_controller_that_numbers_words_by_byte_before_importing_it(self):
+        self.description = target_setting('byte-addressing', 'true')
+        with self.assertRaisesRegex(RuntimeError, 'sets byte-addressing'):
+            verification.verify(self.engine)
+        self.engine.device_repository.import_device.assert_not_called()
+
+    def test_rejects_transitive_library_errors_reported_when_reopening_saved_project(self):
+        def report_late_errors(duration):
+            self.messages.append(SimpleNamespace(
+                text="Could not open library '#VisuShared'.",
+                project=SimpleNamespace(path=r'C:\Managed Libraries\AlarmManager.compiled-library-v3'),
+            ))
+        self.engine.system.delay.side_effect = report_late_errors
+        with self.assertRaisesRegex(
+            RuntimeError,
+            "AlarmManager.compiled-library-v3: Could not open library '#VisuShared'",
+        ):
+            verification.verify(self.engine)
+        self.engine.projects.open.assert_called_once()
+        self.assertEqual(self.project.close.call_count, 2)
+
+    def test_compile_error_stops_before_boot_artifact_and_saved_project_reopen(self):
+        self.application.rebuild.side_effect = lambda: self.messages.append(SimpleNamespace(text='Invalid source'))
+        with self.assertRaisesRegex(RuntimeError, 'Invalid source'):
+            verification.verify(self.engine)
+        self.application.generate_code.assert_not_called()
+        self.application.create_boot_application.assert_not_called()
+        self.engine.projects.open.assert_not_called()
+        self.project.close.assert_called_once()
+
+    def run_verifier_main(self):
+        owner = self
+
+        class Kernel:
+            @property
+            def ExitProcess(self):
+                owner.assertEqual(owner.events, [], 'Bind native exit before compiler work')
+                return lambda status: sys.exit(status)
+
+        output = io.StringIO()
+        errors = io.StringIO()
+        with patch.dict(sys.modules, {
+            'ctypes': SimpleNamespace(windll=SimpleNamespace(kernel32=Kernel())),
+            'scriptengine': self.engine,
+        }), redirect_stdout(output), redirect_stderr(errors):
+            with self.assertRaises(SystemExit) as exit:
+                runpy.run_path(str(path), run_name='__main__')
+        return exit.exception.code, output.getvalue(), errors.getvalue()
+
+    def test_main_prebinds_native_exit_and_returns_zero_after_verification(self):
+        status, output, errors = self.run_verifier_main()
+        self.assertEqual(status, 0)
+        self.assertIn('project reopen: PASS', output)
+        self.assertEqual(errors, '')
+
+    def test_main_keeps_compile_failure_and_returns_one_using_prebound_native_exit(self):
+        self.application.rebuild.side_effect = lambda: self.messages.append(SimpleNamespace(text='Invalid source'))
+        status, output, errors = self.run_verifier_main()
+        self.assertEqual(status, 1)
+        self.assertNotIn('PASS', output)
+        self.assertIn('Invalid source', errors)
+        self.application.create_boot_application.assert_not_called()
+
+
+class InstallerVerificationCommandTests(unittest.TestCase):
+    """Run the maintained shell gate with only Wine's process boundary replaced."""
+
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix='tsplc verification ')
+        self.addCleanup(temporary.cleanup)
+        self.root = Path(temporary.name)
+        self.prefix = self.root / 'wine prefix'
+        (self.prefix / 'drive_c').mkdir(parents=True)
+        self.calls = self.root / 'calls.jsonl'
+        timeout = self.root / 'timeout'
+        timeout.write_text(
+            '#!' + sys.executable + '\n'
+            'import json, os, pathlib, sys\n'
+            'prefix = pathlib.Path(os.environ["WINEPREFIX"]) / "drive_c"\n'
+            'for extension, content in json.loads(os.environ["TSPLC_VERIFICATION_FILES"]).items():\n'
+            ' (prefix / ("codesys-verification." + extension)).write_text(content)\n'
+            'with pathlib.Path(os.environ["TSPLC_VERIFICATION_CALLS"]).open("a") as output:\n'
+            ' output.write(json.dumps({"command": sys.argv[1:], "debug": os.environ["WINEDEBUG"]}) + "\\n")\n'
+            'pathlib.Path(sys.argv[-1]).write_text(os.environ["TSPLC_VERIFICATION_TRANSCRIPT"])\n'
+            'print("Fixture vendor verification result")\n'
+            'sys.exit(int(os.environ["TSPLC_VERIFICATION_STATUS"]))\n'
+        )
+        timeout.chmod(0o755)
+        wineserver = self.root / 'wineserver'
+        wineserver.write_text(
+            '#!' + sys.executable + '\n'
+            'import json, os, pathlib, sys\n'
+            'with pathlib.Path(os.environ["TSPLC_VERIFICATION_CALLS"]).open("a") as output:\n'
+            ' output.write(json.dumps({"wineserver": sys.argv[1:]}) + "\\n")\n'
+        )
+        wineserver.chmod(0o755)
+
+    def run_verifier(self, status=0, files=None, transcript='Fixture vendor verification result\n'):
+        if files is None:
+            files = {extension: 'Vendor artifact' for extension in ('project', 'app', 'crc')}
+        result = subprocess.run(
+            ['sh', str(path.with_name('verify.sh'))],
+            env={**os.environ, 'PATH': str(self.root) + os.pathsep + os.environ['PATH'],
+                'WINEPREFIX': str(self.prefix), 'TSPLC_VERIFICATION_STATUS': str(status),
+                'TSPLC_VERIFICATION_FILES': json.dumps(files),
+                'TSPLC_VERIFICATION_TRANSCRIPT': transcript,
+                'TSPLC_VERIFICATION_CALLS': str(self.calls)},
+            capture_output=True, text=True,
+        )
+        calls = [json.loads(line) for line in self.calls.read_text().splitlines()] if self.calls.exists() else []
+        return result, calls
+
+    def test_success_requires_all_boot_files_before_stopping_the_template_wine_server(self):
+        result, calls = self.run_verifier()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(calls[0]['debug'], '-all,err+seh')
+        self.assertEqual(calls[0]['command'], [
+            '--foreground', '15m', 'script', '-q', '-e', '-c',
+            "wine cmd /d /c 'C:\\verify.cmd'", str(self.prefix / 'drive_c' / 'codesys-verification.log'),
+        ])
+        self.assertEqual(calls[1:], [{'wineserver': ['-k']}, {'wineserver': ['-w']}])
+        command = (self.prefix / 'drive_c' / 'verify.cmd').read_text()
+        self.assertIn('--runscript="C:\\verify.py"', command)
+        self.assertEqual(command.splitlines()[-1], 'exit /b %errorlevel%')
+
+    def test_vendor_failure_is_preserved_even_when_old_boot_artifacts_exist(self):
+        for extension in ('project', 'app', 'crc'):
+            (self.prefix / 'drive_c' / ('codesys-verification.' + extension)).write_text('Old boot artifact')
+        result, calls = self.run_verifier(status=5, files={})
+        self.assertEqual(result.returncode, 5)
+        self.assertEqual(len(calls), 1)
+
+    def test_old_boot_artifacts_cannot_satisfy_a_process_that_skips_verification(self):
+        for extension in ('project', 'app', 'crc'):
+            (self.prefix / 'drive_c' / ('codesys-verification.' + extension)).write_text('Old boot artifact')
+        result, calls = self.run_verifier(files={})
+        self.assertEqual(result.returncode, 1)
+        self.assertEqual(len(calls), 1)
+
+    def test_native_signal_assertion_rejects_zero_exit_and_fresh_boot_artifacts(self):
+        for ending in ('\r\n', '\r\r\n'):
+            with self.subTest(line_ending=ending):
+                self.calls.write_text('')
+                transcript = ending.join([
+                    'assertion failed [x86_avx_state_ptr->xsave_header.xfeatures == kSupportedXFeatureBits]: ',
+                    '(ThreadContextSignals.cpp:414 rt_sigreturn)',
+                    'Compile complete -- 0 errors, 0 warnings',
+                    '',
+                ])
+                result, calls = self.run_verifier(transcript=transcript)
+                self.assertEqual(result.returncode, 1)
+                self.assertIn('Wine translation aborted', result.stderr)
+                self.assertIn('codesys-verification.log', result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual((self.prefix / 'drive_c' / 'codesys-verification.log').read_bytes().decode(), transcript)
+
+    def test_ordinary_compiler_assertion_text_does_not_match_native_signal_failure(self):
+        result, calls = self.run_verifier(transcript='Compiler diagnostic: assertion failed\n')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len(calls), 3)
+
+    def test_missing_or_empty_boot_file_rejects_an_apparently_successful_vendor_exit(self):
+        for extension in ('project', 'app', 'crc'):
+            for content in (None, ''):
+                with self.subTest(extension=extension, content=content):
+                    for artifact in (self.prefix / 'drive_c').glob('codesys-verification.*'):
+                        artifact.unlink()
+                    self.calls.write_text('')
+                    files = {name: 'Vendor artifact' for name in ('project', 'app', 'crc')}
+                    if content is None:
+                        del files[extension]
+                    else:
+                        files[extension] = content
+                    result, calls = self.run_verifier(files=files)
+                    self.assertEqual(result.returncode, 1)
+                    self.assertEqual(len(calls), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/python/test_worker.py

@@ -0,0 +1,142 @@
+import builtins
+import contextlib
+import io
+import json
+import os
+import runpy
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+from build import CompilerError
+from worker import serve
+
+
+class WorkerTests(unittest.TestCase):
+	def run_worker(self, actions, compile):
+		with tempfile.TemporaryDirectory() as temporary:
+			root = Path(temporary)
+			session = root / "build" / ".codesys" / "worker"
+			session.mkdir(parents=True)
+			commands = []
+			for index, action in enumerate(actions + ["stop"]):
+				command = {"id": str(index), "action": action}
+				if action == "build":
+					output = session.parent / "build"
+					output.mkdir(exist_ok=True)
+					(output / "request.json").write_text(json.dumps({
+						"mode": "build", "objects": [], "project": "BottlingLine.project",
+						
+						"output": "runtime/Application.app", "receipt": "compiled.json",
+						"template": "Template.project", "templateHash": "template-fixture",
+					}))
+				commands.append(command)
+			pending = iter(commands)
+			def wait(milliseconds):
+				(session / "request.json").write_text(json.dumps(next(pending)))
+			engine = SimpleNamespace(system=SimpleNamespace(delay=wait))
+			with patch("worker.build", side_effect=compile):
+				serve(engine, str(session))
+			responses = [json.loads((session / (command["id"] + ".json")).read_text()) for command in commands]
+			errors = [path.read_text() for path in (session.parent / "build").glob("error.txt")]
+			return responses, errors
+
+	def test_handles_multiple_builds_and_health_checks_without_exiting(self):
+		requests = []
+		def compile(engine, request, loaded, workspace):
+			requests.append(request)
+		responses, errors = self.run_worker(["ping", "build", "ping", "build"], compile)
+		self.assertTrue(all(response["ok"] for response in responses))
+		self.assertEqual(errors, [])
+		self.assertEqual(len(requests), 2)
+		self.assertEqual(requests[0]["project"], requests[1]["project"])
+		for request in requests:
+			project = Path(request["project"])
+			self.assertTrue(project.is_absolute())
+			self.assertEqual(Path(request["template"]).parent, project.parent)
+			self.assertEqual(Path(request["output"]).parent.parent, project.parent)
+
+	def test_reports_a_failed_build_and_processes_the_next_request(self):
+		failure = "Fixture compiler failure after writing a receipt"
+		requests = []
+		def compile(engine, request, loaded, workspace):
+			requests.append(request)
+			if len(requests) == 1:
+				Path(request["receipt"]).write_text(json.dumps({"mode": "build"}))
+				raise RuntimeError(failure)
+		responses, errors = self.run_worker(["build", "build"], compile)
+		self.assertFalse(responses[0]["ok"])
+		self.assertIn(failure, responses[0]["error"])
+		self.assertTrue(responses[1]["ok"])
+		self.assertTrue(responses[2]["ok"])
+		self.assertEqual(len(errors), 1)
+		self.assertIn(failure, errors[0])
+
+	def test_preserves_structured_compiler_diagnostics_in_failure_response(self):
+		diagnostics = [{"text": "Invalid type", "position": "18446744073709551615", "positionText": "vendor context", "object": None}]
+		def compile(engine, request, loaded, workspace):
+			raise CompilerError(diagnostics)
+		responses, errors = self.run_worker(["build", "ping"], compile)
+		self.assertEqual(responses[0]["diagnostics"], diagnostics)
+		self.assertIn("Invalid type", responses[0]["error"])
+		self.assertTrue(responses[1]["ok"])
+		self.assertIn("Invalid type", errors[0])
+
+
+class WorkerMainTests(unittest.TestCase):
+	def test_native_exit_is_preloaded_before_serving_and_preserves_success_and_failure(self):
+		worker_path = Path(__file__).with_name("worker.py").resolve()
+		for native in (True, False):
+			for invalid in (True, False):
+				with self.subTest(native=native, invalid=invalid), tempfile.TemporaryDirectory() as temporary:
+					root = Path(temporary)
+					(root / "request.json").write_text("{invalid" if invalid else json.dumps({"id": "stop", "action": "stop"}))
+					phase = "startup"
+					events = []
+					def exited(api, code):
+						events.append((api, phase, code))
+						raise SystemExit(code)
+					class NativeLibrary:
+						@property
+						def ExitProcess(self):
+							events.append(("bind", phase))
+							return lambda code: exited("native", code)
+					ctypes = SimpleNamespace(windll=SimpleNamespace(kernel32=NativeLibrary()))
+					engine = SimpleNamespace(
+						system=SimpleNamespace(exit=lambda code: exited("scriptengine", code)),
+						ScriptPromptHandling=SimpleNamespace(LogPrompts="LogPrompts"))
+					actual_import = builtins.__import__
+					def imported(name, *args, **kwargs):
+						if name == "ctypes":
+							events.append(("import", phase))
+							return ctypes
+						return actual_import(name, *args, **kwargs)
+					def profiled(frame, event, _argument):
+						nonlocal phase
+						if frame.f_code.co_filename == str(worker_path) and frame.f_code.co_name == "serve":
+							if event == "call": phase = "serving"
+							elif event == "return": phase = "after-serve"
+					previous_profile = sys.getprofile()
+					previous_path = list(sys.path)
+					try:
+						with patch.dict(sys.modules, {"scriptengine": engine}), patch.dict(os.environ, {
+							"CODESYS_BUILD_SESSION": str(root), "CODESYS_BUILD_NATIVE_EXIT": str(native).lower(),
+						}), patch("builtins.__import__", side_effect=imported), contextlib.redirect_stderr(io.StringIO()):
+							sys.setprofile(profiled)
+							with self.assertRaises(SystemExit) as result:
+								runpy.run_path(str(worker_path), run_name="__main__")
+					finally:
+						sys.setprofile(previous_profile)
+						sys.path[:] = previous_path
+					self.assertEqual(result.exception.code, int(invalid))
+					self.assertEqual(events, ([
+						("import", "startup"), ("bind", "startup"), ("native", "after-serve", int(invalid)),
+					] if native else [("scriptengine", "after-serve", int(invalid))]))
+					if not invalid:
+						self.assertEqual(json.loads((root / "stop.json").read_text()), {"id": "stop", "ok": True})
+
+
+if __name__ == "__main__":
+	unittest.main()

package/python/worker.py

@@ -0,0 +1,102 @@
+"""One long-lived script inside CODESYS; all engine calls stay on its script thread."""
+from __future__ import print_function
+
+import io
+import json
+import os
+import traceback
+
+if __name__ == "__main__":
+	import sys
+
+	sys.path.insert(0, os.environ["CODESYS_BUILD_SESSION"])
+from build import CompilerError, build
+
+
+def write_json(path, value):
+	# The client reads only complete replies. Each request has a unique filename.
+	with io.open(path + ".tmp", "w", encoding="utf-8") as output:
+		output.write(u"{0}".format(json.dumps(value, ensure_ascii=False)))
+	os.rename(path + ".tmp", path)
+
+
+def run_build(engine, directory, loaded):
+	root = os.path.join(os.path.dirname(directory), "build")
+	with io.open(os.path.join(root, "request.json"), "r", encoding="utf-8") as source:
+		request = json.load(source)
+	for key in ("template", "project", "output", "receipt"):
+		request[key] = os.path.join(root, request[key])
+	try:
+		build(engine, request, loaded, directory)
+	except Exception:
+		with io.open(os.path.join(root, "error.txt"), "w", encoding="utf-8") as output:
+			output.write(u"{0}".format(traceback.format_exc()))
+		raise
+
+
+def serve(engine, directory):
+	request_path = os.path.join(directory, "request.json")
+	loaded = {}
+	while True:
+		if not os.path.isfile(request_path):
+			# Unlike time.sleep, this keeps CODESYS's message loop responsive.
+			engine.system.delay(200)
+			continue
+		with io.open(request_path, "r", encoding="utf-8") as source:
+			command = json.load(source)
+		os.remove(request_path)
+		response = {"id": command["id"], "ok": True}
+		try:
+			if command["action"] == "build":
+				run_build(engine, directory, loaded)
+			elif command["action"] == "online":
+				from codesys_online import run_online
+				if loaded.get("project") is not None:
+					loaded["project"].close()
+				loaded.clear()
+				root = os.path.join(os.path.dirname(directory), "controller")
+				with io.open(os.path.join(root, "request.json"), encoding="utf-8") as source:
+					request = json.load(source)
+				write_json(os.path.join(root, "result.json"), run_online(engine, request))
+			elif command["action"] == "login":
+				from codesys_login import close_login, open_login, run_command
+				arguments = command["arguments"]
+				if arguments["command"] == "open":
+					if loaded.get("project") is not None:
+						loaded["project"].close()
+					loaded.clear()
+					loaded["login"] = open_login(engine, arguments)
+					response["result"] = run_command(engine, loaded["login"], {"command": "state"})
+				elif arguments["command"] == "close":
+					close_login(loaded.pop("login"))
+				else:
+					response["result"] = run_command(engine, loaded["login"], arguments)
+			elif command["action"] not in ("ping", "stop"):
+				raise ValueError("Unknown worker action")
+		except Exception as error:
+			response = {"id": command["id"], "ok": False, "error": traceback.format_exc()}
+			if isinstance(error, CompilerError):
+				response["diagnostics"] = error.diagnostics
+		write_json(os.path.join(directory, command["id"] + ".json"), response)
+		if command["action"] == "stop":
+			return
+
+
+if __name__ == "__main__":
+	import scriptengine
+	scriptengine.system.script_prompt_handling = scriptengine.ScriptPromptHandling.LogPrompts
+	native_exit = None
+	if os.environ.get("CODESYS_BUILD_NATIVE_EXIT") == "true":
+		# Import and bind while the engine is starting. A late IronPython import
+		# after serving builds can fault in the runtime's debug-info rewriter.
+		import ctypes
+		native_exit = ctypes.windll.kernel32.ExitProcess
+	exit_code = 0
+	try:
+		serve(scriptengine, os.environ["CODESYS_BUILD_SESSION"])
+	except Exception:
+		traceback.print_exc()
+		exit_code = 1
+	if native_exit is not None:
+		native_exit(exit_code)
+	scriptengine.system.exit(exit_code)

package/runtime/install.sh

@@ -0,0 +1,74 @@
+#!/bin/sh
+set -eu
+
+application_name=$1
+source_application=${2:-Application}
+config_dir=/conf/codesyscontrol
+data_dir=/data/codesyscontrol
+config_file=$config_dir/CODESYSControl_User.cfg
+
+test -d "$config_dir"
+test -d "$data_dir"
+test -s "/codesys-build/$source_application.app"
+test -s "/codesys-build/$source_application.crc"
+
+# Match the Virtual Control image's first-start initialization before installing
+# the application. Existing configuration, device users, licenses and data survive.
+if [ ! -f "$config_dir/.docker_initialized" ]; then
+	for file in CODESYSControl.cfg CODESYSControl_User.cfg; do
+		if [ ! -f "$config_dir/$file" ]; then
+			cp "/etc/codesyscontrol/$file" "$config_dir/$file"
+		fi
+	done
+	touch "$config_dir/.docker_initialized"
+fi
+if [ ! -f "$data_dir/.docker_initialized" ]; then
+	cp -a /var/opt/codesys/. "$data_dir/"
+	touch "$data_dir/.docker_initialized"
+fi
+
+# Register the boot application once, retaining other applications and settings.
+# Read the full section first so a new application index cannot overwrite one.
+cp -p "$config_file" "$config_file.codesys-build.tmp"
+awk -v application="$application_name" '
+{
+	if (FNR == 1) in_app = 0
+	if (FILENAME == ARGV[2]) lines[++count] = $0
+	line = $0
+	sub(/\r$/, "", line)
+	gsub(/^[ \t]+|[ \t]+$/, "", line)
+	if (line ~ /^\[/) in_app = (line == "[CmpApp]")
+	if (in_app && line ~ /^Application\.[0-9]+[ \t]*=/) {
+		split(line, parts, "=")
+		index_text = parts[1]
+		sub(/^Application\./, "", index_text)
+		if (index_text + 0 > maximum) maximum = index_text + 0
+		value = parts[2]
+		gsub(/^[ \t]+|[ \t]+$/, "", value)
+		applications[index_text + 0] = value
+	}
+}
+END {
+	# User configuration overrides the base file for the same Application.N key.
+	for (application_index in applications) {
+		if (applications[application_index] == application) registered = 1
+	}
+	for (i = 1; i <= count; i++) {
+		print lines[i]
+		if (!registered && lines[i] ~ /^[ \t]*\[CmpApp\][ \t]*\r?$/) {
+			print "Application." (maximum + 1) "=" application
+			registered = 1
+		}
+	}
+	if (!registered) print "\n[CmpApp]\nApplication." (maximum + 1) "=" application
+}' "$config_dir/CODESYSControl.cfg" "$config_file" > "$config_file.codesys-build.tmp"
+mv "$config_file.codesys-build.tmp" "$config_file"
+
+# The runtime stays stopped until both boot files are installed. Keep retain files
+# and application-owned data; this is a cold deployment, not an online change.
+application_dir=$data_dir/PlcLogic/$application_name
+mkdir -p "$application_dir"
+for extension in app crc; do
+	cp "/codesys-build/$source_application.$extension" "$application_dir/$application_name.$extension.tmp"
+	mv "$application_dir/$application_name.$extension.tmp" "$application_dir/$application_name.$extension"
+done

package/src/__tests__/fixtures/xml/fb-simple.xml

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<project xmlns="http://www.plcopen.org/xml/tc6_0200" xmlns:xhtml="http://www.w3.org/1999/xhtml">
+  <fileHeader companyName="" productName="CODESYS" productVersion="CODESYS V3.5 SP21" creationDateTime="<NORMALIZED>" />
+  <contentHeader name="FB_Simple" modificationDateTime="<NORMALIZED>">
+    <coordinateInfo>
+      <fbd><scaling x="1" y="1" /></fbd>
+      <ld><scaling x="1" y="1" /></ld>
+      <sfc><scaling x="1" y="1" /></sfc>
+    </coordinateInfo>
+  </contentHeader>
+  <types>
+    <dataTypes />
+    <pous>
+      <pou name="FB_Simple" pouType="functionBlock">
+        <interface>
+        <inputVars>
+          <variable name="bEnable">
+            <type><BOOL /></type>
+            <documentation><xhtml xmlns="http://www.w3.org/1999/xhtml">Enable command</xhtml></documentation>
+          </variable>
+        </inputVars>
+        <outputVars>
+          <variable name="bDone">
+            <type><BOOL /></type>
+            <documentation><xhtml xmlns="http://www.w3.org/1999/xhtml">Done flag</xhtml></documentation>
+          </variable>
+        </outputVars>
+      </interface>
+        <body>
+          <ST>
+            <xhtml xmlns="http://www.w3.org/1999/xhtml"><![CDATA[bDone := bEnable;]]></xhtml>
+          </ST>
+        </body>
+      </pou>
+    </pous>
+  </types>
+  <instances>
+    <configurations />
+  </instances>
+</project>