@tsplc/build 0.2.6 → 0.2.7

package/python/codesys_online.py

@@ -6,7 +6,8 @@ import json
 import os
 import re
 import time
-from build import CompilerError, apply_controller, configure_device_tree, fail_on_errors, import_objects, reported_errors, unique_child, verify_pinned
+from build import CompilerError, fail_on_errors, import_objects, keep_device_tree, open_template, reconcile, reported_errors
+from hardware import verify_pinned
 from System import Activator, AppDomain, Array, Enum, Environment, Object
 from System.Net import Dns, IPAddress
 from System.Reflection import BindingFlags, TargetInvocationException
@@ -118,34 +119,6 @@ def load_downloaded_reference(application):
     return context_ids(context)
 
 
-def remove_deleted(parent, previous, current):
-    """Reconcile only source-owned objects; preserve GUIDs of unchanged objects."""
-    new = {item['name'].lower(): item for item in current}
-    for old in previous:
-        obj = unique_child(parent, old['name'])
-        fresh = new.get(old['name'].lower())
-        if obj is None:
-            raise RuntimeError('Saved source object is missing: ' + old['name'])
-        if fresh is None or old['kind'] != fresh['kind'] or bool(old.get('persistent')) != bool(fresh.get('persistent')):
-            obj.remove()
-        else:
-            remove_deleted(obj, old.get('children', []), fresh.get('children', []))
-
-
-def reconcile(application, previous, current):
-    # A folder move changes placement rather than text. Remove/recreate just
-    # that moved object, letting the vendor decide whether the update is valid.
-    new = {(tuple(item['folder']), item['name'].lower()): item for item in current}
-    for old in previous:
-        parent = application
-        for name in old['folder']:
-            parent = unique_child(parent, name)
-            if parent is None:
-                raise RuntimeError('Saved source folder is missing: ' + name)
-        fresh = new.get((tuple(old['folder']), old['name'].lower()))
-        remove_deleted(parent, [old], [fresh] if fresh else [])
-
-
 def fail_on_errors_after_transfer(engine, progress):
     """Like fail_on_errors, once the controller runs the verified application.
 
@@ -193,11 +166,14 @@ def run_online(engine, request):
         if progress_path:
             with io.open(progress_path, 'a', encoding='utf-8') as output:
                 output.write(u'{0}Z {1}\n'.format(time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime()), stage))
-    progress('Opening project; processor count {0}'.format(Environment.ProcessorCount))
-    project = engine.projects.open(request['project'], primary=True)
-    # Online changes reuse the downloaded project, which already has this controller.
-    if request['operation'] == 'download' and request.get('controller'):
-        apply_controller(project, request['controller'], progress)
+    progress('Starting; processor count {0}'.format(Environment.ProcessorCount))
+    # A download starts from the template; online changes reuse the downloaded project, which has its controller and tree.
+    if request['operation'] == 'download':
+        project, pinned, generated = open_template(engine, request, request['project'], request.get('devices'), request['caches'], progress)
+    else:
+        progress('Opening project')
+        project = engine.projects.open(request['project'], primary=True)
+        pinned, generated = {}, None
     application = project.active_application
     online_app = None
     online_device = None
@@ -236,12 +212,12 @@ def run_online(engine, request):
                             'state': state, 'values': {expression: online_app.read_value(expression) for expression in request.get('read', [])}}
             finally:
                 core.Logout()
-        if request['operation'] == 'online-change':
-            reconcile(application, previous['objects'], request['objects'])
-        import_objects(engine, application, request, request['operation'] != 'download', progress)
-        # Only a download carries the tree: it starts from the template, and an online change keeps the downloaded one.
-        pinned = configure_device_tree(engine, project, request['deviceTree'], request['devices'], progress) \
-            if request.get('deviceTree') else {}
+        # A download starts from the template; an online change writes only what changed since the baseline.
+        held = previous['objects'] if request['operation'] == 'online-change' else None
+        gone = reconcile(application, held, request['objects']) if held is not None else []
+        import_objects(engine, application, request, held, progress)
+        for obj in gone:
+            obj.remove()
         if request['symbols'] and not any(getattr(child, 'is_symbol_config', False) for child in application.get_children()):
             from System import Guid
             application.create_symbol_config(True, True, Guid('{0141eb75-141b-4ea1-9a8c-75f952b22a6c}'))
@@ -318,6 +294,8 @@ def run_online(engine, request):
         online_app.logout()
         progress('Saving downloaded project')
         project.save()
+        if generated:
+            keep_device_tree(*generated)
         return result
     finally:
         if online_app is not None:

package/python/hardware.py

@@ -0,0 +1,261 @@
+"""The controller and its device tree, which a build generates once and caches by this file's hash.
+Runs inside CODESYS's Python engine, not the Mac's Python installation."""
+from __future__ import print_function
+
+import os
+import re
+
+try:
+	unicode
+except NameError:
+	unicode = str
+
+
+# CODESYS EDS Import's converter factory; plain import_device expects device XML.
+EDS_CONVERTER = "1ce4a9c1-37d3-496c-9e80-cd99ad3807ee"
+ETHERNET = ("Ethernet", 110, "0000 0002", "4.2.0.0")
+SCANNER = ("EtherNet_IP_Scanner", 100, "0000 100B", "4.9.0.0")
+# Ethernet adapter interface settings and EtherNet/IP adapter parameter IDs.
+# The interface name is a STRING (10) and a WSTRING (12); the device editor and runtime read the WSTRING.
+ETHERNET_PARAMETERS = (("address", 0), ("subnet", 1), ("gateway", 2), ("interface", 10), ("interface", 12))
+TARGET_ADDRESS = 256
+CONNECTION_SETTINGS = 268435457
+MODBUS_CLIENT = ("Modbus_TCP_Client", 88, "0000 0003", "4.6.0.0")
+MODBUS_SERVER = (89, "0000 0005", "4.6.0.0")
+MODBUS_EDITOR = r"C:\CODESYS-3.5.22.30\CODESYS\PlugIns\7e343689-9a5f-46aa-bf56-5903c4efec59\4.6.0.0\DeviceEditorModbus.plugin.dll"
+# Modbus client and server parameter IDs.
+MODBUS_AUTO_RECONNECT = 9002
+MODBUS_CHANNEL_STATUS = 9003
+MODBUS_ADDRESS = 9102
+MODBUS_PORT = 9103
+# The editor's parameter IDs for channel number n: n * 2^24 plus these.
+MODBUS_CHANNEL = 1 << 24
+MODBUS_TRIGGER = 0x200001
+MODBUS_STATUS = 0x200002
+MODBUS_REQUESTS = 0x200003
+MODBUS_HOLDING_WRITE = 0x840000
+MODBUS_WRITE_SINGLE_REGISTER = 6
+MODBUS_RISING_EDGE = 6
+
+
+def host_parameters(device):
+	connectors = [connector for connector in device.connectors if len(list(connector.host_parameters))]
+	if len(connectors) != 1:
+		raise RuntimeError("Expected one configurable connector on " + device.get_name())
+	return dict((parameter.id, parameter) for parameter in connectors[0].host_parameters)
+
+
+def child_device(engine, parent, spec):
+	name, kind, identifier, version = spec
+	parent.add(name, kind, identifier, version)
+	matches = [child for child in parent.find(name, False) if getattr(child, "is_device", False)]
+	if len(matches) != 1:
+		raise RuntimeError("Could not add device " + name)
+	return matches[0]
+
+
+def set_parameter(parameter, value):
+	parameter.value = value
+	if unicode(parameter.value).replace(" ", "") != unicode(value).replace(" ", ""):
+		raise RuntimeError("{0} reads back {1}, not {2}".format(parameter.visible_name, parameter.value, value))
+
+
+def string_literal(parameter, text):
+	return ('"{0}"' if parameter.type_string == "WSTRING" else "'{0}'").format(text)
+
+
+def ip_array(address, hexadecimal=False):
+	octets = [int(octet) for octet in address.split(".")]
+	return "[" + ",".join("16#{0:02X}".format(octet) if hexadecimal else str(octet) for octet in octets) + "]"
+
+
+def pin(channel, address):
+	# CODESYS validates a manual address against the automatic one until it is disabled.
+	channel.io_mapping.manual_iec_address = address
+	channel.io_mapping.automatic_iec_address = False
+
+
+def settle(pinned):
+	"""Pin only channels whose automatic address differs; each write revalidates the whole tree."""
+	for address, channel in sorted(pinned.items()):
+		# An automatic mapping reports its assigned address here.
+		if channel.io_mapping.manual_iec_address != address:
+			pin(channel, address)
+
+
+def pin_channels(engine, adapter, parameters, device):
+	"""Give each raw payload byte the address of its offset, so AT declarations read it."""
+	pinned = {}
+	for direction, region, kind in (("inputs", "I", engine.ChannelType.Input), ("outputs", "Q", engine.ChannelType.Output)):
+		channels = sorted((parameter for parameter in parameters.values() if parameter.channel_type == kind), key=lambda parameter: parameter.id)
+		area = device.get(direction)
+		if not area:
+			if channels:
+				raise RuntimeError("{0} has {1} without a configured address".format(device["name"], direction))
+			continue
+		if len(channels) != area["size"] or any(channel.bit_size != 8 for channel in channels):
+			raise RuntimeError("{0} {1} are not {2} raw byte channels".format(device["name"], direction, area["size"]))
+		base = int(area["address"][3:])
+		# Later automatic channels follow the first one consecutively.
+		pin(channels[0], "%{0}B{1}".format(region, base))
+		for offset, channel in enumerate(channels):
+			pinned["%{0}B{1}".format(region, base + offset)] = channel
+	settle(pinned)
+	return pinned
+
+
+def channel_at(pinned, address):
+	if address in pinned:
+		return pinned[address]
+	match = re.match(r"^%([IQ])(X|B)(\d+)(?:\.([0-7]))?$", address)
+	channel = pinned.get("%{0}B{1}".format(match.group(1), match.group(3)))
+	if channel is None:
+		raise RuntimeError("No generated channel at " + address)
+	return list(channel)[int(match.group(4))] if match.group(2) == "X" else channel
+
+
+def map_channels(pinned, tree, application):
+	"""Map bound bits and bytes to their variables; comment the channels of IO that keeps AT."""
+	mapped = set()
+	for mapping in tree.get("mappings", []):
+		channel_at(pinned, mapping["address"]).io_mapping.variable = application + "." + mapping["variable"]
+		mapped.add(mapping["address"])
+	for device in tree["devices"]:
+		for comment in device.get("comments", []):
+			if comment["address"] not in mapped:
+				channel_at(pinned, comment["address"]).user_comment = comment["text"]
+
+
+def add_modbus_channel(project, server, register):
+	"""Add a write channel with the editor's own routine: CODESYS scripting has no API for channels."""
+	from System import Activator, Array, Enum, Object, UInt16, UInt32
+	from System.Reflection import Assembly, BindingFlags
+	flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static
+	editor = Assembly.LoadFrom(MODBUS_EDITOR)
+	def named(name):
+		return editor.GetType("_3S.CoDeSys.DeviceEditorModbus." + name, True)
+	def call(owner, target, name, *arguments):
+		return owner.GetMethod(name, flags).Invoke(target, Array[Object](list(arguments)))
+	manager = named("APEnvironment").GetProperty("ObjectMgr", flags).GetValue(None, None)
+	meta = manager.GetObjectToModify(project.handle, server.guid)
+	connector = [item for item in meta.Object.Connectors if str(item.ConnectorRole) == "Child"][0]
+	data = call(named("New.ChannelDataBase"), None, "Create", connector)
+	item_type = named("ModbusChannelItem")
+	item = Activator.CreateInstance(item_type)
+	fields = (
+		("stName", register["name"]),
+		("usFunctionCode", UInt16(MODBUS_WRITE_SINGLE_REGISTER)),
+		("usWriteOffset", UInt16(register["offset"])),
+		("usWriteLength", UInt16(1)),
+		("usReadLength", UInt16(0)),
+		("triggerType", Enum.ToObject(named("TriggerType"), MODBUS_RISING_EDGE)),
+		("uiParamID", call(data.GetType(), data, "GetNextAvailableParamID", call(data.GetType(), data, "LoadSlaveChannels", connector))),
+	)
+	for name, value in fields:
+		item_type.GetField(name).SetValue(item, value)
+	factory = call(named("New.PresetFactory"), None, "Create", connector, False)
+	call(data.GetType(), data, "CreateSlaveChannel", connector, item, factory)
+	manager.SetObject(meta, True, None)
+	return int(UInt32(item_type.GetField("uiParamID").GetValue(item))) // MODBUS_CHANNEL
+
+
+def configure_modbus(engine, project, ethernet, devices):
+	"""One Modbus TCP server per card with registers, with channels pinned like the EtherNet/IP bytes."""
+	pinned = {}
+	client = child_device(engine, ethernet, MODBUS_CLIENT)
+	parameters = host_parameters(client)
+	# The line runs unattended, so a card that restarts must come back on its own.
+	set_parameter(parameters[MODBUS_AUTO_RECONNECT], "TRUE")
+	# Status and request count are how the program learns a write finished.
+	set_parameter(parameters[MODBUS_CHANNEL_STATUS], "TRUE")
+	for device in devices:
+		server = child_device(engine, client, (device["name"] + "_Modbus",) + MODBUS_SERVER)
+		server.driver_info.always_update_variables = engine.AlwaysUpdateVariablesMode.OnlyIfUnused
+		parameters = host_parameters(server)
+		set_parameter(parameters[MODBUS_ADDRESS], ip_array(device["address"]))
+		set_parameter(parameters[MODBUS_PORT], str(device["modbus"]["port"]))
+		for register in device["modbus"]["registers"]:
+			channel = add_modbus_channel(project, server, register) * MODBUS_CHANNEL
+			parameters = host_parameters(server)
+			pinned[register["write"]] = parameters[channel + MODBUS_TRIGGER]
+			pinned[register["status"]] = parameters[channel + MODBUS_STATUS]
+			pinned[register["requests"]] = parameters[channel + MODBUS_REQUESTS]
+			pinned[register["value"]] = parameters[channel + MODBUS_HOLDING_WRITE + register["offset"]]
+	settle(pinned)
+	return pinned
+
+
+def template_controller(project):
+	controllers = [child for child in project.get_children() if getattr(child, "is_device", False)]
+	if len(controllers) != 1:
+		raise RuntimeError("The template must contain one controller device")
+	return controllers[0]
+
+
+def apply_controller(project, identity, progress):
+	controller = template_controller(project)
+	wanted = (identity["type"], identity["id"], identity["version"])
+	current = controller.get_device_identification()
+	if (current.type, current.id, current.version) == wanted:
+		return
+	progress("Updating controller to {0} {1} {2}".format(*wanted))
+	# Update Device keeps the Application and its children under the new device.
+	controller.update(*wanted)
+	updated = controller.get_device_identification()
+	if (updated.type, updated.id, updated.version) != wanted:
+		raise RuntimeError("CODESYS kept controller {0} {1} {2}; install the device description for {3} {4} {5}".format(
+			updated.type, updated.id, updated.version, *wanted))
+
+
+def import_device_description(engine, device, root):
+	from System import Guid
+	repository = engine.device_repository
+	identity = repository.import_device(os.path.join(root, device["eds"]), repository.sources[0], Guid(EDS_CONVERTER), True)
+	if identity is None:
+		raise RuntimeError("CODESYS could not import the EDS of " + device["name"])
+	return identity
+
+
+def configure_device_tree(engine, project, tree, root, progress):
+	controller = template_controller(project)
+	for child in controller.get_children(True):
+		if getattr(child, "is_device", False) and child.get_device_identification().type in (ETHERNET[1], SCANNER[1]):
+			raise RuntimeError("Template already configures " + child.get_name() + "; remove it or codesys.deviceTree")
+	progress("Generating EtherNet/IP device tree")
+	ethernet = child_device(engine, controller, ETHERNET)
+	parameters = host_parameters(ethernet)
+	for key, identifier in ETHERNET_PARAMETERS:
+		value = tree.get("ethernet", {}).get(key)
+		if value is not None:
+			set_parameter(parameters[identifier], string_literal(parameters[identifier], value) if key == "interface" else ip_array(value))
+	scanner = child_device(engine, ethernet, SCANNER)
+	pinned = {}
+	for device in tree["devices"]:
+		identity = import_device_description(engine, device, root)
+		adapter = child_device(engine, scanner, (device["name"], identity.type, identity.id, identity.version))
+		# CODESYS otherwise skips mapped variables no IEC code reads, such as inputs only clients observe.
+		adapter.driver_info.always_update_variables = engine.AlwaysUpdateVariablesMode.OnlyIfUnused
+		parameters = host_parameters(adapter)
+		if device.get("address"):
+			set_parameter(parameters[TARGET_ADDRESS], ip_array(device["address"], True))
+		if device.get("rpiMicroseconds"):
+			fields = [field for field in parameters[CONNECTION_SETTINGS] if field.identifier == "RPI"]
+			set_parameter(fields[0], str(device["rpiMicroseconds"]))
+		for address, channel in pin_channels(engine, adapter, parameters, device).items():
+			if address in pinned:
+				raise RuntimeError("{0} overlaps another adapter".format(address))
+			pinned[address] = channel
+	registers = [device for device in tree["devices"] if device.get("modbus")]
+	if registers:
+		progress("Generating Modbus TCP devices")
+		pinned.update(configure_modbus(engine, project, ethernet, registers))
+	# Adding a later adapter can reflow earlier automatic addresses.
+	settle(pinned)
+	map_channels(pinned, tree, project.active_application.get_name())
+	return pinned
+
+
+def verify_pinned(pinned):
+	for address, channel in pinned.items():
+		if channel.io_mapping.manual_iec_address != address:
+			raise RuntimeError("Channel {0} moved to {1}".format(address, channel.io_mapping.manual_iec_address))

package/python/test_build.py

@@ -1,5 +1,6 @@
 import hashlib
 import json
+import re
 import tempfile
 import unittest
 from pathlib import Path
@@ -74,6 +75,19 @@ class Node:
 		return prop
 
 
+def snapshot(node):
+	"""What a saved project keeps of an object tree."""
+	return dict(name=node.name, kind=node.kind, declaration=node.declaration, implementation=node.implementation,
+		children=[snapshot(child) for child in node.children])
+
+
+def restore(saved, parent=None):
+	node = Node(saved["name"], saved["kind"], parent)
+	node.declaration, node.implementation = saved["declaration"], saved["implementation"]
+	node.children = [restore(child, node) for child in saved["children"]]
+	return node
+
+
 class Controller:
 	"""The template's controller; Update Device succeeds only for installed descriptions."""
 	is_device = True
@@ -109,25 +123,32 @@ class CompilerFixture:
 			system=SimpleNamespace(get_message_categories=lambda: ["compiler"], get_message_objects=lambda category, severity: [], clear_messages=Mock()),
 		)
 	def open(self, path, primary):
-		app = Node("Application", "application")
-		configuration = app.create_task_configuration()
-		configuration.create_task("MainTask")
-		background = configuration.create_task("BackgroundTask")
-		background.children.clear()
-		background.pous.add("Monitor")
-		app.create("Monitor", "program")
-		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")
+		saved = Path(path).read_text()
+		if saved.startswith("{"):
+			saved = json.loads(saved)
+			app = restore(saved["application"])
+			controller.identity = SimpleNamespace(**saved["controller"])
+		else:
+			app = Node("Application", "application")
+			configuration = app.create_task_configuration()
+			configuration.create_task("MainTask")
+			background = configuration.create_task("BackgroundTask")
+			background.children.clear()
+			background.pous.add("Monitor")
+			app.create("Monitor", "program")
+			app.create("Symbols", "symbols")
+			app.create("PLC_PRG", "program")
+			for name, task, call in self.device_tasks:
+				cycle = configuration.create_task(task)
+				cycle.children.clear()
+				cycle.create(call, "task_call")
+		app.parent = controller
 		project = SimpleNamespace(path=path, close=Mock(), active_application=app, controller=controller,
 			get_children=lambda: [controller])
-		def save(): Path(project.path).write_text("compiled project")
+		def save(): Path(project.path).write_text(json.dumps(dict(application=snapshot(app), controller=vars(controller.identity))))
 		def save_as(destination):
 			project.path = destination
 			save()
@@ -242,7 +263,8 @@ class BuildTests(unittest.TestCase):
 			self.run_build(tasks=[dict(name="MainTask", intervalNanoseconds="20000000", priority=1, programs=["Main"])])
 	def test_reuses_the_loaded_project_for_text_changes(self):
 		self.run_build()
-		self.objects[0]["implementation"] = "NewBody();"
+		# Each request is read afresh, so a change never reaches the specs of the last build.
+		self.objects = [dict(self.objects[0], implementation="NewBody();")]
 		self.run_build()
 		self.assertEqual(len(self.compiler.opened), 1)
 		self.assertEqual(self.find("Main").implementation, "NewBody();")
@@ -339,6 +361,72 @@ class BuildTests(unittest.TestCase):
 		self.assertEqual(len(list((self.root / "device-tree").iterdir())), 1)
 		self.assertEqual(self.tree_build(moved)[0], 0)
 
+	def written(self, request):
+		log = (Path(request["receipt"]).parent / "progress.log").read_text()
+		return int(re.search(r"Wrote (\d+) source objects", log).group(1))
+
+	def test_a_later_container_writes_only_the_objects_that_changed(self):
+		self.objects.append(spec("function_block", "FB_Test", [spec("method", "Run", implementation="RETURN;")], implementation=""))
+		self.assertEqual(self.written(self.run_build()), 3)
+		self.loaded = {}
+		self.objects = [self.objects[0], dict(self.objects[1], children=[spec("method", "Run", implementation="Changed();")])]
+		self.assertEqual(self.written(self.run_build()), 1)
+		self.assertEqual(self.find("Run").implementation, "Changed();")
+
+	def test_a_later_container_removes_deleted_objects_and_creates_new_ones(self):
+		self.objects.append(spec("function", "F_Old", implementation="RETURN;", folder=["old"]))
+		self.run_build()
+		self.loaded = {}
+		self.objects = [self.objects[0], spec("function", "F_New", implementation="RETURN;")]
+		self.assertEqual(self.written(self.run_build()), 1)
+		app = self.loaded["project"].active_application
+		self.assertEqual(app.find_ignore_transient_objects("F_Old", True), [])
+		self.assertEqual(self.find("F_New").implementation, "RETURN;")
+
+	def test_a_later_container_removes_a_deleted_type_only_after_the_import_stops_using_it(self):
+		self.objects = [spec("dut", "T_Old", dutType="alias"), dict(self.objects[0], declaration="PROGRAM Main VAR x : T_Old; END_VAR")]
+		self.run_build()
+		self.loaded = {}
+		self.objects = [spec("dut", "T_New", dutType="alias"), dict(self.objects[1], declaration="PROGRAM Main VAR x : T_New; END_VAR")]
+		open_project = self.compiler.engine.projects.open
+
+		def open_refusing_types_in_use(path, primary):
+			project = open_project(path, primary)
+			app = project.active_application
+			old = app.find_ignore_transient_objects("T_Old", True)[0]
+
+			def remove():
+				# CODESYS refuses to remove a type the source still uses.
+				if "T_Old" in app.find_ignore_transient_objects("Main", True)[0].declaration:
+					raise TypeError("Value cannot be null.")
+				app.children.remove(old)
+
+			old.remove = remove
+			return project
+
+		self.compiler.engine.projects.open = open_refusing_types_in_use
+		self.run_build()
+		self.assertEqual(self.loaded["project"].active_application.find_ignore_transient_objects("T_Old", True), [])
+
+	def test_a_template_change_imports_everything_into_the_new_template(self):
+		self.objects.append(spec("gvl", "Globals"))
+		self.run_build()
+		self.loaded = {}
+		self.template.write_text("changed template")
+		self.assertEqual(self.written(self.run_build()), 2)
+
+	def test_a_failed_build_leaves_the_last_successful_one_to_reuse(self):
+		self.run_build()
+		self.loaded = {}
+		self.objects = [dict(self.objects[0], implementation="Broken(")]
+		self.compiler.fail_compile = True
+		with self.assertRaisesRegex(RuntimeError, "Fixture compiler error"):
+			self.run_build()
+		self.loaded, self.compiler.fail_compile = {}, False
+		self.objects = [dict(self.objects[0], implementation="Fixed();")]
+		self.assertEqual(self.written(self.run_build()), 1)
+		self.assertEqual(self.find("Main").implementation, "Fixed();")
+
 	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
@@ -452,7 +540,7 @@ class DeviceTreeTests(unittest.TestCase):
 		return dict((channel.id, channel) for channel in reversed(channels))
 
 	def test_pins_payload_bytes_at_their_offsets_and_labels_bound_io(self):
-		from build import map_channels, pin_channels, verify_pinned
+		from hardware import map_channels, pin_channels, verify_pinned
 		parameters = self.parameters(3, 2)
 		# Automatic addresses that already follow the first channel stay automatic.
 		parameters[101].io_mapping.address = "%IB17"
@@ -480,7 +568,7 @@ class DeviceTreeTests(unittest.TestCase):
 			verify_pinned(pinned)
 
 	def test_rejects_typed_channels_and_unplaced_directions(self):
-		from build import pin_channels
+		from hardware import pin_channels
 		with self.assertRaisesRegex(RuntimeError, "reader inputs are not 2 raw byte channels"):
 			pin_channels(self.engine, None, self.parameters(2, 0, 16), {"name": "reader", "inputs": {"address": "%IB0", "size": 2}})
 		with self.assertRaisesRegex(RuntimeError, "reader has outputs without a configured address"):

package/python/test_codesys_online.py

@@ -80,10 +80,12 @@ class OnlineLifecycleTests(unittest.TestCase):
         def imported(*args):
             self.events.append('import')
             self.source_imported = True
+        # A download's template, with the channels its tree pinned and the tree to keep once it works.
+        self.template = (self.project, {}, None)
         replacements = {
-            'apply_controller': Mock(side_effect=lambda *args: self.events.append('controller')),
+            'open_template': Mock(side_effect=lambda *args: self.events.append('template') or self.template),
+            'keep_device_tree': Mock(),
             '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(),
@@ -91,7 +93,7 @@ class OnlineLifecycleTests(unittest.TestCase):
             'controller_state': Mock(return_value='run'),
             'require_current_boot_project': Mock(),
             'load_downloaded_reference': Mock(return_value=self.ids),
-            'reconcile': Mock(),
+            'reconcile': Mock(return_value=[]),
             'generate_online_code': Mock(),
             'consolidated_manager': Mock(return_value=SimpleNamespace(GetCompileContext=Mock())),
             'context_ids': Mock(return_value=self.ids),
@@ -102,7 +104,7 @@ class OnlineLifecycleTests(unittest.TestCase):
         patcher.start()
         self.addCleanup(patcher.stop)
         self.request = {
-            'project': 'Application.project', 'operation': 'download', 'symbols': False,
+            'project': 'Application.project', 'operation': 'download', 'symbols': False, 'caches': 'C:\\controller',
             'objects': [], 'removeObjects': ['Visualization Manager'],
             'online': {'gateway': {'host': 'gateway', 'port': 1217},
                        'device': {'host': 'plc', 'port': 11740}},
@@ -110,7 +112,8 @@ class OnlineLifecycleTests(unittest.TestCase):
 
     def test_download_rebuilds_imported_tree_before_online_login(self):
         result = codesys_online.run_online(self.engine, self.request)
-        self.assertEqual(self.events, ['import', 'clean', 'compile', 'generate', 'online-wrapper'])
+        self.assertIsNone(codesys_online.import_objects.call_args.args[3])
+        self.assertEqual(self.events, ['template', 'import', 'clean', 'compile', 'generate', 'online-wrapper'])
         self.assertEqual(result['controllerIds'], self.ids)
         self.core.CreateBootProject.assert_called_once()
         self.boot_api.GetMethod.assert_called_once_with('CreateBootProject')
@@ -118,17 +121,22 @@ 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):
+    def test_download_imports_into_the_templates_tree_verifies_its_channels_and_keeps_it(self):
         self.request.update(deviceTree={'devices': []}, devices='C:\\request')
+        self.template = (self.project, {'%IB0': 'channel'}, ('pending', 'cache'))
         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'))
+        self.assertEqual(self.events[:2], ['template', 'import'])
+        self.assertEqual(codesys_online.open_template.call_args.args[2:4], ('Application.project', 'C:\\request'))
+        self.assertEqual(codesys_online.open_template.call_args.args[4], 'C:\\controller')
         codesys_online.verify_pinned.assert_called_once_with({'%IB0': 'channel'})
+        codesys_online.keep_device_tree.assert_called_once_with('pending', 'cache')
 
-    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)
-        self.assertEqual(self.events[:2], ['controller', 'import'])
+    def test_failed_download_keeps_no_generated_tree(self):
+        self.template = (self.project, {}, ('pending', 'cache'))
+        self.app.rebuild.side_effect = RuntimeError('Invalid source declaration')
+        with self.assertRaisesRegex(RuntimeError, 'Invalid source declaration'):
+            codesys_online.run_online(self.engine, self.request)
+        codesys_online.keep_device_tree.assert_not_called()
 
     def test_invalid_full_download_source_never_creates_online_wrapper_or_transfers(self):
         self.app.rebuild.side_effect = RuntimeError('Invalid source declaration')
@@ -147,12 +155,23 @@ class OnlineLifecycleTests(unittest.TestCase):
         })
         result = codesys_online.run_online(self.engine, self.request)
         self.assertEqual(self.events, ['online-wrapper', 'import', 'compile'])
+        codesys_online.open_template.assert_not_called()
+        # Only what changed since the baseline is written.
+        self.assertIs(codesys_online.import_objects.call_args.args[3], self.request['baseline']['objects'])
         self.app.clean.assert_not_called()
         self.app.rebuild.assert_not_called()
         self.app.generate_code.assert_not_called()
         self.core.Download.assert_called_once_with(True, 'UseProjectSetting')
         self.assertEqual(result['state'], 'run')
 
+    def test_online_change_removes_deleted_objects_once_the_import_replaced_their_users(self):
+        self.request.update(operation='online-change', baseline={
+            'applicationGuid': self.app.guid, 'controllerIds': self.ids, 'objects': [],
+        })
+        codesys_online.reconcile.return_value = [SimpleNamespace(remove=lambda: self.events.append('remove'))]
+        codesys_online.run_online(self.engine, self.request)
+        self.assertEqual(self.events, ['online-wrapper', 'import', 'remove', 'compile'])
+
     def test_full_download_rejects_library_errors_reported_after_transfer(self):
         def report_library_error(core):
             self.messages.append(SimpleNamespace(text="Could not open library '#VisuShared'."))