@tsplc/build 0.0.0-stage → 0.2.0

package/python/codesys_login.py

@@ -0,0 +1,100 @@
+"""A long-lived login to the downloaded application; executed by CODESYS's IronPython engine."""
+from __future__ import print_function
+
+from codesys_online import (connect_controller, controller_ids, controller_state, core_application,
+                            load_downloaded_reference, session_login)
+
+
+def open_login(engine, request):
+    """Log in to the controller's running application without changing it.
+
+    The project is a copy of the downloaded baseline, so the login never offers
+    a download: the controller and the compiler reference must both match it.
+    """
+    baseline = request['baseline']
+    project = engine.projects.open(request['project'], primary=True)
+    online_app = None
+    try:
+        application = project.active_application
+        if application is None or str(application.guid) != baseline['applicationGuid']:
+            raise RuntimeError('The saved project does not contain the downloaded application')
+        connect_controller(engine, application, request['online'])
+        online_app = engine.online.create_online_application(application)
+        core = core_application(online_app)
+        session_login(core)
+        try:
+            if controller_ids(core) != baseline['controllerIds']:
+                raise RuntimeError('The controller runs a different application than the last deployment')
+            if load_downloaded_reference(application) != baseline['controllerIds']:
+                raise RuntimeError('Downloaded compiler reference differs from the controller')
+        finally:
+            core.Logout()
+        # The core login, unlike the scripting wrapper's, never creates or downloads an application.
+        if not core.Login(True):
+            raise RuntimeError('Controller application disappeared before login')
+    except Exception:
+        if online_app is not None:
+            online_app.Dispose()
+        project.close()
+        raise
+    return {'project': project, 'online': online_app, 'core': core}
+
+
+def apply_prepared(online_app, prepared, operation):
+    try:
+        operation()
+    except Exception as error:
+        failed = getattr(error, 'failed_expressions', None)
+        if failed is None:
+            raise
+        raise RuntimeError('The controller rejected ' + ', '.join(str(expression) for expression in failed))
+    finally:
+        # An unapplied preparation would otherwise ride along with the next write or force.
+        for expression in prepared:
+            online_app.set_prepared_value(expression, None)
+
+
+def run_command(engine, login, command):
+    online_app = login['online']
+    name = command['command']
+    if name == 'read':
+        return {'values': {expression: online_app.read_value(expression) for expression in command['expressions']}}
+    if name in ('write', 'force'):
+        values = command['values']
+        if name == 'write':
+            # The controller rejects writing a forced variable with only a generic error.
+            forced = set(str(expression).lower() for expression in online_app.get_forced_expressions())
+            blocked = [expression for expression in values if expression.lower() in forced]
+            if blocked:
+                raise RuntimeError(', '.join(blocked) + ' is forced; unforce it before writing')
+        for expression, value in values.items():
+            online_app.set_prepared_value(expression, value)
+        apply_prepared(online_app, values.keys(),
+                       online_app.write_prepared_values if name == 'write' else online_app.force_prepared_values)
+    elif name == 'unforce':
+        expressions = command['expressions']
+        if expressions:
+            for expression in expressions:
+                online_app.set_unforce_value(expression, command['restore'])
+            # CODESYS applies prepared unforces with its force command.
+            apply_prepared(online_app, expressions, online_app.force_prepared_values)
+        else:
+            apply_prepared(online_app, [], online_app.unforce_all_values)
+    elif name == 'start':
+        online_app.start()
+    elif name == 'stop':
+        online_app.stop()
+    elif name == 'reset':
+        online_app.reset(getattr(engine.ResetOption, command['kind']))
+    elif name != 'state':
+        raise ValueError('Unknown login command: ' + name)
+    return {'state': controller_state(login['core']),
+            'forced': [str(expression) for expression in online_app.get_forced_expressions()]}
+
+
+def close_login(login):
+    try:
+        login['online'].logout()
+        login['online'].Dispose()
+    finally:
+        login['project'].close()

package/python/codesys_online.py

@@ -0,0 +1,327 @@
+"""CODESYS 3.5.22.30 online operations; executed by its IronPython engine."""
+from __future__ import print_function
+
+import io
+import json
+import os
+import re
+import time
+from build import CompilerError, apply_controller, fail_on_errors, import_objects, reported_errors, unique_child
+from System import Activator, AppDomain, Array, Enum, Environment, Object
+from System.Net import Dns, IPAddress
+from System.Reflection import BindingFlags, TargetInvocationException
+
+
+def core_application(online_application):
+    # The shipped scripting wrapper omits Keep from its login switch. Its core
+    # application provides a session-only login, which never compiles/downloads.
+    # This narrow bridge is pinned to the scripting version in our Docker image.
+    kind = online_application.GetType()
+    if kind.FullName != '_3S.CoDeSys.ScriptDriverOnline.OnlineApplication' or str(kind.Assembly.GetName().Version) != '4.2.0.0':
+        raise RuntimeError('Unsupported CODESYS online scripting implementation')
+    prop = kind.GetProperty('Application', BindingFlags.Instance | BindingFlags.NonPublic)
+    if prop is None:
+        raise RuntimeError('CODESYS session-only application API is unavailable')
+    return prop.GetValue(online_application, None)
+
+
+def loaded_type(name):
+    for assembly in AppDomain.CurrentDomain.GetAssemblies():
+        kind = assembly.GetType(name, False)
+        if kind is not None:
+            return kind
+    raise RuntimeError('CODESYS API type is unavailable: ' + name)
+
+
+def session_login(core):
+    kind = loaded_type('_3S.CoDeSys.OnlineManager.OnlineApplicationLoginConfiguration')
+    config = Activator.CreateInstance(kind)
+    mode = loaded_type('_3S.CoDeSys.Core.Online.ApplicationLoginClientModes')
+    kind.GetProperty('ClientModes').SetValue(config, Enum.Parse(mode, 'ReadOnly'), None)
+    api = loaded_type('_3S.CoDeSys.Core.Online.IOnlineApplication23')
+    login = api.GetMethod('Login')
+    if not login.Invoke(core, Array[Object]([True, config])):
+        raise RuntimeError('The controller does not contain this application')
+
+
+def controller_ids(core):
+    ids = {'codeId': str(core.CodeId), 'dataId': str(core.DataId)}
+    if any(value == '00000000-0000-0000-0000-000000000000' for value in ids.values()):
+        raise RuntimeError('Controller application has no downloaded code/data identity')
+    return ids
+
+
+def controller_state(core):
+    # Login updates IDs synchronously, but ApplicationState is timer-owned.
+    # Query the original device's application-list service for a fresh state.
+    name_property = core.GetType().GetProperty('ApplicationName', BindingFlags.Instance | BindingFlags.NonPublic)
+    name = str(name_property.GetValue(core, None))
+    api = loaded_type('_3S.CoDeSys.Core.Online.IOnlineDevice6')
+    arguments = Array[Object]([None, None])
+    api.GetMethod('ReadApplicationList').Invoke(core.OnlineDevice, arguments)
+    names, states = arguments[0], arguments[1]
+    if names is None or states is None or len(names) != len(states):
+        raise RuntimeError('Controller returned an incomplete application-state list')
+    found = [str(states[index]) for index in range(len(names)) if str(names[index]) == name]
+    if len(found) != 1 or found[0] == 'unknown':
+        raise RuntimeError('Controller application state is unavailable: ' + name)
+    return found[0]
+
+
+def require_current_boot_project(core):
+    arguments = Array[Object]([False, False])
+    api = loaded_type('_3S.CoDeSys.Core.Online.IOnlineApplication8')
+    api.GetMethod('CheckFileConsistency').Invoke(core, arguments)
+    if not arguments[0]:
+        raise RuntimeError('Controller boot project does not match the downloaded application')
+
+
+def create_controller_boot_project(core):
+    # Reflection retains the CLR stack IronPython otherwise maps to ValueError.
+    api = loaded_type('_3S.CoDeSys.Core.Online.IOnlineApplication3')
+    try:
+        api.GetMethod('CreateBootProject').Invoke(core, None)
+    except TargetInvocationException as error:
+        cause = error.InnerException if error.InnerException is not None else error
+        raise RuntimeError('Controller boot project creation failed:\n' + cause.ToString())
+
+
+def generate_online_code(application):
+    environment = loaded_type('_3S.CoDeSys.ScriptDriverOnline.APEnvironment')
+    prop = environment.GetProperty('LanguageModelMgr', BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+    manager = prop.GetValue(None, None)
+    if not manager.GenerateCode(application.guid, True, False):
+        raise RuntimeError('CODESYS cannot generate an online change for this source')
+
+
+def consolidated_manager():
+    kind = loaded_type('_3S.CoDeSys.LanguageModelManager.LanguageModelManagerConsolidated')
+    return kind.GetProperty('_LMM', BindingFlags.Static | BindingFlags.NonPublic).GetValue(None, None)
+
+
+def context_ids(context):
+    if context is None:
+        raise RuntimeError('Compiler context is unavailable')
+    ids = {'codeId': str(context.CodeId), 'dataId': str(context.DataId)}
+    if any(value == '00000000-0000-0000-0000-000000000000' for value in ids.values()):
+        raise RuntimeError('Compiler context has no generated code/data identity')
+    return ids
+
+
+def load_downloaded_reference(application):
+    # Background reference loading may not have populated the language model
+    # when a new headless worker receives its first operation. This original
+    # synchronous path reads the candidate's saved compileinfo without building.
+    context = consolidated_manager().GetReferenceContextSynchronLoad(application.guid)
+    if context is None:
+        raise RuntimeError('Downloaded compiler reference could not be loaded')
+    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.
+
+    Logging in to a Linux SL controller loads its device's visualization placeholders, which
+    nothing in a tsPLC project resolves. The application compiled without them, so the
+    engineering session reports them rather than failing a completed transfer.
+    """
+    errors, unresolved = [], []
+    for error in reported_errors(engine):
+        placeholder = re.match(r"Could not open library '(#[^']+)'.*could not be resolved", error['text'])
+        if placeholder:
+            unresolved.append(placeholder.group(1))
+        else:
+            errors.append(error)
+    if unresolved:
+        progress('Ignoring library placeholders the login loaded but nothing resolves: ' + ', '.join(unresolved))
+    if errors:
+        raise CompilerError(errors)
+
+
+def connect_controller(engine, application, settings):
+    """Route the application's controller through the configured gateway; returns it and its credentials."""
+    device = application.parent
+    while device is not None and not getattr(device, 'is_device', False):
+        device = device.parent
+    if device is None:
+        raise RuntimeError('Application has no controller device')
+    gateway_ip = str(Dns.GetHostAddresses(settings['gateway']['host'])[0])
+    device_ip = str(Dns.GetHostAddresses(settings['device']['host'])[0])
+    gateway = engine.online.gateways.add_new_gateway('codesys-build', {0: gateway_ip, 1: settings['gateway']['port']})
+    device.set_gateway_and_ip_address(gateway.guid, IPAddress.Parse(device_ip), settings['device']['port'])
+    credentials = settings.get('credentials')
+    if not credentials:
+        return device, None
+    username, password = (os.environ.get(credentials[key]) for key in ('usernameEnv', 'passwordEnv'))
+    if not username or not password:
+        raise RuntimeError('CODESYS online credential environment variables are required')
+    engine.online.set_specific_credentials(device, username, password)
+    return device, (username, password)
+
+
+def run_online(engine, request):
+    progress_path = request.get('progress')
+    def progress(stage):
+        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)
+    application = project.active_application
+    online_app = None
+    online_device = None
+    try:
+        progress('Project opened; configuring controller connection')
+        if application is None:
+            raise RuntimeError('Project has no active Application')
+        device, credentials = connect_controller(engine, application, request['online'])
+        online_device = engine.online.create_online_device(device)
+        if request.get('initializeUser'):
+            if request['operation'] != 'download' or not credentials:
+                raise RuntimeError('Initial controller user requires an explicit download and credentials')
+            online_device.set_credentials_for_initial_user(*credentials)
+        progress('Controller connection configured')
+        previous = request.get('baseline')
+        if request['operation'] != 'download':
+            online_app = engine.online.create_online_application(application)
+            core = core_application(online_app)
+            if not previous or str(application.guid) != previous['applicationGuid']:
+                raise RuntimeError('Online change requires the saved downloaded application')
+            progress('Checking downloaded controller identity and state')
+            session_login(core)
+            try:
+                observed = controller_ids(core)
+                if observed != previous['controllerIds']:
+                    raise RuntimeError('Controller application differs from the saved baseline; use an explicit download')
+                progress('Loading downloaded compiler reference')
+                if load_downloaded_reference(application) != observed:
+                    raise RuntimeError('Downloaded compiler reference differs from the controller; use an explicit download')
+                progress('Downloaded compiler reference loaded')
+                state = controller_state(core)
+                if request['operation'] == 'online-change' and state != 'run':
+                    raise RuntimeError('Online change requires a running application')
+                if request['operation'] == 'inspect':
+                    return {'applicationGuid': str(application.guid), 'controllerIds': observed,
+                            '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)
+        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}'))
+        # Match the normal build's source/template lifecycle. Saving the edited
+        # tree and clearing editor-load diagnostics happens before compilation.
+        project.save()
+        for category in engine.system.get_message_categories():
+            engine.system.clear_messages(category)
+        if request['operation'] == 'download':
+            # A full download replaces the previous compiler model. Use the
+            # normal build's clean/rebuild path before opening the online session.
+            progress('Rebuilding application for full download')
+            application.clean()
+            application.rebuild()
+            fail_on_errors(engine)
+            application.generate_code()
+            project.save()
+        else:
+            # Cleaning would discard the downloaded reference needed to decide
+            # whether a source edit can be applied as an online change.
+            progress('Building application incrementally for online change')
+            application.build()
+        fail_on_errors(engine)
+        if request['operation'] == 'download':
+            online_app = engine.online.create_online_application(application)
+            core = core_application(online_app)
+            progress('Downloading application')
+            online_app.login(engine.OnlineChangeOption.Never, False)
+            expected = controller_ids(core)
+            if controller_state(core) != 'run':
+                online_app.start()
+        else:
+            # Stay on the session-only/core route. High-level scripting Force
+            # still auto-creates absent applications; this route never creates
+            # an application and passes True explicitly to the download service.
+            progress('Rechecking controller identity before online change')
+            if not core.Login(True):
+                raise RuntimeError('Controller application disappeared before the online change')
+            if controller_ids(core) != previous['controllerIds']:
+                raise RuntimeError('Controller application changed before the online change')
+            expected = controller_ids(core)
+            if not application.is_uptodate:
+                if not application.is_online_change_possible:
+                    raise RuntimeError('CODESYS cannot apply this source as an online change; use an explicit download')
+                progress('Generating online-change code')
+                generate_online_code(application)
+                fail_on_errors(engine)
+                expected = context_ids(consolidated_manager().GetCompileContext(application.guid))
+                mode = loaded_type('_3S.CoDeSys.Core.Online.BootProjectTransferMode')
+                progress('Applying online change')
+                core.Download(True, Enum.Parse(mode, 'UseProjectSetting'))
+        # An online-change transfer does not itself replace the boot project.
+        # The original online boot command saves the downloaded application;
+        # Boot-only host preparation saves the accepted application separately
+        # from the live transfer; it does not issue a controller full download.
+        progress('Saving running application as controller boot project')
+        create_controller_boot_project(core)
+        require_current_boot_project(core)
+        progress('Confirming activated code/data identity with a fresh controller login')
+        core.Logout()
+        session_login(core)
+        if controller_ids(core) != expected:
+            raise RuntimeError('Controller did not retain the downloaded code/data identity')
+        fail_on_errors_after_transfer(engine, progress)
+        ids = controller_ids(core)
+        state = controller_state(core)
+        if state != 'run':
+            raise RuntimeError('Controller is not running after the operation')
+        progress('Reading controller values')
+        result = {'applicationGuid': str(application.guid), 'controllerIds': ids,
+                  'state': state, 'application': application.get_name(),
+                  'values': {expression: online_app.read_value(expression) for expression in request.get('read', [])}}
+        online_app.logout()
+        progress('Saving downloaded project')
+        project.save()
+        return result
+    finally:
+        if online_app is not None:
+            online_app.Dispose()
+        if online_device is not None:
+            online_device.Dispose()
+        # The original language-model manager joins its asynchronous downloaded
+        # reference saver on project close. Publication happens after this returns.
+        progress('Closing project and waiting for downloaded reference')
+        project.close()
+        progress('Project closed')