manager: Optionally restore matcher sources and bridge status on instantation

src/calng/CalibrationManager.py

@@ -6,6 +6,7 @@
 
 from asyncio import gather, wait_for, TimeoutError as AsyncTimeoutError
 from collections import defaultdict
+from datetime import datetime
 from traceback import format_exc
 from urllib.parse import urlparse
 import json
@@ -20,7 +21,7 @@ from karabo.middlelayer import (
     AccessMode, AccessLevel, Assignment, DaqPolicy, State, Unit,
     UInt16, Int32, UInt32, Bool, Double, String, VectorString, VectorHash,
     background, callNoWait, setNoWait, sleep, instantiate, slot, coslot,
-    getTopology)
+    getDevice, getTopology, getConfigurationFromPast)
 
 from karabo import version as karaboVersion
 from ._version import version as deviceVersion
@@ -423,6 +424,21 @@ class CalibrationManager(DeviceClientBase, Device):
         self.state = State.CHANGING
         background(self._instantiate_pipeline())
 
+    restoreMatcherSources = Bool(
+        displayedName='Restore matcher sources',
+        description='Attempt to retrieve and restore the last known '
+                    'configuration for slow and fast sources of matcher '
+                    'devices when the pipeline is instantiated.',
+        defaultValue=False,
+        accessMode=AccessMode.RECONFIGURABLE)
+
+    autoActivateBridges = Bool(
+        displayedName='Activate bridges automatically',
+        description='Whether to activate all group bridges immediately '
+                    'after instantation',
+        defaultValue=True,
+        accessMode=AccessMode.RECONFIGURABLE)
+
     # TODO: Inject at runtime by scanning correction device schema.
     runtimeParameters = Node(
         RuntimeParametersNode,
@@ -799,13 +815,13 @@ class CalibrationManager(DeviceClientBase, Device):
             msg = await wait_for(instantiate(
                 server, class_id, device_id, config), 5.0)
         except AsyncTimeoutError:
-            return self._set_error(f'Instantiation timeout on {device_id}')
+            self._set_error(f'Instantiation timeout on {device_id}')
+            return False
         except KaraboError as e:
-            return self._set_exception(
-                f'Instantiation error on {device_id}', e)
-        else:
-            self.logger.debug(f'Instantation result for {device_id}: {msg}')
+            self._set_exception(f'Instantiation error on {device_id}', e)
+            return False
 
+        self.logger.debug(f'Instantation result for {device_id}: {msg}')
         return True
 
     async def _instantiate_pipeline(self):
@@ -921,6 +937,17 @@ class CalibrationManager(DeviceClientBase, Device):
                     for vname in modules_by_group[group]]
                 config['pathToStack'] = 'image.data'
 
+                if self.restoreMatcherSources:
+                    try:
+                        old_config = await getConfigurationFromPast(
+                            matcher_device_id, datetime.now().isoformat())
+                    except KaraboError:
+                        pass  # Ignore configuration on error
+                    else:
+                        config['channels'] = old_config['channels']
+                        config['slowSources'] = old_config['slowSources']
+                        config['fastSources'] = old_config['fastSources']
+
                 if not await self._instantiate_device(
                     server, class_ids['groupMatcher'],
                     matcher_device_id, config
@@ -943,6 +970,17 @@ class CalibrationManager(DeviceClientBase, Device):
                     server, class_ids['bridge'], bridge_device_id, config
                 ):
                     return
+                elif self.autoActivateBridges:
+                    # Delay the slot a bit since it will get lost during
+                    # instantation.
+
+                    async def _activate_bridge(device_id):
+                        with await getDevice(device_id) as device:
+                            await sleep(3)
+                            if device.state == State.PASSIVE:
+                                await device.activate()
+
+                    background(_activate_bridge(bridge_device_id))
 
         # Instantiate preview layer matchers and assemblers.
         for layer, output_pipeline, server in self.previewLayers.value: