os-vif 4.2.1__py3-none-any.whl → 4.3.0__py3-none-any.whl

os_vif/internal/ip/ip_command.py

@@ -18,6 +18,7 @@ class IpCommand(metaclass=abc.ABCMeta):
     TYPE_VETH = 'veth'
     TYPE_VLAN = 'vlan'
     TYPE_BRIDGE = 'bridge'
+    TYPE_TUNTAP = 'tuntap'
 
     @abc.abstractmethod
     def set(self, device, check_exit_code=None, state=None, mtu=None,
@@ -37,11 +38,12 @@ class IpCommand(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def add(self, device, dev_type, check_exit_code=None, peer=None, link=None,
-            vlan_id=None, ageing=None):
+            vlan_id=None, ageing=None, mode=None, multiqueue=False):
         """Method to add an interface.
 
         :param   device: A network device (string)
-        :param   dev_type: String network device type (TYPE_VETH, TYPE_VLAN)
+        :param   dev_type: String network device type (TYPE_VETH, TYPE_VLAN,
+                           TYPE_BRIDGE, TYPE_TUNTAP)
         :param   check_exit_code: List of integers of allowed execution exit
                                   codes
         :param   peer: String peer name, for veth interfaces
@@ -50,6 +52,8 @@ class IpCommand(metaclass=abc.ABCMeta):
         :param   vlan_id: Integer VLAN ID for VLAN devices
         :param   ageing: integer value in seconds before learned
                          mac addresses are forgotten.
+        :param   mode: String mode for tuntap devices ('tap' or 'tun')
+        :param   multiqueue: Boolean to enable multiqueue for tuntap devices
         :return: status of the command execution
         """
 

os_vif/internal/ip/linux/impl_pyroute2.py

@@ -74,7 +74,7 @@ class PyRoute2(ip_command.IpCommand):
         return idx[0]
 
     def add(self, device, dev_type, check_exit_code=None, peer=None, link=None,
-            vlan_id=None, ageing=None):
+            vlan_id=None, ageing=None, mode=None, multiqueue=False):
         check_exit_code = check_exit_code or []
         with iproute.IPRoute() as ip:
             args = {'ifname': device,
@@ -102,6 +102,15 @@ class PyRoute2(ip_command.IpCommand):
                 # what policy to use and keep this code generic.
                 if ageing is not None:
                     args['IFLA_BR_AGEING_TIME'] = ageing
+            elif self.TYPE_TUNTAP == dev_type:
+                # Set mode (default to 'tap' if not specified)
+                # This matches the 'ip tuntap add' command behavior
+                tap_mode = mode if mode else 'tap'
+                args['mode'] = tap_mode
+                # Enable multiqueue if requested
+                # This sets the IFF_MULTI_QUEUE flag in IFTUN_IFR
+                if multiqueue:
+                    args['multi_queue'] = True
             else:
                 raise exception.NetworkInterfaceTypeNotDefined(type=dev_type)
 

os_vif/objects/vif.py

@@ -327,7 +327,8 @@ class VIFPortProfileOpenVSwitch(VIFPortProfileBase):
     # Version 1.1: Added 'datapath_type'
     # Version 1.2: VIFPortProfileBase updated to 1.1 from 1.0
     # Version 1.3: Added 'create_port'
-    VERSION = '1.3'
+    # Version 1.4: Added 'create_tap' and 'multiqueue'
+    VERSION = '1.4'
 
     fields = {
         #: A UUID to uniquely identify the interface. If omitted one will be
@@ -342,10 +343,21 @@ class VIFPortProfileOpenVSwitch(VIFPortProfileBase):
 
         #: Whether the os-vif plugin should add the port to the bridge.
         'create_port': fields.BooleanField(default=False),
+
+        #: Whether the os-vif plugin should create the TAP device.
+        'create_tap': fields.BooleanField(default=False),
+
+        #: Whether to enable multiqueue on the TAP device.
+        'multiqueue': fields.BooleanField(default=False),
     }
 
     def obj_make_compatible(self, primitive, target_version):
         target_version = versionutils.convert_version_to_tuple(target_version)
+        if target_version < (1, 4):
+            if 'create_tap' in primitive:
+                del primitive['create_tap']
+            if 'multiqueue' in primitive:
+                del primitive['multiqueue']
         if target_version < (1, 3) and 'create_port' in primitive:
             del primitive['create_port']
         if target_version < (1, 1) and 'datapath_type' in primitive:
@@ -370,7 +382,8 @@ class VIFPortProfileFPOpenVSwitch(VIFPortProfileOpenVSwitch):
     # Version 1.1: VIFPortProfileOpenVSwitch updated to 1.1 from 1.0
     # Version 1.2: VIFPortProfileOpenVSwitch updated to 1.2 from 1.1
     # Version 1.3: VIFPortProfileOpenVSwitch updated to 1.3 from 1.2
-    VERSION = '1.3'
+    # Version 1.4: VIFPortProfileOpenVSwitch updated to 1.4 from 1.3
+    VERSION = '1.4'
 
     fields = {
         #: Name of the bridge (managed by fast path) to connect to.
@@ -391,9 +404,12 @@ class VIFPortProfileFPOpenVSwitch(VIFPortProfileOpenVSwitch):
         elif target_version < (1, 3):
             super(VIFPortProfileFPOpenVSwitch, self).obj_make_compatible(
                 primitive, '1.2')
-        else:
+        elif target_version < (1, 4):
             super(VIFPortProfileFPOpenVSwitch, self).obj_make_compatible(
                 primitive, '1.3')
+        else:
+            super(VIFPortProfileFPOpenVSwitch, self).obj_make_compatible(
+                primitive, '1.4')
 
 
 @removals.removed_class("VIFPortProfileOVSRepresentor",
@@ -421,7 +437,8 @@ class VIFPortProfileOVSRepresentor(VIFPortProfileOpenVSwitch):
     # Version 1.1: VIFPortProfileOpenVSwitch updated to 1.1 from 1.0
     # Version 1.2: VIFPortProfileOpenVSwitch updated to 1.2 from 1.1
     # Version 1.3: VIFPortProfileOpenVSwitch updated to 1.3 from 1.2
-    VERSION = '1.3'
+    # Version 1.4: VIFPortProfileOpenVSwitch updated to 1.4 from 1.3
+    VERSION = '1.4'
 
     fields = {
         #: Name to set on the representor (if set).
@@ -442,9 +459,12 @@ class VIFPortProfileOVSRepresentor(VIFPortProfileOpenVSwitch):
         elif target_version < (1, 3):
             super(VIFPortProfileOVSRepresentor, self).obj_make_compatible(
                 primitive, '1.2')
-        else:
+        elif target_version < (1, 4):
             super(VIFPortProfileOVSRepresentor, self).obj_make_compatible(
                 primitive, '1.3')
+        else:
+            super(VIFPortProfileOVSRepresentor, self).obj_make_compatible(
+                primitive, '1.4')
 
 
 @base.VersionedObjectRegistry.register

os_vif/tests/functional/internal/command/ip/test_impl_pyroute2.py

@@ -81,6 +81,22 @@ class ShellIpCommands(object):
             return
         return match.group('state')
 
+    def is_admin_up(self, device):
+        """Check if device is administratively up (UP flag set).
+
+        This differs from show_state() which returns the operational state.
+        TAP devices without a carrier will have state=DOWN but can still
+        be administratively UP (UP in flags like <NO-CARRIER,BROADCAST,UP>).
+        """
+        # Flags are in angle brackets on the first line, e.g. <NO-CARRIER,UP>
+        first_line = self.show_device(device)[0]
+        regex = re.compile(r".*<(?P<flags>[^>]+)>")
+        match = regex.match(first_line)
+        if match is None:
+            return False
+        flags = match.group('flags').split(',')
+        return 'UP' in flags
+
     def show_promisc(self, device):
         regex = re.compile(r".*(PROMISC)")
         match = regex.match(self.show_device(device)[0])
@@ -263,3 +279,98 @@ class TestIpCommand(ShellIpCommands, base.BaseFunctionalTestCase):
         _ip_cmd_set(device, master=bridge)
         path = "/sys/class/net/{}/brif/{}".format(bridge, device)
         self.assertTrue(os.path.exists(path))
+
+    def test_add_tap(self):
+        """Test creating a tap device."""
+        device = "test_tap_1"
+        self.addCleanup(self.del_device, device)
+        _ip_cmd_add(device, 'tuntap', mode='tap')
+        self.assertTrue(self.exist_device(device))
+
+        # Verify it's a tap device by checking /sys/class/net/<dev>/tun_flags
+        tun_flags_path = "/sys/class/net/{}/tun_flags".format(device)
+        if os.path.exists(tun_flags_path):
+            with open(tun_flags_path, 'r') as f:
+                flags_hex = f.read().strip()
+                flags = int(flags_hex, 16)
+                # IFF_TAP = 0x0002
+                IFF_TAP = 0x0002
+                self.assertTrue(flags & IFF_TAP,
+                              "TAP flag not set. Flags: {}".format(flags_hex))
+
+    def test_add_tap_with_multiqueue(self):
+        """Test creating a tap device with multiqueue parameter.
+
+        Note: The IFF_MULTI_QUEUE flag (0x0100) cannot be set via netlink.
+        It is only set when a process opens /dev/net/tun with the
+        IFF_MULTI_QUEUE flag in the ioctl. Libvirt sets this when attaching
+        to the TAP device. This test verifies that:
+        1. The TAP device can be created with multiqueue=True without error
+        2. The device is properly created as a TAP device
+        """
+        device = "test_tap_mq"
+        self.addCleanup(self.del_device, device)
+        _ip_cmd_add(device, 'tuntap', mode='tap', multiqueue=True)
+        self.assertTrue(self.exist_device(device))
+
+        # Verify it's a tap device by checking /sys/class/net/<dev>/tun_flags
+        tun_flags_path = "/sys/class/net/{}/tun_flags".format(device)
+        if os.path.exists(tun_flags_path):
+            with open(tun_flags_path, 'r') as f:
+                flags_hex = f.read().strip()
+                flags = int(flags_hex, 16)
+                # IFF_TAP = 0x0002 - verify it's a TAP device
+                IFF_TAP = 0x0002
+                self.assertTrue(
+                    flags & IFF_TAP,
+                    "TAP flag not set. Flags: %s" % flags_hex)
+
+    def test_add_tap_idempotent(self):
+        """Test tap device creation is idempotent with exit code handling."""
+        device = "test_tap_idemp"
+        self.addCleanup(self.del_device, device)
+
+        # Create the device
+        _ip_cmd_add(device, 'tuntap', mode='tap')
+        self.assertTrue(self.exist_device(device))
+
+        # Try to create again with EEXIST in check_exit_code (17)
+        # This should not raise an exception
+        _ip_cmd_add(device, 'tuntap', mode='tap', check_exit_code=[0, 17])
+        self.assertTrue(self.exist_device(device))
+
+    def test_add_tun_device(self):
+        """Test creating a tun device (not tap)."""
+        device = "test_tun_1"
+        self.addCleanup(self.del_device, device)
+        _ip_cmd_add(device, 'tuntap', mode='tun')
+        self.assertTrue(self.exist_device(device))
+
+        # Verify it's a tun device
+        tun_flags_path = "/sys/class/net/{}/tun_flags".format(device)
+        if os.path.exists(tun_flags_path):
+            with open(tun_flags_path, 'r') as f:
+                flags_hex = f.read().strip()
+                flags = int(flags_hex, 16)
+                # IFF_TUN = 0x0001
+                IFF_TUN = 0x0001
+                self.assertTrue(flags & IFF_TUN,
+                              "TUN flag not set. Flags: {}".format(flags_hex))
+
+    def test_tap_set_properties(self):
+        """Test setting properties on a tap device."""
+        device = "test_tap_props"
+        mac = "36:a7:e4:f9:01:02"
+        self.addCleanup(self.del_device, device)
+
+        # Create tap device
+        _ip_cmd_add(device, 'tuntap', mode='tap')
+        self.assertTrue(self.exist_device(device))
+
+        # Set MAC address and state
+        _ip_cmd_set(device, address=mac, state='up')
+        # TAP devices without a carrier will show state=DOWN but should be
+        # administratively UP (UP flag in interface flags)
+        self.assertTrue(self.is_admin_up(device),
+                        "Device should be administratively UP")
+        self.assertEqual(mac, self.show_mac(device))

os_vif/tests/unit/internal/ip/linux/test_impl_pyroute2.py

@@ -175,3 +175,69 @@ class TestIpCommand(base.TestCase):
 
             self.assertRaises(ipexc.NetlinkError, self.ip.delete, self.DEVICE,
                               check_exit_code=[self.OTHER_ERROR_CODE])
+
+    def test_add_tap(self):
+        """Test creating a basic tap device."""
+        self.ip.add(self.DEVICE, 'tuntap', mode='tap')
+        args = {'ifname': self.DEVICE,
+                'kind': 'tuntap',
+                'mode': 'tap'}
+        self.ip_link.assert_called_once_with('add', **args)
+
+    def test_add_tap_default_mode(self):
+        """Test creating tap device with default mode (should be 'tap')."""
+        self.ip.add(self.DEVICE, 'tuntap')
+        args = {'ifname': self.DEVICE,
+                'kind': 'tuntap',
+                'mode': 'tap'}
+        self.ip_link.assert_called_once_with('add', **args)
+
+    def test_add_tap_with_multiqueue(self):
+        """Test creating tap device with multiqueue enabled."""
+        self.ip.add(self.DEVICE, 'tuntap', mode='tap', multiqueue=True)
+
+        # Verify the call includes multiqueue flag
+        args = {'ifname': self.DEVICE,
+                'kind': 'tuntap',
+                'mode': 'tap',
+                'multi_queue': True}
+        self.ip_link.assert_called_once_with('add', **args)
+
+    def test_add_tun_device(self):
+        """Test creating a tun device (not tap)."""
+        self.ip.add(self.DEVICE, 'tuntap', mode='tun')
+        args = {'ifname': self.DEVICE,
+                'kind': 'tuntap',
+                'mode': 'tun'}
+        self.ip_link.assert_called_once_with('add', **args)
+
+    def test_add_tap_exit_code(self):
+        """Test tap device creation with exit code handling."""
+        self.ip_link.side_effect = ipexc.NetlinkError(self.ERROR_CODE,
+                                                      msg="Error message")
+
+        # Should not raise when error code matches
+        self.ip.add(self.DEVICE, 'tuntap', mode='tap',
+                    check_exit_code=[self.ERROR_CODE])
+        self.ip_link.assert_called_once()
+
+        # Should raise when exit code doesn't match
+        self.assertRaises(
+            ipexc.NetlinkError,
+            self.ip.add, self.DEVICE, 'tuntap', mode='tap',
+            check_exit_code=[self.OTHER_ERROR_CODE])
+
+    def test_set_no_multiqueue_parameter(self):
+        """Verify set() no longer accepts multiqueue parameter."""
+        with mock.patch.object(
+                iproute.IPRoute, 'link_lookup', return_value=[1],
+                create=True):
+            self.ip_link.return_value = [{'flags': 0}]
+
+            # Should work without multiqueue
+            self.ip.set(self.DEVICE, state=self.UP, mtu=self.MTU,
+                        address=self.MAC)
+
+            # Should raise TypeError if multiqueue is passed
+            self.assertRaises(TypeError, self.ip.set, self.DEVICE,
+                            multiqueue=True)

os_vif/tests/unit/test_objects.py

@@ -40,12 +40,12 @@ object_data = {
     'VIFPortProfile8021Qbg': '1.1-b3011621809dca9216b50579ce9d6b19',
     'VIFPortProfile8021Qbh': '1.1-226b61b2e76ba452f7b31530cff80ac9',
     'VIFPortProfileBase': '1.1-4982d1621df12ebd1f3b07948f3d0e5f',
-    'VIFPortProfileOpenVSwitch': '1.3-1ad9a350a9cae19c977d21fcce7c8c7f',
-    'VIFPortProfileFPOpenVSwitch': '1.3-06c425743430e7702ef112e09b987346',
+    'VIFPortProfileOpenVSwitch': '1.4-54fb321f2b70c37d392fadc226c889e7',
+    'VIFPortProfileFPOpenVSwitch': '1.4-20904c1dcdac0641cabf7b02525973bd',
     'VIFPortProfileFPBridge': '1.1-49f1952bf50bab7a95112c908534751f',
     'VIFPortProfileFPTap': '1.1-fd178229477604dfb65de5ce929488e5',
     'VIFVHostUser': '1.1-1f95b43be1f884f090ca1f4d79adfd35',
-    'VIFPortProfileOVSRepresentor': '1.3-f625e17143473b93d6c7f97ded9f785a',
+    'VIFPortProfileOVSRepresentor': '1.4-82b7292ee4cd6f808b724d2f5648932b',
     'VIFNestedDPDK': '1.0-fdbaf6b20afd116529929b21aa7158dc',
     'VIFPortProfileK8sDPDK': '1.1-e2a2abd112b14e0239e76b99d9b252ae',
     'DatapathOffloadBase': '1.0-77509ea1ea0dd750d5864b9bd87d3f9d',
@@ -78,3 +78,60 @@ class TestObjectVersions(base.TestCase):
         self.assertIn('vif_name', primitive)
         vif.obj_make_compatible(primitive, '1.0')
         self.assertNotIn('vif_name', primitive)
+
+    def test_vif_port_profile_ovs_obj_make_compatible_1_4(self):
+        """Test obj_make_compatible removes create_tap and multiqueue for
+        versions < 1.4.
+        """
+        profile = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True,
+            multiqueue=True)
+        primitive = profile.obj_to_primitive()['versioned_object.data']
+        self.assertIn('create_tap', primitive)
+        self.assertIn('multiqueue', primitive)
+
+        # For version 1.3, both create_tap and multiqueue should be removed
+        profile.obj_make_compatible(primitive, '1.3')
+        self.assertNotIn('create_tap', primitive)
+        self.assertNotIn('multiqueue', primitive)
+
+    def test_vif_port_profile_ovs_obj_make_compatible_1_3(self):
+        """Test obj_make_compatible removes create_port for versions < 1.3."""
+        profile = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_port=True)
+        primitive = profile.obj_to_primitive()['versioned_object.data']
+        self.assertIn('create_port', primitive)
+
+        # For version 1.2, create_port should be removed
+        profile.obj_make_compatible(primitive, '1.2')
+        self.assertNotIn('create_port', primitive)
+
+    def test_vif_port_profile_ovs_create_tap_multiqueue_fields(self):
+        """Test that create_tap and multiqueue fields can be set."""
+        profile = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True,
+            multiqueue=True)
+        self.assertTrue(profile.create_tap)
+        self.assertTrue(profile.multiqueue)
+
+        # Test explicitly set default values
+        profile_default = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=False,
+            multiqueue=False)
+        self.assertFalse(profile_default.create_tap)
+        self.assertFalse(profile_default.multiqueue)
+
+    def test_vif_port_profile_ovs_in_operator(self):
+        """Test that 'in' operator works for checking field existence."""
+        profile = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True,
+            multiqueue=True)
+        self.assertIn('create_tap', profile)
+        self.assertIn('multiqueue', profile)
+        self.assertIn('interface_id', profile)
+        self.assertNotIn('nonexistent_field', profile)

{os_vif-4.2.1.dist-info → os_vif-4.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: os_vif
-Version: 4.2.1
+Version: 4.3.0
 Summary: A library for plugging and unplugging virtual interfaces in OpenStack.
 Home-page: https://docs.openstack.org/os-vif/latest/
 Author: OpenStack
@@ -34,6 +34,16 @@ Requires-Dist: ovsdbapp>=0.12.1
 Requires-Dist: stevedore>=1.20.0
 Requires-Dist: debtcollector>=1.19.0
 Requires-Dist: pyroute2>=0.5.2; sys_platform != "win32"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ========================
 Team and repository tags

{os_vif-4.2.1.dist-info → os_vif-4.3.0.dist-info}/RECORD

@@ -8,9 +8,9 @@ os_vif/version.py,sha256=ilQe2xTxPDxlzJYWbq8KdHeashflTfC1OZewgFPKPRI,713
 os_vif/internal/__init__.py,sha256=VGE1e9o-7RkuTzNhZl4Wivz1tojriLYypVBObhSZfSk,967
 os_vif/internal/ip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/internal/ip/api.py,sha256=BlGJdRe_Yn7P23Dejo7gLK-M6UasY8sKrMCz0FPvx2s,722
-os_vif/internal/ip/ip_command.py,sha256=agySNBD4GHp87uo6HbtIg4JwtOMhfuRZN5X7ytPir5k,2787
+os_vif/internal/ip/ip_command.py,sha256=3xOsIOozcZNza78bsAhGHNJTGHiSH9CZSXqwPLeA1oE,3044
 os_vif/internal/ip/linux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-os_vif/internal/ip/linux/impl_pyroute2.py,sha256=ddQ9d7fzBJEYmE1wJhMfpmHftTBFdJ2C94dCNGRsB0A,5511
+os_vif/internal/ip/linux/impl_pyroute2.py,sha256=ZFJwd5FlHxq_rZmfciRPQSG5KGPZPubPbJU6liTNKGI,6002
 os_vif/objects/__init__.py,sha256=ePMVrOlb8ti6YmpdZ15pOXI1XLeFjHvhBvw35abZRZE,883
 os_vif/objects/base.py,sha256=kI0c1gPDN37RhGuOYg18AA7l98uUfpqs14AS9GfE4oE,1139
 os_vif/objects/fields.py,sha256=i_kVqeCOBfcNKuZiB3gBat-8qJWhLtwEQxsl-k5plgw,1761
@@ -20,7 +20,7 @@ os_vif/objects/instance_info.py,sha256=pdZcq6ZJzT1vFnkeUV_jlCvMNz53QlHRvY-bB1u5n
 os_vif/objects/network.py,sha256=L6Ngq_u4vbF_xUc9o2aUW2oq0OWALjXFgB1uHsLaZm4,2134
 os_vif/objects/route.py,sha256=44EbxorPn3QiKusaAoksrYolSR6jCYS7sh5tplHenOE,1352
 os_vif/objects/subnet.py,sha256=ZSiwVUZGZT_kmYuND4PwpN98nImvpwMc-ne5DO-Lkg0,1458
-os_vif/objects/vif.py,sha256=VpVgaXez_SRZvoY0BcoSWQY_nF02tP09o8ZjWKldiLI,21668
+os_vif/objects/vif.py,sha256=DlRuvv0ruI246YtvxZG9oP_1pWC50GhzNszZVysPl20,22606
 os_vif/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/functional/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/functional/base.py,sha256=m2uqvH9BkBcCYU7PtlnBYUmwmQLUiuwVS99scJjYQ04,5005
@@ -28,20 +28,22 @@ os_vif/tests/functional/privsep.py,sha256=c7dqBiO4d-hxgCq-DgbP2A7HB6fdhZK4X0ADYU
 os_vif/tests/functional/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/functional/internal/command/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/functional/internal/command/ip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-os_vif/tests/functional/internal/command/ip/test_impl_pyroute2.py,sha256=J1NsdZAK_OY6dvKlb6HstJAhDvKUOEMzox8sAZGe-mo,9982
+os_vif/tests/functional/internal/command/ip/test_impl_pyroute2.py,sha256=hQrZAnV3S6sbp_6QCS4WHmZIZl-udrw0J8c9VCStqZw,14778
 os_vif/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/unit/base.py,sha256=sEjrOSy3yW16WwOorv164ZuUyvKh2TY0gMoVf6lg3kA,795
 os_vif/tests/unit/test_base.py,sha256=iqgweFRWprY98mkGL3HIbV9D8DuX_tUPH8uRiDflwDc,3137
 os_vif/tests/unit/test_exception.py,sha256=UDVJSR3CKU3rc5kmN14ilL9Fj0cgnwQbGoP4weo2P4w,1335
 os_vif/tests/unit/test_host_info.py,sha256=2PYHg4pY-YwUuSg9MyDKJbJhKVGRT6ujJATkzzIPx18,7576
-os_vif/tests/unit/test_objects.py,sha256=WflvhMvvCauXexj04tCw47HvsysHX4Q7fsgJKrPNaI8,3709
+os_vif/tests/unit/test_objects.py,sha256=Bpd-edRlIZ7ojvNw4V9SaMQd9ih7lSlrKnHDG8Zb9Ns,6292
 os_vif/tests/unit/test_os_vif.py,sha256=b0h65Wa9tvxw-e7c707SoJQjfGzEALSFZUPkTtr_GkY,6612
 os_vif/tests/unit/test_vif.py,sha256=mhg2PZ3iVEPzffO5I0VT1wIUP3c-h7MAqrZgCuZdjxE,18000
 os_vif/tests/unit/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/unit/internal/ip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 os_vif/tests/unit/internal/ip/test_api.py,sha256=LnkAM0M8giNjAw_Q4-oRic3WIW3OWq-SCGlde9SCenY,820
 os_vif/tests/unit/internal/ip/linux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-os_vif/tests/unit/internal/ip/linux/test_impl_pyroute2.py,sha256=SKLPhV2O9EVXkgE4jVH2pHUt27W7vcNy6iVs2OECR8c,7540
+os_vif/tests/unit/internal/ip/linux/test_impl_pyroute2.py,sha256=9R2YhJlN-DSTYUnR9xLuuN1NlXkwkC1LL0wXnR7b6ck,10207
+os_vif-4.3.0.dist-info/licenses/AUTHORS,sha256=1vx_YLfQyRK6hjRsylsaEcnk3tHr-EeOH2G6htWR224,3434
+os_vif-4.3.0.dist-info/licenses/LICENSE,sha256=XfKg2H1sVi8OoRxoisUlMqoo10TKvHmU_wU39ks7MyA,10143
 vif_plug_linux_bridge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vif_plug_linux_bridge/constants.py,sha256=NC8n4uOMFCYrhq0sM1ZeGBKo-Gs4OMR60cYP47wMRCk,602
 vif_plug_linux_bridge/iptables.py,sha256=q4LmAMMzg-r9IgDNTu3jCLjNDM8b0JbGo-qmiA2B-JE,20641
@@ -59,9 +61,9 @@ vif_plug_noop/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 vif_plug_noop/tests/unit/test_plugin.py,sha256=x8m9zuGtHsPoZRZP6Q6BREAFx0wiEagFtTFlB_i_Bxc,1236
 vif_plug_ovs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vif_plug_ovs/constants.py,sha256=vQKnYSeBMjV2RGQPGxk96D8FtgpvJIZEX_yZzUlsGg8,892
-vif_plug_ovs/exception.py,sha256=ZiECZVvjCFTVXhuii3uhJn4lZvozKRxziedZB3R9JNo,1328
-vif_plug_ovs/linux_net.py,sha256=HvhfSXjeAlU2l9iZNiN8CFr-GL9psS8Hk8_KAaktH6I,13922
-vif_plug_ovs/ovs.py,sha256=zvxORVO_bW9_2QgoAYFf7Fdu3VtwcSJz1qJ3aY4TEmg,22920
+vif_plug_ovs/exception.py,sha256=5MQZsoUFZ7kShXQA3Jeax9CcOYpT2I3h-F8ugNMncks,1569
+vif_plug_ovs/linux_net.py,sha256=El3C-9utimXonEE51D5lDthP5gmFkH_XI6jyrcWXOF4,14873
+vif_plug_ovs/ovs.py,sha256=_j3iCYnvwNemyR_vfAH3xMkWCCvbEWesRA6vrvi-uRE,25386
 vif_plug_ovs/privsep.py,sha256=nPQUkYgjbSjaHMuu40fZArRnf8RBiR73l4YpDF1K1yQ,1100
 vif_plug_ovs/ovsdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vif_plug_ovs/ovsdb/api.py,sha256=_jHR8xokDAPI8sw3IEWuT3hObJuskqVzeVMDaWRbIq0,1293
@@ -71,19 +73,17 @@ vif_plug_ovs/ovsdb/ovsdb_lib.py,sha256=U7mZk_1q5tnHgWsgBotIqt_-fu7I3pfBGapchmlLc
 vif_plug_ovs/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vif_plug_ovs/tests/functional/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vif_plug_ovs/tests/functional/base.py,sha256=GZKyA9UR9BaEgZ0tv6xyMTQnz9FpKedV2do1ePMB-rw,2059
-vif_plug_ovs/tests/functional/test_plugin.py,sha256=1zVCielOSCKjn6NMMYfxEp1t-nmTUHGciPZeJghZd8c,10447
+vif_plug_ovs/tests/functional/test_plugin.py,sha256=f2XdYkZPiOL5hzzXCM3bMwGw8CMsbjWkA_HvcIFyZZk,13018
 vif_plug_ovs/tests/functional/ovsdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vif_plug_ovs/tests/functional/ovsdb/test_ovsdb_lib.py,sha256=tXSTmjYWOmqLXYQ42_3Sv8XNNktlDxPDalJRr8KRwCU,13775
+vif_plug_ovs/tests/functional/ovsdb/test_ovsdb_lib.py,sha256=dSmQyqzFn9VSgxEeHr5EHePnhfx_SvlA5IxX1gGGAes,13517
 vif_plug_ovs/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vif_plug_ovs/tests/unit/test_linux_net.py,sha256=B3buNpn9EKZQPio5rNrIma_E5MUL9vBspdg5EqZ3RHk,17532
-vif_plug_ovs/tests/unit/test_plugin.py,sha256=YfJXJirOWbZB2l2VHTiJPCMZlgBCyRXDAFgzEj6pQeY,30827
+vif_plug_ovs/tests/unit/test_linux_net.py,sha256=TQ4If-mNl2Q8-JoIrNH8QRPO2jQDTkKlSvwKawsgsSs,19703
+vif_plug_ovs/tests/unit/test_plugin.py,sha256=3tH3jpazI83m9TQaScQ-o9NHSO1_2Fk29LHV9Q_kT4M,43506
 vif_plug_ovs/tests/unit/ovsdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vif_plug_ovs/tests/unit/ovsdb/test_ovsdb_lib.py,sha256=mec9WESL92MQZonDVyBrsJJveMcLyvHKPj1GU8yYGjo,10687
-os_vif-4.2.1.dist-info/AUTHORS,sha256=nljv1JcwR_ww3Wbk3qLgNHa-b2DwpSggdnTI0REYvyo,3356
-os_vif-4.2.1.dist-info/LICENSE,sha256=XfKg2H1sVi8OoRxoisUlMqoo10TKvHmU_wU39ks7MyA,10143
-os_vif-4.2.1.dist-info/METADATA,sha256=py0CxkiQZ-llyYDhoMOak5u6Kd6NrZ0DecEn87qQbPw,2324
-os_vif-4.2.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-os_vif-4.2.1.dist-info/entry_points.txt,sha256=BU9WplZnF_bjwT4SQP5n1mKu2f0R5xXBOznXP1GygHM,206
-os_vif-4.2.1.dist-info/pbr.json,sha256=9Bn0S-V8G7QyTsM_UW7im9HossXmtpKDvFHkOwabN50,46
-os_vif-4.2.1.dist-info/top_level.txt,sha256=ULBxtkTk3bkfzCSYJjifWehfjJdMODVzC6SX5l_CNKo,56
-os_vif-4.2.1.dist-info/RECORD,,
+os_vif-4.3.0.dist-info/METADATA,sha256=9GHnBKuER01IWkhNAktrSm96MNkjK6-K8RxXoFMLw9g,2533
+os_vif-4.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+os_vif-4.3.0.dist-info/entry_points.txt,sha256=BU9WplZnF_bjwT4SQP5n1mKu2f0R5xXBOznXP1GygHM,206
+os_vif-4.3.0.dist-info/pbr.json,sha256=5Ah5X1ihi7jQlwKHCYVuLIcFpYUEB-NSbfUFgmYOH2o,46
+os_vif-4.3.0.dist-info/top_level.txt,sha256=ULBxtkTk3bkfzCSYJjifWehfjJdMODVzC6SX5l_CNKo,56
+os_vif-4.3.0.dist-info/RECORD,,

{os_vif-4.2.1.dist-info → os_vif-4.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{os_vif-4.2.1.dist-info → os_vif-4.3.0.dist-info/licenses}/AUTHORS

@@ -1,8 +1,10 @@
 Adrian Chiris <adrianc@mellanox.com>
+Adrien Cunin <a.cunin@syseleven.de>
 Alin Balutoiu <abalutoiu@cloudbasesolutions.com>
 Andreas Jaeger <aj@suse.com>
 Balazs Gibizer <gibi@redhat.com>
 Bence Romsics <bence.romsics@gmail.com>
+Bodo Petermann <b.petermann@syseleven.de>
 Brian Haley <brian.haley@hpe.com>
 Cao Xuan Hoang <hoangcx@vn.fujitsu.com>
 Carlos Goncalves <cgoncalves@redhat.com>

os_vif-4.3.0.dist-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "8cbe6ee", "is_release": true}

vif_plug_ovs/exception.py

@@ -35,3 +35,9 @@ class RepresentorNotFound(osv_exception.ExceptionBase):
 
 class PciDeviceNotFoundById(osv_exception.ExceptionBase):
     msg_fmt = _("PCI device %(id)s not found")
+
+
+class TapCreationNotSupported(osv_exception.ExceptionBase):
+    msg_fmt = _('Tap device creation requested for unsupported VIF type. '
+                'create_tap is only supported for VIFOpenVSwitch, got '
+                '%(vif_type)s')

vif_plug_ovs/linux_net.py

@@ -90,6 +90,29 @@ def update_veth_pair(dev1_name, dev2_name, mtu):
         _update_device_mtu(dev, mtu)
 
 
+@privsep.vif_plug.entrypoint
+def create_tap(dev, mtu, mac, multiqueue=False):
+    """Create a tap device with the specified configuration.
+
+    Creates a tap device using pyroute2's netlink interface, with optional
+    multiqueue support for better performance with multiple VCPUs.
+
+    :param dev: Device name (string)
+    :param mtu: MTU value (integer)
+    :param mac: MAC address (string)
+    :param multiqueue: Enable multiqueue support (boolean, default False)
+                       Requires Linux kernel 3.8+
+    """
+    # Create the tap device with optional multiqueue support
+    # Use check_exit_code=[0, 17] to handle EEXIST (device already exists)
+    ip_lib.add(dev, 'tuntap', mode='tap', multiqueue=multiqueue,
+               check_exit_code=[0, 17])
+    # Configure the device state and MAC address
+    ip_lib.set(dev, state='up', address=mac, check_exit_code=[0, 2, 254])
+    # Set MTU if specified
+    _update_device_mtu(dev, mtu)
+
+
 def _disable_ipv6(bridge):
     """Disable ipv6 if available for bridge. Must be called from
        privsep context.

vif_plug_ovs/ovs.py

@@ -223,7 +223,7 @@ class OvsPlugin(plugin.PluginBase):
             # This is a mitigation for the performance regression
             # introduced by the fix for bug #1734320. See bug #2017868
             # for more details.
-            if not self.ovsdb.port_exists(vif_name, vif.network.bridge):
+            if not self.ovsdb.port_exists(vif_name, bridge):
                 kwargs['qos_type'] = qos_type
         self.ovsdb.create_ovs_vif_port(
             bridge,
@@ -232,11 +232,62 @@ class OvsPlugin(plugin.PluginBase):
             vif.address, instance_info.uuid,
             mtu=mtu,
             **kwargs)
+        # Check if tap creation is requested:
+        # - 'field in profile.fields' checks if field exists in schema
+        # - 'field in profile' checks if the attribute is set on instance
+        profile = vif.port_profile
+        create_tap = (
+            isinstance(profile, objects.vif.VIFPortProfileOpenVSwitch) and
+            'create_tap' in profile.fields and
+            'create_tap' in profile and
+            profile.create_tap
+        )
+
+        if create_tap:
+            # Validate VIF type - only VIFOpenVSwitch supports tap creation
+            if not isinstance(vif, objects.vif.VIFOpenVSwitch):
+                raise exception.TapCreationNotSupported(
+                    vif_type=vif.__class__.__name__)
+
+            # Get multiqueue setting from port profile if available
+            # 'field in profile.fields' checks schema, 'field in profile'
+            # checks if the attribute is set
+            multiqueue = ('multiqueue' in profile.fields and
+                          'multiqueue' in profile and
+                          profile.multiqueue)
+
+            # Create the tap device with proper MAC and MTU if it doesn't
+            # already exist (e.g., from a previous plug during init_host)
+            if not ip_lib.exists(vif_name):
+                linux_net.create_tap(
+                    vif_name, mtu, vif.address, multiqueue=multiqueue)
 
     def _update_vif_port(self, vif, vif_name):
         mtu = self._get_mtu(vif)
         self.ovsdb.update_ovs_vif_port(vif_name, mtu)
 
+    def _delete_tap_if_required(self, vif, vif_name):
+        """Delete tap device if it was created via create_tap flag.
+
+        :param vif: VIF object
+        :param vif_name: Name of the tap device
+        """
+        # Check if this VIF had a tap device created for it:
+        # - 'field in profile.fields' checks if field exists in schema
+        # - 'field in profile' checks if the attribute is set on instance
+        profile = getattr(vif, 'port_profile', None)
+        create_tap = (
+            profile is not None and
+            isinstance(profile, objects.vif.VIFPortProfileOpenVSwitch) and
+            isinstance(vif, objects.vif.VIFOpenVSwitch) and
+            'create_tap' in profile.fields and
+            'create_tap' in profile and
+            profile.create_tap
+        )
+
+        if create_tap and ip_lib.exists(vif_name):
+            linux_net.delete_net_dev(vif_name)
+
     @staticmethod
     def _get_vif_datapath_type(vif, datapath=constants.OVS_DATAPATH_SYSTEM):
         profile = vif.port_profile
@@ -428,6 +479,9 @@ class OvsPlugin(plugin.PluginBase):
 
     def _unplug_port_bridge(self, vif, instance_info):
         """Create a per-VIF OVS bridge and patch pair."""
+        # Delete tap device if it was created
+        self._delete_tap_if_required(vif, vif.vif_name)
+
         # NOTE(sean-k-mooney): the port name prefix should not be
         # changed to avoid loosing ports on upgrade.
         port_bridge_name = self.gen_port_name('pb', vif.id)
@@ -444,6 +498,9 @@ class OvsPlugin(plugin.PluginBase):
 
     def _unplug_vif_generic(self, vif, instance_info):
         """Remove port from OVS."""
+        # Delete tap device if it was created
+        self._delete_tap_if_required(vif, vif.vif_name)
+
         # NOTE(sean-k-mooney): even with the partial revert of change
         # Iaf15fa7a678ec2624f7c12f634269c465fbad930 this should be correct
         # so this is not removed.

vif_plug_ovs/tests/functional/ovsdb/test_ovsdb_lib.py

@@ -183,12 +183,7 @@ class TestOVSDBLib(testscenarios.WithScenarios,
             'Interface', port_bridge_port, 'options', port_opts)
 
     def test_create_ovs_vif_port_with_default_qos(self):
-        if self.interface == 'native':
-            self.skipTest(
-                'test_create_ovs_vif_port_with_default_qos is unstable '
-                'when run with the native driver, see: '
-                'https://bugs.launchpad.net/os-vif/+bug/2087982')
-        port_name = 'qos-port-' + self.interface
+        port_name = 'def-qos-port-' + self.interface
         iface_id = 'iface_id'
         mac = 'ca:fe:ca:fe:ca:fe'
         instance_id = uuidutils.generate_uuid()

vif_plug_ovs/tests/functional/test_plugin.py

@@ -186,6 +186,63 @@ class TestOVSPlugin(testscenarios.WithScenarios,
             'QoS', str(qos_uuid), 'type', None
         )
 
+    def test_plug_unplug_ovs_port_with_qos_per_port_bridge(self):
+        with mock.patch.object(self.plugin.config, 'per_port_bridge', True):
+            bridge = 'br-ppb-' + self.interface
+            vif_name = 'port-ppb-' + self.interface
+            qos_type = CONF.os_vif_ovs.default_qos_type
+
+            network = objects.network.Network(
+                id='6977aa43-b7c3-484a-8bcb-09d77374981b',
+                bridge=bridge,
+                subnets=self.subnets,
+                vlan=99)
+            vif = objects.vif.VIFOpenVSwitch(
+                id='e5cf7112-a72f-43a4-aaa3-48a5cfbdeaca',
+                address='ca:fe:de:ad:be:ef',
+                network=network,
+                port_profile=self.profile_ovs_system,
+                vif_name=vif_name)
+            port_bridge_name = self.plugin.gen_port_name('pb', vif.id)
+
+            self.addCleanup(self._del_bridge, bridge)
+            self.addCleanup(self._del_bridge, port_bridge_name)
+            self.addCleanup(
+                self.ovs.delete_ovs_vif_port, port_bridge_name, vif_name,
+                delete_netdev=False, qos_type=qos_type
+            )
+            self.addCleanup(del_device, vif_name)
+            add_device(vif_name, 'dummy')
+            # plugging a vif will create the port and bridges
+            # if they don't exist
+            self.plugin.plug(vif, self.instance)
+            self.assertTrue(self._check_bridge(bridge))
+            self.assertTrue(self._check_bridge(port_bridge_name))
+            self.assertTrue(self._check_port(vif_name, port_bridge_name))
+
+            # Plugging a second time should succeed
+            self.plugin.plug(vif, self.instance)
+
+            # Check that the 2nd plug did not create a 2nd qos row,
+            # which happened in https://bugs.launchpad.net/os-vif/+bug/2133225
+            qos = self.ovs.get_qos(vif_name, qos_type)
+            self.assertEqual(1, len(qos))
+
+            qos_uuid = qos[0]['_uuid']
+            self._check_parameter('Port', vif_name, 'qos', qos_uuid)
+            self._check_parameter(
+                'QoS', str(qos_uuid), 'type', qos_type
+            )
+            # unplugging a port will not delete the int bridge,
+            # only the per-port bridge.
+            self.plugin.unplug(vif, self.instance)
+            self.assertTrue(self._check_bridge(bridge))
+            self.assertFalse(self._check_bridge(port_bridge_name))
+            self.assertFalse(self._check_port(vif_name, bridge))
+            self._check_parameter(
+                'QoS', str(qos_uuid), 'type', None
+            )
+
     def test_plug_br_int_isolate_vif_dead_vlan(self):
         with mock.patch.object(self.plugin.config, 'isolate_vif', True):
             network = objects.network.Network(

vif_plug_ovs/tests/unit/test_linux_net.py

@@ -396,3 +396,47 @@ class LinuxNetTest(testtools.TestCase):
         mock_isfile.return_value = False
         phys_port_name = linux_net._get_phys_switch_id("ifname")
         self.assertIsNone(phys_port_name)
+
+    @mock.patch.object(linux_net, "_update_device_mtu")
+    @mock.patch.object(ip_lib, "set")
+    @mock.patch.object(ip_lib, "add")
+    def test_create_tap(self, mock_add, mock_set, mock_update_mtu):
+        """Test basic tap device creation."""
+        linux_net.create_tap("tap0", 1500, "aa:bb:cc:dd:ee:ff",
+                             multiqueue=False)
+
+        mock_add.assert_called_once_with("tap0", "tuntap", mode="tap",
+                                         multiqueue=False,
+                                         check_exit_code=[0, 17])
+        mock_set.assert_called_once_with("tap0", state="up",
+                                         address="aa:bb:cc:dd:ee:ff",
+                                         check_exit_code=[0, 2, 254])
+        mock_update_mtu.assert_called_once_with("tap0", 1500)
+
+    @mock.patch.object(linux_net, "_update_device_mtu")
+    @mock.patch.object(ip_lib, "set")
+    @mock.patch.object(ip_lib, "add")
+    def test_create_tap_with_multiqueue(self, mock_add, mock_set,
+                                        mock_update_mtu):
+        """Test tap device creation with multiqueue enabled."""
+        linux_net.create_tap("tap0", 1500, "aa:bb:cc:dd:ee:ff",
+                             multiqueue=True)
+
+        mock_add.assert_called_once_with("tap0", "tuntap", mode="tap",
+                                         multiqueue=True,
+                                         check_exit_code=[0, 17])
+        mock_set.assert_called_once_with("tap0", state="up",
+                                         address="aa:bb:cc:dd:ee:ff",
+                                         check_exit_code=[0, 2, 254])
+        mock_update_mtu.assert_called_once_with("tap0", 1500)
+
+    @mock.patch.object(linux_net, "_update_device_mtu")
+    @mock.patch.object(ip_lib, "set")
+    @mock.patch.object(ip_lib, "add")
+    def test_create_tap_no_mtu(self, mock_add, mock_set, mock_update_mtu):
+        """Test tap device creation without MTU."""
+        linux_net.create_tap("tap0", None, "aa:bb:cc:dd:ee:ff")
+
+        mock_add.assert_called_once()
+        mock_set.assert_called_once()
+        mock_update_mtu.assert_called_once_with("tap0", None)

vif_plug_ovs/tests/unit/test_plugin.py

@@ -19,6 +19,7 @@ from os_vif import objects
 from os_vif.objects import fields
 
 from vif_plug_ovs import constants
+from vif_plug_ovs import exception
 from vif_plug_ovs import linux_net
 from vif_plug_ovs import ovs
 from vif_plug_ovs.ovsdb import ovsdb_lib
@@ -96,6 +97,13 @@ class PluginTest(testtools.TestCase):
             vif_name='tap-xxx-yyy-zzz',
             port_profile=self.profile_ovs)
 
+        self.vif_ovs_system = objects.vif.VIFOpenVSwitch(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            vif_name='tap-xxx-yyy-zzz',
+            port_profile=self.profile_ovs_system)
+
         # This is used for ironic with vif_type=smartnic
         self.vif_ovs_smart_nic = objects.vif.VIFOpenVSwitch(
             id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
@@ -241,6 +249,88 @@ class PluginTest(testtools.TestCase):
                 mtu=plugin.config.network_device_mtu,
                 interface_type=constants.OVS_VHOSTUSER_INTERFACE_TYPE)
 
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_qos_port_bridge_true_port_new(
+            self, mock_port_exists, mock_create_ovs_vif_port):
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = False
+        port_bridge_name = "port-bridge-xxx"
+        # _create_vif_port as from _plug_port_bridge
+        plugin._create_vif_port(
+            self.vif_ovs_system, mock.sentinel.vif_name, self.instance,
+            bridge=port_bridge_name, set_ids=False)
+        # port existence should be checked on the per-port bridge
+        mock_port_exists.assert_called_once_with(
+            mock.sentinel.vif_name, port_bridge_name)
+        # qos_type should be set for the new port
+        mock_create_ovs_vif_port.assert_called_once_with(
+            port_bridge_name, mock.sentinel.vif_name,
+            self.vif_ovs_system.port_profile.interface_id,
+            self.vif_ovs_system.address, self.instance.uuid,
+            mtu=plugin.config.network_device_mtu,
+            set_ids=False,
+            qos_type="linux-noop")
+
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_qos_port_bridge_true_port_exists(
+            self, mock_port_exists, mock_create_ovs_vif_port):
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = True
+        port_bridge_name = "port-bridge-xxx"
+        # _create_vif_port as from _plug_port_bridge
+        plugin._create_vif_port(
+            self.vif_ovs_system, mock.sentinel.vif_name, self.instance,
+            bridge=port_bridge_name, set_ids=False)
+        # port existence should be checked on the per-port bridge
+        mock_port_exists.assert_called_once_with(
+            mock.sentinel.vif_name, port_bridge_name)
+        # qos_type should not be set for the existing port
+        mock_create_ovs_vif_port.assert_called_once_with(
+            port_bridge_name, mock.sentinel.vif_name,
+            self.vif_ovs_system.port_profile.interface_id,
+            self.vif_ovs_system.address, self.instance.uuid,
+            mtu=plugin.config.network_device_mtu,
+            set_ids=False)
+
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_qos_port_bridge_false_port_new(
+            self, mock_port_exists, mock_create_ovs_vif_port):
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = False
+        # _create_vif_port as from _plug_vif_generic
+        plugin._create_vif_port(
+            self.vif_ovs_system, mock.sentinel.vif_name, self.instance)
+        mock_port_exists.assert_called_once_with(
+            mock.sentinel.vif_name, self.vif_ovs_system.network.bridge)
+        # qos_type should be set for the new port
+        mock_create_ovs_vif_port.assert_called_once_with(
+            self.vif_ovs_system.network.bridge, mock.sentinel.vif_name,
+            self.vif_ovs_system.port_profile.interface_id,
+            self.vif_ovs_system.address, self.instance.uuid,
+            mtu=plugin.config.network_device_mtu,
+            qos_type="linux-noop")
+
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_qos_port_bridge_false_port_exists(
+            self, mock_port_exists, mock_create_ovs_vif_port):
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = True
+        # _create_vif_port as from _plug_vif_generic
+        plugin._create_vif_port(
+            self.vif_ovs_system, mock.sentinel.vif_name, self.instance)
+        mock_port_exists.assert_called_once_with(
+            mock.sentinel.vif_name, self.vif_ovs_system.network.bridge)
+        # qos_type should not be set for the existing port
+        mock_create_ovs_vif_port.assert_called_once_with(
+            self.vif_ovs_system.network.bridge, mock.sentinel.vif_name,
+            self.vif_ovs_system.port_profile.interface_id,
+            self.vif_ovs_system.address, self.instance.uuid,
+            mtu=plugin.config.network_device_mtu)
+
     @mock.patch.object(ovs.OvsPlugin, '_plug_vif_generic')
     def test_plug_ovs_port_bridge_false(self, plug_vif_generic):
         plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
@@ -648,3 +738,179 @@ class PluginTest(testtools.TestCase):
         plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
         plugin.unplug(self.vif_ovs, self.instance)
         m_unplug_generic.assert_called_once()
+
+    @mock.patch.object(linux_net, 'create_tap')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_with_tap_creation(
+            self, mock_port_exists, mock_create_ovs_vif_port, mock_create_tap):
+        """Test that create_tap is called when create_tap flag is set."""
+        # Create a profile with create_tap=True
+        profile_with_tap = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True)
+        vif_with_tap = objects.vif.VIFOpenVSwitch(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            vif_name='tap-xxx-yyy-zzz',
+            port_profile=profile_with_tap)
+
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = False
+        plugin._create_vif_port(
+            vif_with_tap, 'tap-xxx-yyy-zzz', self.instance)
+
+        # Verify create_tap was called with correct parameters
+        mock_create_tap.assert_called_once_with(
+            'tap-xxx-yyy-zzz',
+            plugin.config.network_device_mtu,
+            'ca:fe:de:ad:be:ef',
+            multiqueue=False)
+
+    @mock.patch.object(linux_net, 'create_tap')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_with_tap_and_multiqueue(
+            self, mock_port_exists, mock_create_ovs_vif_port, mock_create_tap):
+        """Test that create_tap is called with multiqueue when both are set."""
+        # Create a profile with create_tap=True and multiqueue=True
+        profile_with_tap_mq = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True,
+            multiqueue=True)
+        vif_with_tap_mq = objects.vif.VIFOpenVSwitch(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            vif_name='tap-xxx-yyy-zzz',
+            port_profile=profile_with_tap_mq)
+
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = False
+        plugin._create_vif_port(
+            vif_with_tap_mq, 'tap-xxx-yyy-zzz', self.instance)
+
+        # Verify create_tap was called with multiqueue=True
+        mock_create_tap.assert_called_once_with(
+            'tap-xxx-yyy-zzz',
+            plugin.config.network_device_mtu,
+            'ca:fe:de:ad:be:ef',
+            multiqueue=True)
+
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_tap_not_supported_vhostuser(
+            self, mock_port_exists, mock_create_ovs_vif_port):
+        """Test that TapCreationNotSupported is raised for VIFVHostUser."""
+        # Create a VIFVHostUser with create_tap=True
+        profile_with_tap = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True)
+        vif_vhostuser_with_tap = objects.vif.VIFVHostUser(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            path='/var/run/openvswitch/vhub679325f-ca',
+            mode='client',
+            port_profile=profile_with_tap)
+
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = False
+
+        # Verify exception is raised
+        self.assertRaises(
+            exception.TapCreationNotSupported,
+            plugin._create_vif_port,
+            vif_vhostuser_with_tap, 'vhub679325f-ca', self.instance)
+
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'create_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'port_exists')
+    def test_create_vif_port_tap_not_supported_hostdevice(
+            self, mock_port_exists, mock_create_ovs_vif_port):
+        """Test that TapCreationNotSupported is raised for VIFHostDevice."""
+        # Create a VIFHostDevice with create_tap=True
+        profile_with_tap = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True)
+        vif_hostdevice_with_tap = objects.vif.VIFHostDevice(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            dev_type=fields.VIFHostDeviceDevType.ETHERNET,
+            dev_address='0002:24:12.3',
+            port_profile=profile_with_tap)
+
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        mock_port_exists.return_value = False
+
+        # Verify exception is raised
+        self.assertRaises(
+            exception.TapCreationNotSupported,
+            plugin._create_vif_port,
+            vif_hostdevice_with_tap, 'tap-xxx-yyy-zzz', self.instance)
+
+    @mock.patch.object(ip_lib, 'exists', return_value=True)
+    @mock.patch.object(linux_net, 'delete_net_dev')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'delete_ovs_vif_port')
+    def test_unplug_vif_generic_deletes_tap(
+            self, mock_delete_ovs_vif_port, mock_delete_net_dev,
+            mock_exists):
+        """Test that tap device is deleted when unplugging with
+        create_tap=True.
+        """
+        # Create a VIF with create_tap=True
+        profile_with_tap = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True)
+        vif_with_tap = objects.vif.VIFOpenVSwitch(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            vif_name='tap-xxx-yyy-zzz',
+            port_profile=profile_with_tap)
+
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        plugin._unplug_vif_generic(vif_with_tap, self.instance)
+
+        # Verify delete_net_dev was called with vif_name
+        mock_delete_net_dev.assert_called_once_with('tap-xxx-yyy-zzz')
+
+    @mock.patch.object(linux_net, 'delete_net_dev')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'delete_ovs_vif_port')
+    def test_unplug_vif_generic_no_tap_deletion_when_not_created(
+            self, mock_delete_ovs_vif_port, mock_delete_net_dev):
+        """Test that tap device is not deleted when create_tap=False."""
+        # Use default vif_ovs which has create_tap=False (or unset)
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        plugin._unplug_vif_generic(self.vif_ovs, self.instance)
+
+        # Verify delete_net_dev was not called
+        mock_delete_net_dev.assert_not_called()
+
+    @mock.patch.object(ip_lib, 'exists', return_value=True)
+    @mock.patch.object(linux_net, 'delete_net_dev')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'delete_ovs_vif_port')
+    @mock.patch.object(ovsdb_lib.BaseOVS, 'delete_ovs_bridge')
+    def test_unplug_port_bridge_deletes_tap(
+            self, mock_delete_ovs_bridge, mock_delete_ovs_vif_port,
+            mock_delete_net_dev, mock_exists):
+        """Test that tap device is deleted when unplugging port bridge with
+        create_tap=True.
+        """
+        # Create a VIF with create_tap=True
+        profile_with_tap = objects.vif.VIFPortProfileOpenVSwitch(
+            interface_id='e65867e0-9340-4a7f-a256-09af6eb7a3aa',
+            create_tap=True)
+        vif_with_tap = objects.vif.VIFOpenVSwitch(
+            id='b679325f-ca89-4ee0-a8be-6db1409b69ea',
+            address='ca:fe:de:ad:be:ef',
+            network=self.network_ovs,
+            vif_name='tap-xxx-yyy-zzz',
+            port_profile=profile_with_tap)
+
+        plugin = ovs.OvsPlugin.load(constants.PLUGIN_NAME)
+        plugin._unplug_port_bridge(vif_with_tap, self.instance)
+
+        # Verify delete_net_dev was called with vif_name
+        mock_delete_net_dev.assert_called_once_with('tap-xxx-yyy-zzz')

os_vif-4.2.1.dist-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "b33415b", "is_release": true}