isar 1.33.3__tar.gz → 1.33.4__tar.gz

{isar-1.33.3 → isar-1.33.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.3
+Version: 1.33.4
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.33.3 → isar-1.33.4}/src/isar/services/service_connections/mqtt/mqtt_client.py

@@ -106,15 +106,15 @@ class MqttClient(MqttClientInterface):
             )
 
     def on_connect(self, client, userdata, flags, reason_code, properties):
-        self.logger.info(
-            "Connection returned result: " + mqtt.connack_string(reason_code)
-        )
-
-    def on_disconnect(self, client, userdata, reason_code, properties):
-        if reason_code != 0:
-            self.logger.warning(
-                f"Unexpected disconnection from MQTT Broker, {reason_code}"
-            )
+        self.logger.info(f"Connected: {reason_code}")
+
+    def on_disconnect(self, client, userdata, *args):
+        if not args:
+            return
+        reason_code = args[0] if len(args) < 3 else args[1]
+        rc = getattr(reason_code, "value", reason_code)
+        if rc != 0:
+            self.logger.warning(f"Unexpected disconnect: {reason_code}.")
 
     @backoff.on_exception(
         backoff.expo,

{isar-1.33.3 → isar-1.33.4}/src/isar/storage/uploader.py

@@ -29,6 +29,14 @@ from robot_interface.telemetry.payloads import (
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
 
+def has_empty_blob_storage_path(storage_paths: StoragePaths):
+    for path in (storage_paths.data_path, storage_paths.metadata_path):
+        for value in (path.storage_account, path.blob_container, path.blob_name):
+            if not (value and value.strip()):
+                return True
+    return False
+
+
 @dataclass
 class UploaderQueueItem:
     inspection: Inspection
@@ -192,6 +200,13 @@ class Uploader:
                     inspection_paths = self._upload(item)
                     if isinstance(inspection_paths.data_path, LocalStoragePath):
                         self.logger.info("Skipping publishing when using local storage")
+                    elif isinstance(
+                        inspection_paths.data_path, BlobStoragePath
+                    ) and has_empty_blob_storage_path(inspection_paths):
+                        self.logger.warning(
+                            "Skipping publishing: Blob storage paths are empty for inspection %s",
+                            str(item.inspection.id)[:8],
+                        )
                     else:
                         self._publish_inspection_result(
                             inspection=item.inspection,

{isar-1.33.3 → isar-1.33.4}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.3
+Version: 1.33.4
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.33.3 → isar-1.33.4}/src/isar.egg-info/SOURCES.txt

@@ -204,6 +204,7 @@ tests/test_data/test_map_config/test_map_config.json
 tests/test_double/__init__.py
 tests/test_double/blob_storage.py
 tests/test_double/mission_definition.py
+tests/test_double/mqtt_client.py
 tests/test_double/pose.py
 tests/test_double/request.py
 tests/test_double/robot_interface.py

{isar-1.33.3 → isar-1.33.4}/tests/isar/storage/test_uploader.py

@@ -14,7 +14,8 @@ from robot_interface.models.inspection.inspection import (
 from robot_interface.models.mission.mission import Mission
 from robot_interface.models.mission.task import TakeImage
 from tests.isar.state_machine.test_state_machine import UploaderThreadMock
-from tests.test_double.blob_storage import StorageFake
+from tests.test_double.blob_storage import StorageEmptyBlobPathsFake, StorageFake
+from tests.test_double.mqtt_client import MqttPublisherFake
 
 MISSION_ID = "some-mission-id"
 ARBITRARY_IMAGE_METADATA = ImageMetadata(
@@ -85,3 +86,33 @@ def test_should_retry_failed_upload_from_queue(
 
     # After some time, it should have retried and now it should be successful
     assert storage_handler.blob_exists(inspection)
+
+
+def test_should_not_publish_when_blob_paths_are_empty(
+    container: ApplicationContainer, uploader_thread: UploaderThreadMock
+) -> None:
+    uploader_thread.start()
+
+    mission: Mission = Mission(name="Dummy mission")
+    inspection: Inspection = InspectionBlob(
+        metadata=ARBITRARY_IMAGE_METADATA, id="blob-empty"
+    )
+
+    uploader: Uploader = container.uploader()
+
+    storage_handler: StorageEmptyBlobPathsFake() = StorageEmptyBlobPathsFake()  # type: ignore
+    uploader.storage_handlers[0] = storage_handler
+
+    mqtt_fake = MqttPublisherFake()
+    uploader.mqtt_publisher = mqtt_fake
+
+    message: Tuple[Inspection, Mission] = (
+        inspection,
+        mission,
+    )
+    uploader.upload_queue.put(message)
+    time.sleep(1)
+
+    assert inspection in storage_handler.stored
+
+    assert len(mqtt_fake.published) == 0

isar-1.33.4/tests/test_double/blob_storage.py

@@ -0,0 +1,41 @@
+from typing import List
+
+from isar.storage.storage_interface import (
+    BlobStoragePath,
+    StorageException,
+    StorageInterface,
+    StoragePaths,
+)
+from robot_interface.models.inspection.inspection import Inspection, InspectionBlob
+from robot_interface.models.mission.mission import Mission
+
+
+class StorageFake(StorageInterface):
+    will_fail: bool = False
+
+    def __init__(self) -> None:
+        self.stored_inspections: List[Inspection] = []
+
+    def store(self, inspection: Inspection, mission: Mission):
+        if self.will_fail:
+            raise StorageException("Fake failed on purpose")
+        self.stored_inspections.append(inspection)
+
+    def blob_exists(self, inspection: Inspection) -> bool:
+        return inspection in self.stored_inspections
+
+
+class StorageEmptyBlobPathsFake(StorageInterface):
+
+    def __init__(self) -> None:
+        self.stored: List[Inspection] = []
+        self.fail: bool = False
+
+    def store(
+        self, inspection: InspectionBlob, mission: Mission
+    ) -> StoragePaths[BlobStoragePath]:
+        if self.fail:
+            raise StorageException("fail on purpose")
+        self.stored.append(inspection)
+        empty = BlobStoragePath(storage_account="", blob_container="", blob_name="")
+        return StoragePaths(data_path=empty, metadata_path=empty)

isar-1.33.4/tests/test_double/mqtt_client.py

@@ -0,0 +1,37 @@
+from threading import Lock
+from typing import Any, Dict, List, Optional
+
+from robot_interface.telemetry.mqtt_client import MqttClientInterface
+
+
+class MqttPublisherFake(MqttClientInterface):
+    def __init__(self) -> None:
+        self._lock = Lock()
+        self.published: List[Dict[str, Any]] = []
+
+    def publish(
+        self,
+        topic: str,
+        payload: str,
+        qos: int = 0,
+        retain: bool = False,
+        properties: Optional[Any] = None,
+    ) -> None:
+        with self._lock:
+            self.published.append(
+                {
+                    "topic": topic,
+                    "payload": payload,
+                    "qos": qos,
+                    "retain": retain,
+                    "properties": properties,
+                }
+            )
+
+    def last(self) -> Optional[Dict[str, Any]]:
+        with self._lock:
+            return self.published[-1] if self.published else None
+
+    def count(self) -> int:
+        with self._lock:
+            return len(self.published)

isar-1.33.3/tests/test_double/blob_storage.py

@@ -1,20 +0,0 @@
-from typing import List
-
-from isar.storage.storage_interface import StorageException, StorageInterface
-from robot_interface.models.inspection.inspection import Inspection
-from robot_interface.models.mission.mission import Mission
-
-
-class StorageFake(StorageInterface):
-    will_fail: bool = False
-
-    def __init__(self) -> None:
-        self.stored_inspections: List[Inspection] = []
-
-    def store(self, inspection: Inspection, mission: Mission):
-        if self.will_fail:
-            raise StorageException("Fake failed on purpose")
-        self.stored_inspections.append(inspection)
-
-    def blob_exists(self, inspection: Inspection) -> bool:
-        return inspection in self.stored_inspections