feat(cinder-understack): split the classes like upstream

Follow the upstream pattern by having the actual driver class inherit
from BaseVD and have a library class that's called instead of combining
functionality.

Author: cardoe

python/cinder-understack/cinder_understack/dynamic_netapp_driver.py

@@ -2,6 +2,7 @@
 
 from cinder import context
 from cinder import exception
+from cinder import interface
 from cinder.objects import volume_type as vol_type_obj
 from cinder.volume import driver as volume_driver
 from cinder.volume.drivers.netapp import options
@@ -31,8 +32,8 @@
 ]
 
 
-class NetappCinderDynamicDriver(NetAppNVMeStorageLibrary):
-    """NetApp NVMe driver with dynamic SVM selection from volume types.
+class NetappDynamicLibrary(NetAppNVMeStorageLibrary):
+    """NetApp NVMe storage library with dynamic SVM selection from volume types.
 
     Key difference from standard NetApp drivers:
     - Standard: One SVM per backend, all config in cinder.conf
@@ -964,6 +965,87 @@ def create_volume(self, volume):
             ) from e
 
 
+@interface.volumedriver
+class NetappCinderDynamicDriver(volume_driver.BaseVD):
+    """NetApp NVMe driver with dynamic multi-SVM support.
+
+    This driver follows the standard Cinder pattern by inheriting from BaseVD
+    and delegating storage operations to the NetappDynamicLibrary.
+    """
+
+    VERSION = "1.0.0"
+    DRIVER_NAME = "NetApp_Dynamic_NVMe"
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the driver and create library instance."""
+        super().__init__(*args, **kwargs)
+        self.library = NetappDynamicLibrary(self.DRIVER_NAME, "NVMe", **kwargs)
+
+    def do_setup(self, context):
+        """Setup the driver."""
+        self.library.do_setup(context)
+
+    def check_for_setup_error(self):
+        """Check for setup errors."""
+        self.library.check_for_setup_error()
+
+    def create_volume(self, volume):
+        """Create a volume."""
+        return self.library.create_volume(volume)
+
+    def delete_volume(self, volume):
+        """Delete a volume."""
+        return self.library.delete_volume(volume)
+
+    def create_snapshot(self, snapshot):
+        """Create a snapshot."""
+        return self.library.create_snapshot(snapshot)
+
+    def delete_snapshot(self, snapshot):
+        """Delete a snapshot."""
+        return self.library.delete_snapshot(snapshot)
+
+    def create_volume_from_snapshot(self, volume, snapshot):
+        """Create a volume from a snapshot."""
+        return self.library.create_volume_from_snapshot(volume, snapshot)
+
+    def create_cloned_volume(self, volume, src_vref):
+        """Create a cloned volume."""
+        return self.library.create_cloned_volume(volume, src_vref)
+
+    def extend_volume(self, volume, new_size):
+        """Extend a volume."""
+        return self.library.extend_volume(volume, new_size)
+
+    def initialize_connection(self, volume, connector):
+        """Initialize connection to volume."""
+        return self.library.initialize_connection(volume, connector)
+
+    def terminate_connection(self, volume, connector, **kwargs):
+        """Terminate connection to volume."""
+        return self.library.terminate_connection(volume, connector, **kwargs)
+
+    def get_volume_stats(self, refresh=False):
+        """Get volume stats."""
+        return self.library.get_volume_stats(refresh)
+
+    def update_provider_info(self, volumes, snapshots):
+        """Update provider info."""
+        return self.library.update_provider_info(volumes, snapshots)
+
+    def create_export(self, context, volume, connector):
+        """Create export for volume."""
+        return self.library.create_export(context, volume, connector)
+
+    def ensure_export(self, context, volume):
+        """Ensure export for volume."""
+        return self.library.ensure_export(context, volume)
+
+    def remove_export(self, context, volume):
+        """Remove export for volume."""
+        return self.library.remove_export(context, volume)
+
+
 # NOTES
 # Namespace: Manually created because we skip standard do_setup()
 # Pool: Custom svm#flexvol format to support multi-SVM

python/cinder-understack/cinder_understack/tests/test_dynamic_netapp_driver.py

@@ -0,0 +1,64 @@
+"""Test NetApp dynamic driver implementation."""
+
+from unittest import mock
+
+from cinder.tests.unit import test
+from cinder.tests.unit.volume.drivers.netapp import fakes as na_fakes
+
+from cinder_understack import dynamic_netapp_driver
+
+
+class NetappDynamicDriverTestCase(test.TestCase):
+    """Test case for NetappCinderDynamicDriver."""
+
+    def setUp(self):
+        """Set up test case."""
+        super().setUp()
+
+        kwargs = {
+            "configuration": self.get_config_base(),
+            "host": "openstack@netapp_dynamic",
+        }
+        self.driver = dynamic_netapp_driver.NetappCinderDynamicDriver(**kwargs)
+        self.library = self.driver.library
+
+    def get_config_base(self):
+        """Get base configuration for testing."""
+        return na_fakes.create_configuration()
+
+    def test_driver_has_correct_attributes(self):
+        """Test that driver has expected attributes."""
+        self.assertEqual("1.0.0", self.driver.VERSION)
+        self.assertEqual("NetApp_Dynamic_NVMe", self.driver.DRIVER_NAME)
+
+    def test_driver_has_library_instance(self):
+        """Test that driver has library instance."""
+        self.assertIsInstance(self.library, dynamic_netapp_driver.NetappDynamicLibrary)
+
+    def test_library_inherits_from_netapp_library(self):
+        """Test that library inherits from NetApp NVMe library."""
+        from cinder.volume.drivers.netapp.dataontap.nvme_library import (
+            NetAppNVMeStorageLibrary,
+        )
+
+        self.assertIsInstance(self.library, NetAppNVMeStorageLibrary)
+
+    @mock.patch.object(dynamic_netapp_driver.NetappDynamicLibrary, "do_setup")
+    def test_do_setup_calls_library(self, mock_do_setup):
+        """Test that do_setup delegates to library."""
+        context = mock.Mock()
+        self.driver.do_setup(context)
+        mock_do_setup.assert_called_once_with(context)
+
+    @mock.patch.object(dynamic_netapp_driver.NetappDynamicLibrary, "create_volume")
+    def test_create_volume_calls_library(self, mock_create_volume):
+        """Test that create_volume delegates to library."""
+        volume = mock.Mock()
+        self.driver.create_volume(volume)
+        mock_create_volume.assert_called_once_with(volume)
+
+    @mock.patch.object(dynamic_netapp_driver.NetappDynamicLibrary, "get_volume_stats")
+    def test_get_volume_stats_calls_library(self, mock_get_volume_stats):
+        """Test that get_volume_stats delegates to library."""
+        self.driver.get_volume_stats(refresh=True)
+        mock_get_volume_stats.assert_called_once_with(True)