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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec-server
-Version: 4.1.2
+Version: 4.1.4
 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.4}/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.4}/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.4}/bec_server/scan_server/scan_queue.py

@@ -459,15 +459,19 @@ class QueueManager:
                           Expected: {instruction_queue}, actual: {instruction_queue.worker.current_instruction_queue_item}. Skipping abort."
                 )
                 return
-            que.worker_status = InstructionQueueStatus.STOPPED
             if instruction_queue.scan_id and instruction_queue.scan_id[-1] is None:
                 stop_id = instruction_queue.queue_id
             else:
                 stop_id = instruction_queue.scan_id
-            self.stop_all_devices(
-                stop_id=stop_id,
-                devices=self._get_owned_devices_for_instruction_queue(instruction_queue),
-            )
+            try:
+                self.stop_all_devices(
+                    stop_id=stop_id,
+                    devices=self._get_owned_devices_for_instruction_queue(instruction_queue),
+                )
+            finally:
+                # Attempt publication before cleanup, but still interrupt on publish failure.
+                if instruction_queue.status != InstructionQueueStatus.COMPLETED:
+                    instruction_queue.status = InstructionQueueStatus.STOPPED
 
     def _cancel_queue_item(self, target_queue_item: DirectInstructionQueueItem, queue: str) -> None:
         """
@@ -528,8 +532,26 @@ class QueueManager:
         que = self.queues[queue]
         with AutoResetCM(que):
             que.status = ScanQueueStatus.PAUSED
-            que.worker_status = InstructionQueueStatus.STOPPED
-            que.clear()
+            instruction_queue = que.scan_worker.current_instruction_queue_item
+            if (
+                instruction_queue is not None
+                and instruction_queue.status != InstructionQueueStatus.COMPLETED
+            ):
+                scan_ids = instruction_queue.scan_id
+                stop_id = (
+                    instruction_queue.queue_id if scan_ids and scan_ids[-1] is None else scan_ids
+                )
+                try:
+                    self.stop_all_devices(
+                        stop_id=stop_id,
+                        devices=self._get_owned_devices_for_instruction_queue(instruction_queue),
+                    )
+                finally:
+                    instruction_queue.status = InstructionQueueStatus.STOPPED
+                    que.clear()
+            else:
+                que.worker_status = InstructionQueueStatus.STOPPED
+                que.clear()
 
     @requires_queue
     def set_restart(

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

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

{bec_server-4.1.2 → bec_server-4.1.4}/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.4}/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()

{bec_server-4.1.2 → bec_server-4.1.4}/tests/tests_scan_server/test_scan_server_queue.py

@@ -1,5 +1,6 @@
 import threading
 import time
+from contextlib import nullcontext
 from unittest import mock
 
 import pytest
@@ -1017,6 +1018,128 @@ def test_set_abort_with_no_owned_devices_sends_stop_none(queuemanager_mock):
     } in queue_manager.connector.message_sent
 
 
+@pytest.mark.parametrize("action", ["abort", "clear"])
+@pytest.mark.parametrize("has_scan_id", [False, True])
+@pytest.mark.parametrize("publish_fails", [False, True])
+def test_device_stop_precedes_worker_shutdown(
+    dormant_scan_queue, action, has_scan_id, publish_fails
+):
+    queue = dormant_scan_queue
+    manager = queue.queue_manager
+    registry = manager.parent.device_lock_registry
+    item = DirectInstructionQueueItem(queue, mock.Mock(), queue.scan_worker)
+    scan = _build_dummy_v4_scan("scan-id" if has_scan_id else None)
+    scan.scan_info.metadata["RID"] = "stop-rid"
+    item.scans = [scan]
+    item.scan_msgs = [_queued_scan_message(rid="stop-rid")]
+    item.active_scan = scan
+    queue.queue.append(item)
+    queue.active_instruction_queue = item
+    queue.scan_worker.current_instruction_queue_item = item
+    item.status = InstructionQueueStatus.RUNNING
+    registry.get_owned_devices = mock.Mock(return_value=["samx"])
+    manager.connector.message_sent = []
+    original_stop = item.stop
+
+    def release_on_shutdown():
+        # Model the direct worker releasing ownership immediately on interruption.
+        registry.get_owned_devices.return_value = []
+        stops = [
+            sent["msg"]
+            for sent in manager.connector.message_sent
+            if sent["queue"] == MessageEndpoints.stop_devices()
+        ]
+        if publish_fails:
+            assert not stops
+        else:
+            assert len(stops) == 1
+            assert stops[0].value == ["samx"]
+            expected_stop_id = item.scan_id if has_scan_id else item.queue_id
+            assert stops[0].metadata["stop_id"] == expected_stop_id
+        original_stop()
+
+    def fail_stop_publication(endpoint, msg):
+        assert endpoint == MessageEndpoints.stop_devices()
+        assert msg.value == ["samx"]
+        raise RuntimeError("Stop publication failed")
+
+    publication = (
+        mock.patch.object(manager.connector, "send", side_effect=fail_stop_publication)
+        if publish_fails
+        else nullcontext()
+    )
+    expected_error = (
+        pytest.raises(RuntimeError, match="Stop publication failed")
+        if publish_fails
+        else nullcontext()
+    )
+    with publication, mock.patch.object(item, "stop", side_effect=release_on_shutdown):
+        with expected_error:
+            getattr(manager, f"set_{action}")(queue="primary")
+    assert item.status == InstructionQueueStatus.STOPPED
+    assert queue.status == ScanQueueStatus.PAUSED
+    if action == "clear":
+        assert not queue.queue
+        assert queue.active_instruction_queue is None
+
+
+@pytest.mark.parametrize("retire_target", [False, True])
+@pytest.mark.parametrize("publish_fails", [False, True])
+def test_abort_preserves_completed_target_and_following_item(
+    dormant_scan_queue, retire_target, publish_fails
+):
+    # pylint: disable=redefined-outer-name
+    queue = dormant_scan_queue
+    manager = queue.queue_manager
+    manager.add_to_queue("primary", _queued_scan_message(rid="original"))
+    manager.add_to_queue("primary", _queued_scan_message(rid="following"))
+    original, following = queue.queue
+    original.active_scan = original.scans[0]
+    original.status = InstructionQueueStatus.RUNNING
+    queue.active_instruction_queue = original
+    queue.scan_worker.current_instruction_queue_item = original
+    send = manager.connector.send
+
+    def complete_during_publication(endpoint, msg):
+        assert endpoint == MessageEndpoints.stop_devices()
+        # Model the worker completing and optionally retiring the original during publication.
+        original.status = InstructionQueueStatus.COMPLETED
+        queue.scan_worker.current_instruction_queue_item = None
+        if retire_target:
+            assert queue.queue.popleft() is original
+        if publish_fails:
+            raise RuntimeError("Stop publication failed")
+        send(endpoint, msg)
+
+    expected_error = (
+        pytest.raises(RuntimeError, match="Stop publication failed")
+        if publish_fails
+        else nullcontext()
+    )
+    with mock.patch.object(manager.connector, "send", side_effect=complete_during_publication):
+        with expected_error:
+            manager.set_abort(request_id="original")
+
+    assert original.status == InstructionQueueStatus.COMPLETED
+    assert following.status == InstructionQueueStatus.PENDING
+    assert not following.scans[0]._shutdown_event.is_set()
+    assert queue.status == ScanQueueStatus.PAUSED
+
+
+def test_clear_pending_queue_does_not_stop_devices(dormant_scan_queue):
+    queue = dormant_scan_queue
+    manager = queue.queue_manager
+    manager.add_to_queue("primary", _queued_scan_message())
+    manager.connector.message_sent = []
+
+    manager.set_clear(queue="primary")
+
+    assert not queue.queue
+    assert not any(
+        sent["queue"] == MessageEndpoints.stop_devices() for sent in manager.connector.message_sent
+    )
+
+
 @pytest.mark.timeout(5)
 def test_set_clear_sends_message(queuemanager_mock):
     queue_manager = queuemanager_mock()