make nic_slot_prefix configurable

According to Venkat, the physical slots used for those interfaces will
vary with each environment.

Author: skrobul

python/understack-workflows/docs/example_netapp_config.conf

@@ -0,0 +1,15 @@
+# Example NetApp configuration file showing the new netapp_nic_slot_prefix option
+
+[netapp_nvme]
+# Required configuration options
+netapp_server_hostname = netapp-cluster.example.com
+netapp_login = admin
+netapp_password = your-secure-password
+
+# Optional: NIC slot prefix for port naming (defaults to 'e4' if not specified)
+# This controls the base port name generation in NetappIPInterfaceConfig
+# Examples:
+#   netapp_nic_slot_prefix = e4  # Results in ports like e4a, e4b (default)
+#   netapp_nic_slot_prefix = e5  # Results in ports like e5a, e5b
+#   netapp_nic_slot_prefix = e6  # Results in ports like e6a, e6b
+netapp_nic_slot_prefix = e5

python/understack-workflows/tests/test_netapp_config.py

@@ -20,6 +20,21 @@ def valid_config_file(self):
 netapp_server_hostname = test-hostname.example.com
 netapp_login = test-user
 netapp_password = test-password-123
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".conf", delete=False) as f:
+            f.write(config_content)
+            f.flush()
+            yield f.name
+        os.unlink(f.name)
+
+    @pytest.fixture
+    def config_with_nic_prefix(self):
+        """Create a config file with custom NIC slot prefix."""
+        config_content = """[netapp_nvme]
+netapp_server_hostname = test-hostname.example.com
+netapp_login = test-user
+netapp_password = test-password-123
+netapp_nic_slot_prefix = e5
 """
         with tempfile.NamedTemporaryFile(mode="w", suffix=".conf", delete=False) as f:
             f.write(config_content)
@@ -48,6 +63,7 @@ def test_successful_initialization(self, valid_config_file):
         assert config.hostname == "test-hostname.example.com"
         assert config.username == "test-user"
         assert config.password == "test-password-123"
+        assert config.netapp_nic_slot_prefix == "e4"  # Default value
         assert config.config_path == valid_config_file
 
     def test_default_config_path(self):
@@ -318,6 +334,21 @@ def test_config_with_extra_sections(self, valid_config_file):
 
         os.unlink(f.name)
 
+    def test_netapp_nic_slot_prefix_custom_value(self, config_with_nic_prefix):
+        """Test NetAppConfig with custom NIC slot prefix."""
+        config = NetAppConfig(config_with_nic_prefix)
+
+        assert config.hostname == "test-hostname.example.com"
+        assert config.username == "test-user"
+        assert config.password == "test-password-123"
+        assert config.netapp_nic_slot_prefix == "e5"
+
+    def test_netapp_nic_slot_prefix_default_value(self, valid_config_file):
+        """Test NetAppConfig uses default NIC slot prefix when not specified."""
+        config = NetAppConfig(valid_config_file)
+
+        assert config.netapp_nic_slot_prefix == "e4"
+
     def test_config_with_extra_options(self):
         """Test config parsing ignores extra options in netapp_nvme section."""
         config_content = """[netapp_nvme]
@@ -338,3 +369,61 @@ def test_config_with_extra_options(self):
             assert config.password == "test-password"
 
         os.unlink(f.name)
+    def test_integration_netapp_config_with_from_nautobot_response(self, config_with_nic_prefix):
+        """Test integration between NetAppConfig and NetappIPInterfaceConfig.from_nautobot_response."""
+        from unittest.mock import MagicMock
+        from understack_workflows.netapp.value_objects import NetappIPInterfaceConfig
+        import ipaddress
+
+        # Create config with custom NIC prefix
+        config = NetAppConfig(config_with_nic_prefix)
+        assert config.netapp_nic_slot_prefix == "e5"
+
+        # Create a mock nautobot response
+        mock_interface_a = MagicMock()
+        mock_interface_a.name = "N1-test-A"
+        mock_interface_a.address = "192.168.1.10/24"
+        mock_interface_a.vlan = 100
+
+        mock_interface_b = MagicMock()
+        mock_interface_b.name = "N1-test-B"
+        mock_interface_b.address = "192.168.1.11/24"
+        mock_interface_b.vlan = 100
+
+        mock_response = MagicMock()
+        mock_response.interfaces = [mock_interface_a, mock_interface_b]
+
+        # Test that from_nautobot_response uses the custom prefix
+        configs = NetappIPInterfaceConfig.from_nautobot_response(mock_response, config)
+
+        assert len(configs) == 2
+        assert configs[0].base_port_name == "e5a"
+        assert configs[1].base_port_name == "e5b"
+        assert configs[0].nic_slot_prefix == "e5"
+        assert configs[1].nic_slot_prefix == "e5"
+    def test_from_nautobot_response_default_prefix(self, valid_config_file):
+        """Test that from_nautobot_response uses default prefix when no config provided."""
+        from unittest.mock import MagicMock
+        from understack_workflows.netapp.value_objects import NetappIPInterfaceConfig
+
+        # Create a mock nautobot response
+        mock_interface = MagicMock()
+        mock_interface.name = "N1-test-A"
+        mock_interface.address = "192.168.1.10/24"
+        mock_interface.vlan = 100
+
+        mock_response = MagicMock()
+        mock_response.interfaces = [mock_interface]
+
+        # Test without config (should use default)
+        configs = NetappIPInterfaceConfig.from_nautobot_response(mock_response)
+        assert len(configs) == 1
+        assert configs[0].base_port_name == "e4a"
+        assert configs[0].nic_slot_prefix == "e4"
+
+        # Test with config that has default prefix
+        config = NetAppConfig(valid_config_file)
+        configs_with_config = NetappIPInterfaceConfig.from_nautobot_response(mock_response, config)
+        assert len(configs_with_config) == 1
+        assert configs_with_config[0].base_port_name == "e4a"
+        assert configs_with_config[0].nic_slot_prefix == "e4"

python/understack-workflows/tests/test_netapp_manager.py

@@ -666,6 +666,30 @@ def test_base_port_name_b(self):
 
         assert config.base_port_name == "e4b"
 
+    def test_base_port_name_custom_prefix_a(self):
+        """Test base_port_name with custom prefix for side A."""
+        config = NetappIPInterfaceConfig(
+            name="N1-test-A",
+            address=ipaddress.IPv4Address("192.168.1.10"),
+            network=ipaddress.IPv4Network("192.168.1.0/24"),
+            vlan_id=100,
+            nic_slot_prefix="e5",
+        )
+
+        assert config.base_port_name == "e5a"
+
+    def test_base_port_name_custom_prefix_b(self):
+        """Test base_port_name with custom prefix for side B."""
+        config = NetappIPInterfaceConfig(
+            name="N1-test-B",
+            address=ipaddress.IPv4Address("192.168.1.10"),
+            network=ipaddress.IPv4Network("192.168.1.0/24"),
+            vlan_id=100,
+            nic_slot_prefix="e6",
+        )
+
+        assert config.base_port_name == "e6b"
+
     def test_broadcast_domain_name_a(self):
         """Test broadcast_domain_name for side A."""
         config = NetappIPInterfaceConfig(

python/understack-workflows/understack_workflows/main/netapp_configure_net.py

@@ -352,7 +352,7 @@ def netapp_create_interfaces(
         Exception: If SVM for the project is not found
         NetAppRestError: If LIF creation fails on the NetApp system
     """
-    configs = NetappIPInterfaceConfig.from_nautobot_response(nautobot_response)
+    configs = NetappIPInterfaceConfig.from_nautobot_response(nautobot_response, mgr.config)
     for interface_config in configs:
         logger.info("Creating LIF %s for project %s", interface_config.name, project_id)
         mgr.create_lif(project_id, interface_config)

python/understack-workflows/understack_workflows/netapp/config.py

@@ -49,11 +49,19 @@ def _parse_config(self) -> dict[str, str]:
             ) from e
 
         try:
-            return {
+            config_data = {
                 "hostname": parser.get("netapp_nvme", "netapp_server_hostname"),
                 "username": parser.get("netapp_nvme", "netapp_login"),
                 "password": parser.get("netapp_nvme", "netapp_password"),
             }
+
+            # Optional netapp_nic_slot_prefix with default value
+            try:
+                config_data["netapp_nic_slot_prefix"] = parser.get("netapp_nvme", "netapp_nic_slot_prefix")
+            except (configparser.NoSectionError, configparser.NoOptionError):
+                config_data["netapp_nic_slot_prefix"] = "e4"
+
+            return config_data
         except (configparser.NoSectionError, configparser.NoOptionError) as e:
             raise ConfigurationError(
                 f"Missing required configuration in {self._config_path}: {e}",
@@ -108,6 +116,11 @@ def password(self) -> str:
         """Get the NetApp login password."""
         return self._config_data["password"]
 
+    @property
+    def netapp_nic_slot_prefix(self) -> str:
+        """Get the NetApp NIC slot prefix."""
+        return self._config_data["netapp_nic_slot_prefix"]
+
     @property
     def config_path(self) -> str:
         """Get the configuration file path."""

python/understack-workflows/understack_workflows/netapp/manager.py

@@ -429,3 +429,8 @@ def _svm_name(self, project_id):
 
     def _volume_name(self, project_id):
         return f"vol_{project_id}"
+
+    @property
+    def config(self):
+        """Get the NetApp configuration."""
+        return self._config

python/understack-workflows/understack_workflows/netapp/value_objects.py

@@ -23,6 +23,7 @@ class NetappIPInterfaceConfig:
     address: ipaddress.IPv4Address
     network: ipaddress.IPv4Network
     vlan_id: int
+    nic_slot_prefix: str = "e4"
 
     def netmask_long(self):
         return self.network.netmask
@@ -50,7 +51,20 @@ def desired_node_number(self) -> int:
             raise ValueError("Cannot determine node index from name %s", self.name)
 
     @classmethod
-    def from_nautobot_response(cls, response: "VirtualMachineNetworkInfo"):
+    def from_nautobot_response(cls, response: "VirtualMachineNetworkInfo", netapp_config=None):
+        """Create NetappIPInterfaceConfig instances from Nautobot response.
+
+        Args:
+            response: The Nautobot response containing network interface information
+            netapp_config: Optional NetApp configuration to get NIC slot prefix from
+
+        Returns:
+            List of NetappIPInterfaceConfig instances
+        """
+        nic_slot_prefix = "e4"  # Default value
+        if netapp_config:
+            nic_slot_prefix = netapp_config.netapp_nic_slot_prefix
+
         result = []
         for interface in response.interfaces:
             address, _ = interface.address.split("/")
@@ -60,13 +74,15 @@ def from_nautobot_response(cls, response: "VirtualMachineNetworkInfo"):
                     address=ipaddress.IPv4Address(address),
                     network=ipaddress.IPv4Network(interface.address, strict=False),
                     vlan_id=interface.vlan,
+                    nic_slot_prefix=nic_slot_prefix,
                 )
             )
         return result
 
     @cached_property
     def base_port_name(self):
-        return f"e4{self.side.lower()}"
+        """Get the base port name using the configured NIC slot prefix."""
+        return f"{self.nic_slot_prefix}{self.side.lower()}"
 
     @cached_property
     def broadcast_domain_name(self):