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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec-server
-Version: 4.1.3
+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.3 → 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.3 → bec_server-4.1.4}/pyproject.toml

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

{bec_server-4.1.3 → 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()