bec-server 4.1.2__tar.gz → 4.1.3__tar.gz

{bec_server-4.1.2 → bec_server-4.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec-server
-Version: 4.1.2
+Version: 4.1.3
 Summary: BEC server
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_server-4.1.2 → bec_server-4.1.3}/bec_server/file_writer/async_writer.py

@@ -111,6 +111,7 @@ class AsyncWriter(threading.Thread):
         self._written_signals = defaultdict(set)
         self.file_handle = None
         self.cursor = defaultdict(dict)
+        self.error_info: messages.ErrorInfo | None = None
 
     @property
     def written_signals(self) -> dict[str, list[str]]:
@@ -215,13 +216,13 @@ class AsyncWriter(threading.Thread):
         # pylint: disable=broad-except
         except Exception:
             content = traceback.format_exc()
-            # self.send_file_message(done=True, successful=False)
             logger.error(f"Error writing async data file {self.tmp_file_path}: {content}")
             error_info = messages.ErrorInfo(
                 error_message=f"Error writing async data file {self.tmp_file_path}",
                 compact_error_message=traceback.format_exc(limit=0),
                 exception_type="AsyncWriterError",
             )
+            self.error_info = error_info
             self.connector.raise_alarm(
                 severity=Alarms.WARNING,
                 info=error_info,

{bec_server-4.1.2 → bec_server-4.1.3}/bec_server/file_writer/file_writer_manager.py

@@ -422,6 +422,8 @@ class FileWriterManager(BECService):
         file_suffix = "master"
 
         start_time = time.time()
+        successful = storage.async_writer is None or storage.async_writer.error_info is None
+        file_handle = None
 
         try:
             file_path = get_full_path(
@@ -429,7 +431,6 @@ class FileWriterManager(BECService):
                 name=file_suffix,
                 log_if_dir_does_not_exist=False,
             )
-            successful = True
             written_async_signals = (
                 storage.async_writer.written_signals if storage.async_writer else None
             )
@@ -491,6 +492,9 @@ class FileWriterManager(BECService):
             expire=3600,
         )
 
+        if not successful:
+            return
+
         history_msg = messages.ScanHistoryMessage(
             scan_id=scan_id,
             scan_number=storage.scan_number,
@@ -509,6 +513,4 @@ class FileWriterManager(BECService):
         self.connector.xadd(
             topic=MessageEndpoints.scan_history(), msg_dict={"data": history_msg}, max_size=10000
         )
-        if successful:
-            logger.success(f"Finished writing file {file_path}.")
-            return
+        logger.success(f"Finished writing file {file_path}.")

{bec_server-4.1.2 → bec_server-4.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec-server"
-version = "4.1.2"
+version = "4.1.3"
 description = "BEC server"
 requires-python = ">=3.11"
 classifiers = [

{bec_server-4.1.2 → bec_server-4.1.3}/tests/tests_device_server/test_device_manager_ds.py

@@ -12,6 +12,7 @@ from ophyd_devices.tests.utils import patched_device
 
 from bec_lib import messages
 from bec_lib.bec_errors import DeviceConfigError
+from bec_lib.connector import MessageObject
 from bec_lib.endpoints import MessageEndpoints
 from bec_server.device_server.devices.config_update_handler import ConfigUpdateHandler
 from bec_server.device_server.devices.devicemanager import DeviceManagerDS
@@ -20,6 +21,32 @@ from bec_server.device_server.devices.devicemanager import DeviceManagerDS
 # pylint: disable=protected-access
 
 
+@pytest.mark.parametrize("device_manager_class", [DeviceManagerDS])
+@pytest.mark.parametrize("metadata", [{}, {"RID": "reload-request"}])
+def test_reload_notification_does_not_change_device_server_status(device_manager, metadata):
+    device_manager._service._service_name = "DeviceServer"
+    msg = messages.DeviceConfigMessage(action="reload", config={}, metadata=metadata)
+    with (
+        mock.patch.object(device_manager, "update_status") as update_status,
+        mock.patch.object(device_manager, "_reload_action") as reload_action,
+        mock.patch.object(device_manager.connector, "lpush") as lpush,
+    ):
+        device_manager._device_config_update_callback(MessageObject(value=msg, topic=""))
+
+    update_status.assert_not_called()
+    reload_action.assert_not_called()
+    if metadata:
+        lpush.assert_called_once_with(
+            MessageEndpoints.service_response(metadata["RID"]),
+            messages.ServiceResponseMessage(
+                response={"accepted": True, "service": device_manager._service._service_name}
+            ),
+            expire=100,
+        )
+    else:
+        lpush.assert_not_called()
+
+
 @pytest.fixture
 def dm_with_devices_and_status(dm_with_devices):
     """

{bec_server-4.1.2 → bec_server-4.1.3}/tests/tests_file_writer/test_file_writer_manager.py

@@ -2,6 +2,7 @@
 import os
 import threading
 import time
+from pathlib import Path
 from unittest import mock
 
 import numpy as np
@@ -15,6 +16,7 @@ from bec_lib.redis_connector import MessageObject
 from bec_lib.service_config import ServiceConfig
 from bec_lib.tests.utils import ConnectorMock
 from bec_server.file_writer import FileWriterManager
+from bec_server.file_writer.async_writer import AsyncWriter
 from bec_server.file_writer.file_writer import HDF5FileWriter
 from bec_server.file_writer.file_writer_manager import ScanStorage
 
@@ -242,7 +244,7 @@ def test_write_file(file_writer_manager_mock, scan_storage_mock):
 def test_write_file_forwards_written_async_signals(file_writer_manager_mock, scan_storage_mock):
     file_manager = file_writer_manager_mock
     scan_storage_mock.async_writer = mock.Mock(
-        written_signals={"waveform": ["waveform_data"]}, file_handle=None
+        written_signals={"waveform": ["waveform_data"]}, file_handle=None, error_info=None
     )
     file_manager.scan_storage["scan_id"] = scan_storage_mock
 
@@ -839,3 +841,95 @@ def test_subscriptions_buffer_early_notifications(file_writer_manager_mock, conn
     assert manager.scan_storage["scan_id"].file_references == {"eiger": file_msg}
     assert manager._pending_baseline_writes == {}
     assert manager._pending_file_references == {}
+
+
+@pytest.mark.parametrize("failure_stage", ["poll", "write", "final_poll", None])
+@pytest.mark.parametrize("finalization_fails", [False, True])
+def test_async_failure_survives_finalization(
+    file_writer_manager_mock,
+    scan_storage_mock,
+    tmp_path,
+    failure_stage,
+    finalization_fails,
+    request,
+):
+    manager = file_writer_manager_mock
+    path = str(tmp_path / "master.h5")
+    writer = AsyncWriter(path, "scan_id", 10, manager.connector, ["det"], [])
+
+    def close_file():
+        if writer.file_handle is not None:
+            writer.file_handle.close()
+
+    request.addfinalizer(close_file)
+    scan_storage_mock.async_writer = writer
+    manager.scan_storage["scan_id"] = scan_storage_mock
+    data = {
+        "det": [
+            messages.DeviceMessage(
+                signals={"det": {"value": [1], "timestamp": 1}},
+                metadata={"async_update": {"type": "add", "max_shape": [None]}},
+            )
+        ]
+    }
+    failure = RuntimeError("async acquisition failed")
+
+    def poll(poll_timeout=500):
+        if writer.written_signals:
+            if failure_stage in ("poll", "final_poll"):
+                raise failure
+            writer.stop()
+            return None
+        return data
+
+    original_write = writer.write_data
+
+    def write(*args, **kwargs):
+        original_write(*args, **kwargs)
+        if failure_stage == "write":
+            raise failure
+        if failure_stage == "final_poll":
+            writer.stop()
+
+    with (
+        mock.patch.object(writer, "poll_data", side_effect=poll),
+        mock.patch.object(writer, "write_data", side_effect=write),
+        mock.patch.object(manager.connector, "raise_alarm"),
+    ):
+        # Error propagation does not require a background thread or a timing deadline.
+        writer.run()
+    assert writer.written_signals == {"det": ["det"]}
+    assert writer.file_handle["/entry/collection/devices/det/det/value"][:].tolist() == [1]
+    if failure_stage:
+        assert "async acquisition failed" in writer.error_info.compact_error_message
+    else:
+        assert writer.error_info is None
+    with (
+        mock.patch("bec_server.file_writer.file_writer_manager.get_full_path", return_value=path),
+        mock.patch.object(
+            manager.file_writer,
+            "write",
+            side_effect=RuntimeError("metadata failed") if finalization_fails else None,
+        ) as finalize,
+        mock.patch.object(manager.connector, "set_and_publish") as publish,
+        mock.patch.object(manager.connector, "xadd") as xadd,
+        mock.patch.object(manager.connector, "raise_alarm"),
+    ):
+        manager.write_file("scan_id")
+    finalize.assert_called_once()
+    outcome = publish.call_args.args[1]
+    assert outcome.done is True
+    assert outcome.successful is (failure_stage is None and not finalization_fails)
+    # The logger may also publish through this connector, depending on test order.
+    history_calls = [
+        call
+        for call in xadd.call_args_list
+        if call.kwargs.get("topic") == MessageEndpoints.scan_history()
+    ]
+    if outcome.successful:
+        assert len(history_calls) == 1
+        assert history_calls[0].kwargs["msg_dict"]["data"].file_path == path
+    else:
+        assert not history_calls
+    assert not writer.file_handle.id.valid
+    assert Path(path).exists()