(PTFE-3027) Add support for block storage

Author: matthiasL-scality

runner_manager/backend/scaleway.py

@@ -8,6 +8,7 @@
 from pydantic import Field
 from redis_om import NotFoundError
 from scaleway import Client
+from scaleway.block.v1alpha1 import BlockV1Alpha1API
 from scaleway.instance.v1 import (
     Image,
     Server,
@@ -56,6 +57,26 @@ def client(self) -> InstanceUtilsV1API:
         )
         return InstanceUtilsV1API(scw_client)
 
+    @property
+    def block_client(self) -> BlockV1Alpha1API:
+        """Returns a Scaleway Block Storage API client."""
+        access_key = self.config.access_key or os.getenv("SCW_ACCESS_KEY")
+        secret_key = self.config.secret_key or os.getenv("SCW_SECRET_KEY")
+
+        if not access_key or not secret_key:
+            raise ValueError(
+                "Scaleway credentials not found. Set SCW_ACCESS_KEY and SCW_SECRET_KEY."
+            )
+
+        scw_client = Client(
+            access_key=access_key,
+            secret_key=secret_key,
+            default_project_id=self.config.project_id,
+            default_zone=self.config.zone,
+            default_region=self.config.region,
+        )
+        return BlockV1Alpha1API(scw_client)
+
     def sanitize_tags(self, tags: List[str]) -> List[str]:
         """Sanitize tags to comply with Scaleway requirements.
 
@@ -438,20 +459,41 @@ def delete(self, runner: Runner) -> int:
 
             # Delete associated volumes
             # Note: The behavior differs by volume type:
-            # - l_ssd (local storage): Usually auto-deleted with the server
-            # - sbs_volume (block storage): Persists after server deletion, must be deleted manually
-            # The Instance API manages both types, but sbs volumes need explicit cleanup
+            # - l_ssd (local storage): Usually auto-deleted with the server, use Instance API
+            # - sbs_volume (block storage): Persists after server deletion, must be deleted manually using Block API
             for volume_id in volume_ids:
                 try:
-                    self.client.delete_volume(
-                        zone=self.config.zone,
-                        volume_id=volume_id,
-                    )
-                    log.info(f"Volume {volume_id} deleted successfully")
+                    # First, try to delete using Block Storage API (for sbs_volume)
+                    try:
+                        self.block_client.delete_volume(
+                            zone=self.config.zone,
+                            volume_id=volume_id,
+                        )
+                        log.info(
+                            f"Block storage volume {volume_id} deleted successfully"
+                        )
+                    except Exception as block_error:
+                        block_error_msg = str(block_error)
+                        # If volume not found in Block API, try Instance API (for l_ssd volumes)
+                        if (
+                            "404" in block_error_msg
+                            or "not_found" in block_error_msg.lower()
+                        ):
+                            log.debug(
+                                f"Volume {volume_id} not found in Block API, trying Instance API"
+                            )
+                            self.client.delete_volume(
+                                zone=self.config.zone,
+                                volume_id=volume_id,
+                            )
+                            log.info(
+                                f"Instance volume {volume_id} deleted successfully"
+                            )
+                        else:
+                            raise block_error
                 except Exception as vol_error:
                     error_msg = str(vol_error)
                     # Volume may already be deleted automatically (especially l_ssd volumes)
-                    # or might not be found if searching in wrong scope
                     if "404" in error_msg or "not_found" in error_msg.lower():
                         log.info(
                             f"Volume {volume_id} not found - may have been auto-deleted with server or already cleaned up"

tests/unit/backend/test_scaleway.py

@@ -72,9 +72,21 @@ def fake_scaleway_group(scaleway_group, monkeypatch):
     mock_client.server_action.return_value = None
     mock_client.update_server.return_value = None
     mock_client.delete_server.return_value = None
+    mock_client.delete_volume.return_value = None  # For fallback from Block API
+
+    # Mock Block Storage API client
+    # By default, simulate that volumes are not found in Block API (like l_ssd volumes)
+    # This will trigger fallback to Instance API, maintaining compatibility with existing tests
+    mock_block_client = MagicMock()
+    mock_block_client.delete_volume.side_effect = Exception(
+        "404 not_found: Volume not in Block API"
+    )
 
     # Patch the client property
     monkeypatch.setattr(ScalewayBackend, "client", property(lambda self: mock_client))
+    monkeypatch.setattr(
+        ScalewayBackend, "block_client", property(lambda self: mock_block_client)
+    )
 
     # Mock wait_for_server_state to return immediately
     def mock_wait(self, server_id, target_state, timeout=300):
@@ -549,6 +561,119 @@ def test_delete_not_found(scaleway_runner, fake_scaleway_group, caplog):
     assert result == 1
 
 
+def test_delete_with_block_storage_volume(
+    scaleway_runner, fake_scaleway_group, caplog, monkeypatch
+):
+    """Test instance deletion with block storage (sbs_volume) using Block API."""
+    backend = fake_scaleway_group.backend
+    scaleway_runner.instance_id = "test-server-id"
+    scaleway_runner.save()
+
+    # Mock server with block storage volume
+    mock_volume = MagicMock()
+    mock_volume.id = "test-block-volume-id"
+    mock_server = MagicMock()
+    mock_server.id = "test-server-id"
+    mock_server.state = ServerState.RUNNING
+    mock_server.volumes = {"0": mock_volume}
+
+    # Mock Instance API client
+    mock_client = MagicMock()
+    mock_client.get_server.return_value = MagicMock(server=mock_server)
+    mock_client.delete_server.return_value = None
+    mock_client.delete_volume.return_value = None
+    mock_client.server_action.return_value = None
+
+    # Mock Block Storage API client
+    mock_block_client = MagicMock()
+    mock_block_client.delete_volume.return_value = None
+
+    # Patch both clients
+    monkeypatch.setattr(ScalewayBackend, "client", property(lambda self: mock_client))
+    monkeypatch.setattr(
+        ScalewayBackend, "block_client", property(lambda self: mock_block_client)
+    )
+
+    # Mock wait_for_server_state
+    def mock_wait(self, server_id, target_state, timeout=300):
+        return mock_server
+
+    monkeypatch.setattr(ScalewayBackend, "wait_for_server_state", mock_wait)
+
+    result = backend.delete(scaleway_runner)
+
+    # Verify Block Storage API was called first
+    mock_block_client.delete_volume.assert_called_once_with(
+        zone=backend.config.zone,
+        volume_id="test-block-volume-id",
+    )
+    # Verify Instance API delete_volume was NOT called
+    mock_client.delete_volume.assert_not_called()
+    # Verify successful deletion was logged
+    assert (
+        "Block storage volume test-block-volume-id deleted successfully" in caplog.text
+    )
+    assert result == 1
+
+
+def test_delete_with_volume_fallback_to_instance_api(
+    scaleway_runner, fake_scaleway_group, caplog, monkeypatch
+):
+    """Test volume deletion fallback from Block API to Instance API for l_ssd volumes."""
+    backend = fake_scaleway_group.backend
+    scaleway_runner.instance_id = "test-server-id"
+    scaleway_runner.save()
+
+    # Mock server with l_ssd volume
+    mock_volume = MagicMock()
+    mock_volume.id = "test-lssd-volume-id"
+    mock_server = MagicMock()
+    mock_server.id = "test-server-id"
+    mock_server.state = ServerState.RUNNING
+    mock_server.volumes = {"0": mock_volume}
+
+    # Mock Instance API client
+    mock_client = MagicMock()
+    mock_client.get_server.return_value = MagicMock(server=mock_server)
+    mock_client.delete_server.return_value = None
+    mock_client.delete_volume.return_value = None
+    mock_client.server_action.return_value = None
+
+    # Mock Block Storage API client to return 404 (volume not found in Block API)
+    mock_block_client = MagicMock()
+    mock_block_client.delete_volume.side_effect = Exception(
+        "404 not_found: Volume not found in Block API"
+    )
+
+    # Patch both clients
+    monkeypatch.setattr(ScalewayBackend, "client", property(lambda self: mock_client))
+    monkeypatch.setattr(
+        ScalewayBackend, "block_client", property(lambda self: mock_block_client)
+    )
+
+    # Mock wait_for_server_state
+    def mock_wait(self, server_id, target_state, timeout=300):
+        return mock_server
+
+    monkeypatch.setattr(ScalewayBackend, "wait_for_server_state", mock_wait)
+
+    result = backend.delete(scaleway_runner)
+
+    # Verify Block Storage API was called first
+    mock_block_client.delete_volume.assert_called_once_with(
+        zone=backend.config.zone,
+        volume_id="test-lssd-volume-id",
+    )
+    # Verify Instance API was called as fallback
+    mock_client.delete_volume.assert_called_once_with(
+        zone=backend.config.zone,
+        volume_id="test-lssd-volume-id",
+    )
+    # Verify successful deletion through Instance API was logged
+    assert "Instance volume test-lssd-volume-id deleted successfully" in caplog.text
+    assert result == 1
+
+
 def test_list_with_auto_create(fake_scaleway_group, monkeypatch):
     """Test list() creates runners for servers not in database."""
     backend = fake_scaleway_group.backend