Implement ensure_connected configuration option

DeviceManagerSource now accepts ensure_connected boolean option.
When enabled any failure to build or connect a device will result in
an exception.

Author: rtuck99

helm/blueapi/config_schema.json

@@ -91,6 +91,12 @@
                     "description": "Name of the device manager in the module",
                     "title": "Name",
                     "type": "string"
+                },
+                "ensure_connected": {
+                    "default": false,
+                    "description": "If true, all devices must be successfully connected at startup.",
+                    "title": "Ensure Connected",
+                    "type": "boolean"
                 }
             },
             "required": [

helm/blueapi/values.schema.json

@@ -510,6 +510,12 @@
                 "module"
             ],
             "properties": {
+                "ensure_connected": {
+                    "title": "Ensure Connected",
+                    "description": "If true, all devices must be successfully connected at startup.",
+                    "default": false,
+                    "type": "boolean"
+                },
                 "kind": {
                     "title": "Kind",
                     "default": "deviceManager",

src/blueapi/config.py

@@ -83,6 +83,10 @@ class DeviceManagerSource(Source):
     name: str = Field(
         default="devices", description="Name of the device manager in the module"
     )
+    ensure_connected: bool = Field(
+        default=False,
+        description="If true, all devices must be successfully connected at startup.",
+    )
 
 
 class TcpUrl(AnyUrl):

src/blueapi/core/context.py

@@ -214,13 +214,21 @@ def with_config(self, config: EnvironmentConfig) -> None:
                     self.with_device_module(mod)
                 case DodalSource(mock=mock):
                     self.with_dodal_module(mod, mock=mock)
-                case DeviceManagerSource(mock=mock, name=name):
+                case DeviceManagerSource(
+                    mock=mock, name=name, ensure_connected=ensure_connected
+                ):
                     manager = getattr(mod, name)
                     if not isinstance(manager, DeviceManager):
                         raise ValueError(
                             f"{name} in module {mod} is not a device manager"
                         )
-                    self.with_device_manager(manager, mock)
+                    device_map, error_map = self.with_device_manager(manager, mock)
+                    if ensure_connected and error_map:
+                        raise ExceptionGroup(
+                            "Errors occurred while connecting the following devices: "
+                            f"{', '.join(error_map.keys())}",
+                            list(error_map.values()),
+                        )
 
     def with_plan_module(self, module: ModuleType) -> None:
         """

tests/unit_tests/core/test_context.py

@@ -20,6 +20,7 @@
 from dodal.common import PlanGenerator, inject
 from ophyd import Device
 from ophyd_async.core import (
+    NotConnectedError,
     PathProvider,
     StandardDetector,
     StaticPathProvider,
@@ -153,6 +154,20 @@ def devicey_context(sim_motor: Motor, sim_detector: StandardDetector) -> Bluesky
     return ctx
 
 
+@pytest.fixture
+def beamline_with_connection_and_build_errors():
+    stm = StaticDeviceManager(
+        devices={},
+        build_errors={"foo": RuntimeError("Simulated Build Error")},
+        connection_errors={"bar": NotConnectedError("Simulated Connection Error")},
+    )
+    dev_mod = Mock(spec=ModuleType)
+    dev_mod.devices = stm
+    with patch("blueapi.core.context.import_module") as imp_mod:
+        imp_mod.side_effect = lambda mod: dev_mod if mod == "foo.bar" else None
+        yield
+
+
 class SomeConfigurable:
     def read_configuration(self) -> SyncOrAsync[dict[str, Reading]]:
         return {}
@@ -425,6 +440,28 @@ def test_with_config_passes_mock_to_with_dodal_module(
         mock_with_dodal_module.assert_called_once_with(ANY, mock=mock)
 
 
+def test_with_config_raises_exception_group_on_connection_errors_when_ensure_connected(
+    empty_context: BlueskyContext, beamline_with_connection_and_build_errors: None
+):
+    with pytest.raises(ExceptionGroup, match="Errors occurred while connecting.*") as e:
+        empty_context.with_config(
+            EnvironmentConfig(
+                sources=[DeviceManagerSource(module="foo.bar", ensure_connected=True)]
+            )
+        )
+
+    assert e.value.exceptions[0].args[0] == "Simulated Build Error"
+    assert e.value.exceptions[1].args[0] == "Simulated Connection Error"
+
+
+def test_with_config_ignores_build_connect_exceptions_by_default(
+    empty_context: BlueskyContext, beamline_with_connection_and_build_errors: None
+):
+    empty_context.with_config(
+        EnvironmentConfig(sources=[DeviceManagerSource(module="foo.bar")])
+    )
+
+
 def test_function_spec(empty_context: BlueskyContext):
     spec = empty_context._type_spec_for_function(has_some_params)
     assert spec["foo"][0] is int