refactor: replace Supervisor singleton with FastAPI lifespan (#129)

* refactor: replace Supervisor singleton with FastAPI lifespan

- Remove SingletonMeta from Supervisor and DataGathering
- Add lifespan to create_app() — all service instances created once at
  startup and stored in app.state
- Make BinaryStorageFactory and MetadataStorageFactory config-independent:
  StoringPathManager is now built inside create_*_storage(), removing the
  dependency on StationConfig at factory construction time
- Simplify reset_managers() on Supervisor and DataGathering: no factory
  args needed since factories are stateless
- Simplify reset() on storage managers: just clears the cache
- Remove config_updated flag from ConfigManager: reset is now triggered
  directly from set_config route via app.state.supervisor.reset_managers()
- Expose binary_storage_manager and metadata_storage_manager in app.state
  directly, avoiding private attribute access in dependency_injection.py
- Update unit tests for storage factories and managers

* fix: enter TestClient context manager to trigger FastAPI lifespan in functional tests

TestClient only fires lifespan events (startup/shutdown) when used as a
context manager. Without it, app.state is never populated and routes that
access request.app.state.supervisor raise KeyError.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* refactor: delete dead V2 router

V2 was never registered in app.py, contained bugs (sync binary.read()
without await, missing station_config in supervisor.inspect), and was
superseded by V1. No code referenced it.

* fix: ci test reporter

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: bojeanson

.github/workflows/ci_edge_orchestrator.yml

@@ -14,6 +14,10 @@ jobs:
   lint_and_test_on_edge_orchestrator:
     name: Run Python linter and tests (unit > integration > functional)
     runs-on: ubuntu-latest
+    permissions:
+      checks: write
+      contents: read
+      packages: read
     strategy:
       matrix:
         python-version: ["3.9", "3.10", "3.11"]

edge_orchestrator/src/edge_orchestrator/application/config/config_manager.py

@@ -17,7 +17,6 @@ def __init__(self):
         self._active_station_name: Optional[str] = os.getenv("ACTIVE_CONFIG_NAME", "marker_classif_with_2_fake_cam")
         self._logger = logging.getLogger(__name__)
         self._config_dir = Path(os.getenv("CONFIG_DIR", "config")).resolve()
-        self._config_updated = False
         self._load_all_configs()
 
     def _load_all_configs(self) -> StationConfig:
@@ -58,7 +57,6 @@ def set_config(self, new_station_config: StationConfig):
         self._active_station_name = new_active_station_name
         self._station_configs[new_active_station_name] = new_station_config
         self._save_config_as_json(new_station_config)
-        self._config_updated = True
 
     def get_config(self) -> Optional[StationConfig]:
         return self._station_configs.get(self._active_station_name)
@@ -70,14 +68,6 @@ def reload_configs(self):
     def all_configs(self) -> Dict[str, StationConfig]:
         return self._station_configs
 
-    @property
-    def config_updated(self) -> bool:
-        return self._config_updated
-
-    @config_updated.setter
-    def config_updated(self, value: bool):
-        self._config_updated = value
-
     def _is_an_existing_config_name(self, station_name: str) -> bool:
         if station_name not in self.all_configs:
             return False
@@ -90,4 +80,6 @@ def set_config_by_name(self, station_name: str):
                 detail=f"{station_name} is not one of existing station names: {self.get_all_config_names()}",
             )
         self._active_station_name = station_name
-        self._config_updated = True
+
+    def get_all_config_names(self):
+        return list(self._station_configs.keys())

edge_orchestrator/src/edge_orchestrator/application/use_cases/data_gathering.py

@@ -2,23 +2,16 @@
 
 from edge_orchestrator.domain.models.item import Item
 from edge_orchestrator.domain.models.station_config import StationConfig
-from edge_orchestrator.domain.ports.binary_storage.i_binary_storage_factory import (
-    IBinaryStorageFactory,
-)
 from edge_orchestrator.domain.ports.binary_storage.i_binary_storage_manager import (
     IBinaryStorageManager,
 )
 from edge_orchestrator.domain.ports.camera.i_camera_manager import ICameraManager
-from edge_orchestrator.domain.ports.metadata_storage.i_metadata_storage_factory import (
-    IMetadataStorageFactory,
-)
 from edge_orchestrator.domain.ports.metadata_storage.i_metadata_storage_manager import (
     IMetadataStorageManager,
 )
-from edge_orchestrator.utils.singleton import SingletonMeta
 
 
-class DataGathering(metaclass=SingletonMeta):
+class DataGathering:
     def __init__(
         self,
         metadata_storage_manager: IMetadataStorageManager,
@@ -43,11 +36,9 @@ async def upload(self, item: Item, station_config: StationConfig):
 
         self._metadata_storage_manager.get_metadata_storage(station_config).save_item_metadata(item)
 
-    def reset_managers(
-        self, binary_storage_factory: IBinaryStorageFactory, metadata_storage_factory: IMetadataStorageFactory
-    ):
+    def reset_managers(self):
         self._logger.info("Resetting all managers after configuration update...")
-        self._metadata_storage_manager.reset(metadata_storage_factory)
-        self._binary_storage_manager.reset(binary_storage_factory)
+        self._metadata_storage_manager.reset()
+        self._binary_storage_manager.reset()
         self._camera_manager.reset()
         self._logger.info("Managers reset done!")

edge_orchestrator/src/edge_orchestrator/application/use_cases/supervisor.py

@@ -2,9 +2,6 @@
 
 from edge_orchestrator.domain.models.item import Item
 from edge_orchestrator.domain.models.station_config import StationConfig
-from edge_orchestrator.domain.ports.binary_storage.i_binary_storage_factory import (
-    IBinaryStorageFactory,
-)
 from edge_orchestrator.domain.ports.binary_storage.i_binary_storage_manager import (
     IBinaryStorageManager,
 )
@@ -15,19 +12,15 @@
 from edge_orchestrator.domain.ports.item_rule.i_item_rule_manager import (
     IItemRuleManager,
 )
-from edge_orchestrator.domain.ports.metadata_storage.i_metadata_storage_factory import (
-    IMetadataStorageFactory,
-)
 from edge_orchestrator.domain.ports.metadata_storage.i_metadata_storage_manager import (
     IMetadataStorageManager,
 )
 from edge_orchestrator.domain.ports.model_forwarder.i_model_forwarder_manager import (
     IModelForwarderManager,
 )
-from edge_orchestrator.utils.singleton import SingletonMeta
 
 
-class Supervisor(metaclass=SingletonMeta):
+class Supervisor:
     def __init__(
         self,
         metadata_storage_manager: IMetadataStorageManager,
@@ -59,12 +52,10 @@ async def inspect(self, item: Item, station_config: StationConfig):
 
         self._metadata_storage_manager.get_metadata_storage(station_config).save_item_metadata(item)
 
-    def reset_managers(
-        self, binary_storage_factory: IBinaryStorageFactory, metadata_storage_factory: IMetadataStorageFactory
-    ):
+    def reset_managers(self):
         self._logger.info("Resetting all managers after configuration update...")
-        self._metadata_storage_manager.reset(metadata_storage_factory)
-        self._binary_storage_manager.reset(binary_storage_factory)
+        self._metadata_storage_manager.reset()
+        self._binary_storage_manager.reset()
         self._model_forwarder_manager.reset()
         self._camera_rule_manager.reset()
         self._item_rule_manager.reset()

edge_orchestrator/src/edge_orchestrator/domain/ports/binary_storage/i_binary_storage_manager.py

@@ -21,5 +21,5 @@ def get_binary_storage(self, station_config: StationConfig) -> IBinaryStorage:
         pass
 
     @abstractmethod
-    def reset(self, binary_storage_factory: IBinaryStorageFactory):
+    def reset(self):
         pass

edge_orchestrator/src/edge_orchestrator/domain/ports/metadata_storage/i_metadata_storage_manager.py

@@ -21,5 +21,5 @@ def get_metadata_storage(self, station_config: StationConfig) -> IMetadataStorag
         pass
 
     @abstractmethod
-    def reset(self, metadata_storage_factory: IMetadataStorageFactory):
+    def reset(self):
         pass

edge_orchestrator/src/edge_orchestrator/infrastructure/adapters/binary_storage/binary_storage_factory.py

@@ -12,34 +12,34 @@
 
 
 class BinaryStorageFactory(IBinaryStorageFactory):
-    def __init__(self, storing_path_manager: StoringPathManager):
+    def __init__(self):
         self._logger = logging.getLogger(__name__)
-        self._storing_path_manager = storing_path_manager
 
     def create_binary_storage(self, station_config: StationConfig) -> IBinaryStorage:
+        storing_path_manager = StoringPathManager(station_config.binary_storage_config, station_config.station_name)
         if station_config.binary_storage_config.storage_type == StorageType.FILESYSTEM:
             from edge_orchestrator.infrastructure.adapters.binary_storage.filesystem_binary_storage import (
                 FileSystemBinaryStorage,
             )
 
-            return FileSystemBinaryStorage(station_config, self._storing_path_manager)
+            return FileSystemBinaryStorage(station_config, storing_path_manager)
         elif station_config.binary_storage_config.storage_type == StorageType.AWS:
             from edge_orchestrator.infrastructure.adapters.binary_storage.aws_binary_storage import (
                 AWSBinaryStorage,
             )
 
-            return AWSBinaryStorage(station_config, self._storing_path_manager)
+            return AWSBinaryStorage(station_config, storing_path_manager)
         elif station_config.binary_storage_config.storage_type == StorageType.GCP:
             from edge_orchestrator.infrastructure.adapters.binary_storage.gcp_binary_storage import (
                 GCPBinaryStorage,
             )
 
-            return GCPBinaryStorage(station_config, self._storing_path_manager)
+            return GCPBinaryStorage(station_config, storing_path_manager)
         elif station_config.binary_storage_config.storage_type == StorageType.AZURE:
             from edge_orchestrator.infrastructure.adapters.binary_storage.azure_binary_storage import (
                 AzureBinaryStorage,
             )
 
-            return AzureBinaryStorage(station_config, self._storing_path_manager)
+            return AzureBinaryStorage(station_config, storing_path_manager)
         else:
             raise Exception(f"Binary storage type {station_config.binary_storage_config.storage_type} not supported")

edge_orchestrator/src/edge_orchestrator/infrastructure/adapters/binary_storage/binary_storage_manager.py

@@ -25,6 +25,5 @@ def get_binary_storage(self, station_config: StationConfig) -> IBinaryStorage:
             self._binary_storages[binary_storage_type] = binary_storage
         return self._binary_storages[binary_storage_type]
 
-    def reset(self, binary_storage_factory: IBinaryStorageFactory):
-        self._binary_storage_factory = binary_storage_factory
+    def reset(self):
         self._binary_storages = {}

edge_orchestrator/src/edge_orchestrator/infrastructure/adapters/metadata_storage/metadata_storage_factory.py

@@ -12,35 +12,35 @@
 
 
 class MetadataStorageFactory(IMetadataStorageFactory):
-    def __init__(self, storing_path_manager: StoringPathManager):
+    def __init__(self):
         self._logger = logging.getLogger(__name__)
-        self._storing_path_manager = storing_path_manager
 
     def create_metadata_storage(self, station_config: StationConfig) -> IMetadataStorage:
+        storing_path_manager = StoringPathManager(station_config.metadata_storage_config, station_config.station_name)
         if station_config.metadata_storage_config.storage_type == StorageType.FILESYSTEM:
             from edge_orchestrator.infrastructure.adapters.metadata_storage.filesystem_metadata_storage import (
                 FileSystemMetadataStorage,
             )
 
-            return FileSystemMetadataStorage(station_config, self._storing_path_manager)
+            return FileSystemMetadataStorage(station_config, storing_path_manager)
         elif station_config.metadata_storage_config.storage_type == StorageType.AWS:
             from edge_orchestrator.infrastructure.adapters.metadata_storage.aws_metadata_storage import (
                 AWSMetadataStorage,
             )
 
-            return AWSMetadataStorage(station_config, self._storing_path_manager)
+            return AWSMetadataStorage(station_config, storing_path_manager)
         elif station_config.metadata_storage_config.storage_type == StorageType.GCP:
             from edge_orchestrator.infrastructure.adapters.metadata_storage.gcp_metadata_storage import (
                 GCPMetadataStorage,
             )
 
-            return GCPMetadataStorage(station_config, self._storing_path_manager)
+            return GCPMetadataStorage(station_config, storing_path_manager)
         elif station_config.metadata_storage_config.storage_type == StorageType.AZURE:
             from edge_orchestrator.infrastructure.adapters.metadata_storage.azure_metadata_storage import (
                 AzureMetadataStorage,
             )
 
-            return AzureMetadataStorage(station_config, self._storing_path_manager)
+            return AzureMetadataStorage(station_config, storing_path_manager)
         else:
             raise ValueError(
                 f"Metadata storage type {station_config.metadata_storage_config.storage_type} is not supported"

edge_orchestrator/src/edge_orchestrator/infrastructure/adapters/metadata_storage/metadata_storage_manager.py

@@ -25,6 +25,5 @@ def get_metadata_storage(self, station_config: StationConfig) -> IMetadataStorag
             self._metadata_storages[metadata_storage_type] = metadata_storage
         return self._metadata_storages[metadata_storage_type]
 
-    def reset(self, metadata_storage_factory: IMetadataStorageFactory):
-        self._metadata_storage_factory = metadata_storage_factory
+    def reset(self):
         self._metadata_storages = {}