feat: generate ibmgpfs charm

sunbeam-python/sunbeam/storage/backends/ibmgpfs/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026 - Canonical Ltd
+# SPDX-License-Identifier: Apache-2.0
+
+"""IBM GPFS backend for Sunbeam storage."""

sunbeam-python/sunbeam/storage/backends/ibmgpfs/backend.py

@@ -0,0 +1,155 @@
+# SPDX-FileCopyrightText: 2026 - Canonical Ltd
+# SPDX-License-Identifier: Apache-2.0
+
+"""GPFS backend implementation using base step classes."""
+
+import logging
+from enum import StrEnum
+from typing import Annotated, Literal
+
+from pydantic import Field
+from rich.console import Console
+
+from sunbeam.core.manifest import StorageBackendConfig
+from sunbeam.storage.base import StorageBackendBase
+from sunbeam.storage.models import SecretDictField
+
+LOG = logging.getLogger(__name__)
+console = Console()
+
+
+class ImagesShareMode(StrEnum):
+    """Enumeration of valid image share modes."""
+
+    COPY = "copy"
+    COPY_ON_WRITE = "copy_on_write"
+
+
+class IbmgpfsConfig(StorageBackendConfig):
+    """Configuration model for GPFS backend.
+
+    This model includes ALL configuration options for the backend.
+    Additional configuration can be managed dynamically through the charm.
+    """
+
+    # Optional backend configuration
+    protocol: Annotated[
+        Literal["iscsi"] | None,
+        Field(description="Protocol selector: iscsi."),
+    ] = None
+    gpfs_mount_point_base: Annotated[
+        str | None,
+        Field(
+            description="Specifies the path of the GPFS directory where Block Storage volume and snapshot files are stored."  # noqa: E501
+        ),
+    ] = None
+    gpfs_images_dir: Annotated[
+        str | None,
+        Field(
+            description="Specifies the path of the Image service repository in GPFS. Leave undefined if not storing images in GPFS."  # noqa: E501
+        ),
+    ] = None
+    gpfs_images_share_mode: Annotated[
+        ImagesShareMode | None,
+        Field(description="Specifies the type of image copy to be used."),
+    ] = None
+    gpfs_max_clone_depth: Annotated[
+        int | None,
+        Field(
+            description="Specifies an upper limit on the number of indirections required to reach a specific block due to snapshots or clones."  # noqa: E501
+        ),
+    ] = None
+    gpfs_sparse_volumes: Annotated[
+        bool | None,
+        Field(
+            description="Specifies that volumes are created as sparse files which initially consume no space."  # noqa: E501
+        ),
+    ] = None
+    gpfs_storage_pool: Annotated[
+        str | None,
+        Field(description="Specifies the storage pool that volumes are assigned to."),
+    ] = None
+    gpfs_hosts: Annotated[
+        str | None,
+        Field(
+            description="Comma-separated list of IP address or hostnames of GPFS nodes."
+        ),
+    ] = None
+    gpfs_user_login: Annotated[str, Field(description="Username for GPFS nodes.")]
+    gpfs_user_password: Annotated[
+        str,
+        Field(description="Password for GPFS node user."),
+        SecretDictField(field="gpfs-user-password"),
+    ]
+    gpfs_private_key: Annotated[
+        str | None,
+        Field(description="Filename of private key to use for SSH authentication."),
+    ] = None
+    gpfs_ssh_port: Annotated[int | None, Field(description="SSH port to use.")] = None
+    gpfs_hosts_key_file: Annotated[
+        str | None,
+        Field(
+            description="File containing SSH host keys for the gpfs nodes with which driver needs to communicate."  # noqa: E501
+        ),
+    ] = None
+    gpfs_strict_host_key_policy: Annotated[
+        bool | None,
+        Field(
+            description="Option to enable strict gpfs host key checking while connecting to gpfs nodes."  # noqa: E501
+        ),
+    ] = None
+    san_thin_provision: Annotated[
+        bool | None, Field(description="Use thin provisioning for SAN volumes?")
+    ] = None
+    san_ip: Annotated[str, Field(description="IP address of SAN controller")]
+    san_login: Annotated[
+        str,
+        Field(description="Username for SAN controller"),
+        SecretDictField(field="san-login"),
+    ]
+    san_password: Annotated[
+        str,
+        Field(description="Password for SAN controller"),
+        SecretDictField(field="san-password"),
+    ]
+    use_multipath_for_image_xfer: Annotated[
+        bool | None,
+        Field(description="Enable multipathing for image transfer operations."),
+    ] = None
+
+
+class IbmgpfsBackend(StorageBackendBase):
+    """GPFS backend implementation."""
+
+    backend_type = "ibmgpfs"
+    display_name = "GPFS"
+    generally_available = True
+
+    @property
+    def charm_name(self) -> str:
+        """Return the charm application name."""
+        return "cinder-volume-ibmgpfs"
+
+    @property
+    def charm_channel(self) -> str:
+        """Return the default charm channel."""
+        return "latest/edge"
+
+    @property
+    def charm_revision(self) -> str | None:
+        """Return a pinned charm revision, if any."""
+        return None
+
+    @property
+    def charm_base(self) -> str:
+        """Return the target base for this charm."""
+        return "ubuntu@24.04"
+
+    @property
+    def supports_ha(self) -> bool:
+        """Whether this backend supports HA deployments."""
+        return False
+
+    def config_type(self) -> type[StorageBackendConfig]:
+        """Return the configuration model type for this backend."""
+        return IbmgpfsConfig

sunbeam-python/tests/unit/sunbeam/storage/backends/conftest.py

@@ -8,6 +8,7 @@
 from sunbeam.storage.backends.dellpowerstore.backend import DellPowerstoreBackend
 from sunbeam.storage.backends.dellsc.backend import DellSCBackend
 from sunbeam.storage.backends.hitachi.backend import HitachiBackend
+from sunbeam.storage.backends.ibmgpfs.backend import IbmgpfsBackend
 from sunbeam.storage.backends.purestorage.backend import PureStorageBackend
 
 
@@ -29,19 +30,28 @@ def dellsc_backend():
     return DellSCBackend()
 
 
+@pytest.fixture
+def ibmgpfs_backend():
+    """Provide an IBM GPFS backend instance."""
+    return IbmgpfsBackend()
+
+
 @pytest.fixture
 def dellpowerstore_backend():
     """Provide a Dell PowerStore backend instance."""
     return DellPowerstoreBackend()
 
 
-@pytest.fixture(params=["hitachi", "purestorage", "dellsc", "dellpowerstore"])
+@pytest.fixture(
+    params=["hitachi", "purestorage", "dellsc", "ibmgpfs", "dellpowerstore"]
+)
 def any_backend(request):
     """Parametrized fixture that provides each backend type."""
     backends = {
         "hitachi": HitachiBackend(),
         "purestorage": PureStorageBackend(),
         "dellsc": DellSCBackend(),
+        "ibmgpfs": IbmgpfsBackend(),
         "dellpowerstore": DellPowerstoreBackend(),
     }
     return backends[request.param]

sunbeam-python/tests/unit/sunbeam/storage/backends/test_common.py

@@ -157,13 +157,18 @@ def backend(self, any_backend):
 
 
 def test_all_backends_have_unique_types(
-    hitachi_backend, purestorage_backend, dellsc_backend, dellpowerstore_backend
+    hitachi_backend,
+    purestorage_backend,
+    dellsc_backend,
+    ibmgpfs_backend,
+    dellpowerstore_backend,
 ):
     """Test that all backends have unique type identifiers."""
     backends = [
         hitachi_backend,
         purestorage_backend,
         dellsc_backend,
+        ibmgpfs_backend,
         dellpowerstore_backend,
     ]
     types = [b.backend_type for b in backends]
@@ -173,13 +178,18 @@ def test_all_backends_have_unique_types(
 
 
 def test_all_backends_have_unique_charm_names(
-    hitachi_backend, purestorage_backend, dellsc_backend, dellpowerstore_backend
+    hitachi_backend,
+    purestorage_backend,
+    dellsc_backend,
+    ibmgpfs_backend,
+    dellpowerstore_backend,
 ):
     """Test that all backends have unique charm names."""
     backends = [
         hitachi_backend,
         purestorage_backend,
         dellsc_backend,
+        ibmgpfs_backend,
         dellpowerstore_backend,
     ]
     charm_names = [b.charm_name for b in backends]
@@ -196,6 +206,7 @@ def test_all_backends_have_unique_charm_names(
         ("hitachi", "hitachi"),
         ("purestorage", "purestorage"),
         ("dellsc", "dellsc"),
+        ("ibmgpfs", "ibmgpfs"),
         ("dellpowerstore", "dellpowerstore"),
     ],
 )
@@ -211,6 +222,7 @@ def test_backend_types_match_expected(any_backend, backend_type, expected_type):
         ("hitachi", "cinder-volume-hitachi"),
         ("purestorage", "cinder-volume-purestorage"),
         ("dellsc", "cinder-volume-dellsc"),
+        ("ibmgpfs", "cinder-volume-ibmgpfs"),
         ("dellpowerstore", "cinder-volume-dellpowerstore"),
     ],
 )

sunbeam-python/tests/unit/sunbeam/storage/backends/test_ibmgpfs.py

@@ -0,0 +1,90 @@
+# SPDX-FileCopyrightText: 2026 - Canonical Ltd
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for IBM GPFS backend."""
+
+import pytest
+from pydantic import ValidationError
+
+from sunbeam.storage.models import SecretDictField
+from tests.unit.sunbeam.storage.backends.test_common import BaseBackendTests
+
+
+class TestIbmgpfsBackend(BaseBackendTests):
+    """Tests for IBM GPFS backend."""
+
+    @pytest.fixture
+    def backend(self, ibmgpfs_backend):
+        """Provide IBM GPFS backend instance."""
+        return ibmgpfs_backend
+
+    def test_backend_type_is_ibmgpfs(self, backend):
+        """Test that backend type is 'ibmgpfs'."""
+        assert backend.backend_type == "ibmgpfs"
+
+    def test_charm_name_is_ibmgpfs_charm(self, backend):
+        """Test that charm name is cinder-volume-ibmgpfs."""
+        assert backend.charm_name == "cinder-volume-ibmgpfs"
+
+    def test_config_has_required_fields(self, backend):
+        """Test that IBM GPFS config has required fields."""
+        fields = backend.config_type().model_fields
+        for field in ("san_ip", "san_login", "san_password", "protocol"):
+            assert field in fields, f"Required field {field} not found in config"
+
+    def test_credentials_are_secret(self, backend):
+        """Test that configured credentials are marked as secrets."""
+        config_class = backend.config_type()
+        for field_name in ("san_login", "san_password", "gpfs_user_password"):
+            field = config_class.model_fields.get(field_name)
+            assert field is not None
+            assert any(isinstance(m, SecretDictField) for m in field.metadata), (
+                f"{field_name} should be marked as secret"
+            )
+
+
+class TestIbmgpfsConfigValidation:
+    """Test IBM GPFS config validation behavior."""
+
+    def test_gpfs_login_is_required(self, ibmgpfs_backend):
+        """Test that gpfs-user-login is required."""
+        config_class = ibmgpfs_backend.config_type()
+        with pytest.raises(ValidationError):
+            config_class.model_validate(
+                {
+                    "san-ip": "192.168.1.1",
+                    "san-login": "admin",
+                    "san-password": "secret",
+                    "gpfs-user-password": "secret",
+                    "protocol": "iscsi",
+                }
+            )
+
+    def test_protocol_rejects_invalid_value(self, ibmgpfs_backend):
+        """Test that protocol rejects values other than iscsi."""
+        config_class = ibmgpfs_backend.config_type()
+        with pytest.raises(ValidationError):
+            config_class.model_validate(
+                {
+                    "san-ip": "192.168.1.1",
+                    "san-login": "admin",
+                    "san-password": "secret",
+                    "gpfs-user-password": "secret",
+                    "protocol": "fc",
+                }
+            )
+
+    def test_protocol_accepts_iscsi(self, ibmgpfs_backend):
+        """Test that protocol accepts iscsi."""
+        config_class = ibmgpfs_backend.config_type()
+        config = config_class.model_validate(
+            {
+                "san-ip": "192.168.1.1",
+                "san-login": "admin",
+                "san-password": "secret",
+                "gpfs-user-login": "gpfs-admin",
+                "gpfs-user-password": "secret",
+                "protocol": "iscsi",
+            }
+        )
+        assert config.protocol == "iscsi"