From: Cedric Brandily Date: Thu, 5 Nov 2015 22:40:45 +0000 (+0100) Subject: Move LinuxBridge related features to bridge_lib X-Git-Url: https://review.fuel-infra.org/gitweb?a=commitdiff_plain;h=459980f04a62e2ef15a2b8c91ac6c8d6ee484167;p=openstack-build%2Fneutron-build.git Move LinuxBridge related features to bridge_lib This change moves from linuxbridge agent[1] to bridge_lib[2] bridge only related features and adds functional tests. [1] neutron.plugins.ml2.drivers.linuxbridge.agent.linuxbridge_neutron_agent [2] neutron.agent.linux.bridge_lib Partial-Bug: #1514548 Change-Id: Ieccb8f77fc833467a166557e227023f5c2a50d1b --- diff --git a/neutron/agent/linux/bridge_lib.py b/neutron/agent/linux/bridge_lib.py index e8176510f..dd1712cbf 100644 --- a/neutron/agent/linux/bridge_lib.py +++ b/neutron/agent/linux/bridge_lib.py @@ -16,8 +16,27 @@ # License for the specific language governing permissions and limitations # under the License. +import os + from neutron.agent.linux import ip_lib +BRIDGE_FS = "/sys/class/net/" +BRIDGE_INTERFACE_FS = BRIDGE_FS + "%(bridge)s/brif/%(interface)s" +BRIDGE_INTERFACES_FS = BRIDGE_FS + "%s/brif/" +BRIDGE_PORT_FS_FOR_DEVICE = BRIDGE_FS + "%s/brport" +BRIDGE_PATH_FOR_DEVICE = BRIDGE_PORT_FS_FOR_DEVICE + '/bridge' + + +def is_bridged_interface(interface): + if not interface: + return False + else: + return os.path.exists(BRIDGE_PORT_FS_FOR_DEVICE % interface) + + +def get_bridge_names(): + return os.listdir(BRIDGE_FS) + class BridgeDevice(ip_lib.IPDevice): def _brctl(self, cmd): @@ -31,6 +50,16 @@ class BridgeDevice(ip_lib.IPDevice): bridge._brctl(['addbr', bridge.name]) return bridge + @classmethod + def get_interface_bridge(cls, interface): + try: + path = os.readlink(BRIDGE_PATH_FOR_DEVICE % interface) + except OSError: + return None + else: + name = path.rpartition('/')[-1] + return cls(name) + def delbr(self): return self._brctl(['delbr', self.name]) @@ -45,3 +74,14 @@ class BridgeDevice(ip_lib.IPDevice): def disable_stp(self): return self._brctl(['stp', self.name, 'off']) + + def owns_interface(self, interface): + return os.path.exists( + BRIDGE_INTERFACE_FS % {'bridge': self.name, + 'interface': interface}) + + def get_interfaces(self): + try: + return os.listdir(BRIDGE_INTERFACES_FS % self.name) + except OSError: + return [] diff --git a/neutron/plugins/ml2/drivers/linuxbridge/agent/linuxbridge_neutron_agent.py b/neutron/plugins/ml2/drivers/linuxbridge/agent/linuxbridge_neutron_agent.py index 430a9572b..9568db251 100644 --- a/neutron/plugins/ml2/drivers/linuxbridge/agent/linuxbridge_neutron_agent.py +++ b/neutron/plugins/ml2/drivers/linuxbridge/agent/linuxbridge_neutron_agent.py @@ -19,7 +19,6 @@ # Based on the structure of the OpenVSwitch agent in the # Neutron OpenVSwitch Plugin. -import os import sys import time @@ -61,11 +60,6 @@ LOG = logging.getLogger(__name__) BRIDGE_NAME_PREFIX = "brq" # NOTE(toabctl): Don't use /sys/devices/virtual/net here because not all tap # devices are listed here (i.e. when using Xen) -BRIDGE_FS = "/sys/class/net/" -BRIDGE_INTERFACE_FS = BRIDGE_FS + "%(bridge)s/brif/%(interface)s" -BRIDGE_INTERFACES_FS = BRIDGE_FS + "%s/brif/" -BRIDGE_PORT_FS_FOR_DEVICE = BRIDGE_FS + "%s/brport" -BRIDGE_PATH_FOR_DEVICE = BRIDGE_PORT_FS_FOR_DEVICE + '/bridge' VXLAN_INTERFACE_PREFIX = "vxlan-" @@ -121,11 +115,6 @@ class LinuxBridgeManager(object): sys.exit(1) return device - @staticmethod - def interface_exists_on_bridge(bridge, interface): - return os.path.exists( - BRIDGE_INTERFACE_FS % {'bridge': bridge, 'interface': interface}) - def get_existing_bridge_name(self, physical_network): if not physical_network: return None @@ -176,7 +165,7 @@ class LinuxBridgeManager(object): def get_all_neutron_bridges(self): neutron_bridge_list = [] - bridge_list = os.listdir(BRIDGE_FS) + bridge_list = bridge_lib.get_bridge_names() for bridge in bridge_list: if bridge.startswith(BRIDGE_NAME_PREFIX): neutron_bridge_list.append(bridge) @@ -187,38 +176,18 @@ class LinuxBridgeManager(object): neutron_bridge_list.append(bridge_name) return neutron_bridge_list - def get_interfaces_on_bridge(self, bridge_name): - if ip_lib.device_exists(bridge_name): - return os.listdir(BRIDGE_INTERFACES_FS % bridge_name) - else: - return [] - def get_tap_devices_count(self, bridge_name): - try: - if_list = os.listdir(BRIDGE_INTERFACES_FS % bridge_name) - return len([interface for interface in if_list if - interface.startswith(constants.TAP_DEVICE_PREFIX)]) - except OSError: - return 0 + if_list = bridge_lib.BridgeDevice(bridge_name).get_interfaces() + return len([interface for interface in if_list if + interface.startswith(constants.TAP_DEVICE_PREFIX)]) def get_bridge_for_tap_device(self, tap_device_name): - try: - path = os.readlink(BRIDGE_PATH_FOR_DEVICE % tap_device_name) - except OSError: - pass - else: - bridge = path.rpartition('/')[-1] - if (bridge.startswith(BRIDGE_NAME_PREFIX) - or bridge in self.bridge_mappings.values()): - return bridge + bridge = bridge_lib.BridgeDevice.get_interface_bridge(tap_device_name) + if (bridge and (bridge.name.startswith(BRIDGE_NAME_PREFIX) + or bridge.name in self.bridge_mappings.values())): + return bridge return None - def is_device_on_bridge(self, device_name): - if not device_name: - return False - else: - return os.path.exists(BRIDGE_PORT_FS_FOR_DEVICE % device_name) - def ensure_vlan_bridge(self, network_id, phy_bridge_name, physical_interface, vlan_id): """Create a vlan and bridge unless they already exist.""" @@ -396,12 +365,12 @@ class LinuxBridgeManager(object): self.update_interface_ip_details(bridge_name, interface, ips, gateway) # Check if the interface is part of the bridge - if not self.interface_exists_on_bridge(bridge_name, interface): + if not bridge_device.owns_interface(interface): try: # Check if the interface is not enslaved in another bridge - if self.is_device_on_bridge(interface): + if bridge_lib.is_bridged_interface(interface): bridge = self.get_bridge_for_tap_device(interface) - bridge_lib.BridgeDevice(bridge).delif(interface) + bridge.delif(interface) bridge_device.addif(interface) except Exception as e: @@ -505,7 +474,7 @@ class LinuxBridgeManager(object): bridge_device = bridge_lib.BridgeDevice(bridge_name) if bridge_device.exists(): physical_interfaces = set(self.interface_mappings.values()) - interfaces_on_bridge = self.get_interfaces_on_bridge(bridge_name) + interfaces_on_bridge = bridge_device.get_interfaces() for interface in interfaces_on_bridge: self.remove_interface(bridge_name, interface) @@ -550,7 +519,7 @@ class LinuxBridgeManager(object): def remove_interface(self, bridge_name, interface_name): bridge_device = bridge_lib.BridgeDevice(bridge_name) if bridge_device.exists(): - if not self.is_device_on_bridge(interface_name): + if not bridge_lib.is_bridged_interface(interface_name): return True LOG.debug("Removing device %(interface_name)s from bridge " "%(bridge_name)s", @@ -581,7 +550,7 @@ class LinuxBridgeManager(object): def get_tap_devices(self): devices = set() - for device in os.listdir(BRIDGE_FS): + for device in bridge_lib.get_bridge_names(): if device.startswith(constants.TAP_DEVICE_PREFIX): devices.add(device) return devices diff --git a/neutron/tests/functional/agent/linux/test_bridge_lib.py b/neutron/tests/functional/agent/linux/test_bridge_lib.py new file mode 100644 index 000000000..7c88b8cb9 --- /dev/null +++ b/neutron/tests/functional/agent/linux/test_bridge_lib.py @@ -0,0 +1,61 @@ +# Copyright (c) 2015 Thales Services SAS +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + + +from neutron.agent.linux import bridge_lib +from neutron.tests.common import net_helpers +from neutron.tests.functional import base + + +class BridgeLibTestCase(base.BaseSudoTestCase): + + def setUp(self): + super(BridgeLibTestCase, self).setUp() + self.bridge, self.port_fixture = self.create_bridge_port_fixture() + + def create_bridge_port_fixture(self): + bridge = self.useFixture( + net_helpers.LinuxBridgeFixture(namespace=None)).bridge + port_fixture = self.useFixture( + net_helpers.LinuxBridgePortFixture(bridge)) + return bridge, port_fixture + + def test_is_bridged_interface(self): + self.assertTrue( + bridge_lib.is_bridged_interface(self.port_fixture.br_port.name)) + + def test_is_not_bridged_interface(self): + self.assertFalse( + bridge_lib.is_bridged_interface(self.port_fixture.port.name)) + + def test_get_bridge_names(self): + self.assertIn(self.bridge.name, bridge_lib.get_bridge_names()) + + def test_get_interface_bridge(self): + bridge = bridge_lib.BridgeDevice.get_interface_bridge( + self.port_fixture.br_port.name) + self.assertEqual(self.bridge.name, bridge.name) + + def test_get_interface_no_bridge(self): + bridge = bridge_lib.BridgeDevice.get_interface_bridge( + self.port_fixture.port.name) + self.assertIsNone(bridge) + + def test_get_interfaces(self): + self.assertEqual( + [self.port_fixture.br_port.name], self.bridge.get_interfaces()) + + def test_get_interfaces_no_bridge(self): + bridge = bridge_lib.BridgeDevice('--fake--') + self.assertEqual([], bridge.get_interfaces()) diff --git a/neutron/tests/functional/agent/test_l2_lb_agent.py b/neutron/tests/functional/agent/test_l2_lb_agent.py index 13939e022..5dfdacd40 100644 --- a/neutron/tests/functional/agent/test_l2_lb_agent.py +++ b/neutron/tests/functional/agent/test_l2_lb_agent.py @@ -19,7 +19,6 @@ import testtools from neutron.plugins.ml2.drivers.linuxbridge.agent import \ linuxbridge_neutron_agent -from neutron.tests.common import net_helpers from neutron.tests.functional.agent.linux import test_ip_lib LOG = logging.getLogger(__name__) @@ -35,13 +34,6 @@ class LinuxBridgeAgentTests(test_ip_lib.IpLibTestFramework): mock.patch('neutron.agent.rpc.PluginReportStateAPI').start() cfg.CONF.set_override('enable_vxlan', False, 'VXLAN') - def create_bridge_port_fixture(self): - bridge = self.useFixture( - net_helpers.LinuxBridgeFixture(namespace=None)).bridge - port_fixture = self.useFixture( - net_helpers.LinuxBridgePortFixture(bridge)) - return port_fixture - def test_validate_interface_mappings(self): mappings = {'physnet1': 'int1', 'physnet2': 'int2'} with testtools.ExpectedException(SystemExit): @@ -64,27 +56,3 @@ class LinuxBridgeAgentTests(test_ip_lib.IpLibTestFramework): self.generate_device_details()._replace(namespace=None, name='br-eth1')) lba.LinuxBridgeManager(mappings, {}) - - def test_interface_exists_on_bridge(self): - port_fixture = self.create_bridge_port_fixture() - self.assertTrue( - lba.LinuxBridgeManager.interface_exists_on_bridge( - port_fixture.bridge.name, port_fixture.br_port.name)) - - def test_interface_exists_not_on_bridge(self): - port_fixture = self.create_bridge_port_fixture() - self.assertFalse( - lba.LinuxBridgeManager.interface_exists_on_bridge( - port_fixture.bridge.name, port_fixture.port.name)) - - def test_get_bridge_for_tap_device(self): - port_fixture = self.create_bridge_port_fixture() - mappings = {'physnet1': port_fixture.bridge.name} - lbm = lba.LinuxBridgeManager(mappings, {}) - self.assertEqual( - port_fixture.bridge.name, - lbm.get_bridge_for_tap_device(port_fixture.br_port.name)) - - def test_get_no_bridge_for_tap_device(self): - lbm = lba.LinuxBridgeManager({}, {}) - self.assertIsNone(lbm.get_bridge_for_tap_device('fake')) diff --git a/neutron/tests/unit/agent/linux/test_bridge_lib.py b/neutron/tests/unit/agent/linux/test_bridge_lib.py index 3b9701d08..425415744 100644 --- a/neutron/tests/unit/agent/linux/test_bridge_lib.py +++ b/neutron/tests/unit/agent/linux/test_bridge_lib.py @@ -36,6 +36,21 @@ class BridgeLibTest(base.BaseTestCase): self.execute.assert_called_once_with(cmd, run_as_root=True) self.execute.reset_mock() + def test_is_bridged_interface(self): + exists = lambda path: path == "/sys/class/net/tapOK/brport" + with mock.patch('os.path.exists', side_effect=exists): + self.assertTrue(bridge_lib.is_bridged_interface("tapOK")) + self.assertFalse(bridge_lib.is_bridged_interface("tapKO")) + + def test_get_interface_bridge(self): + with mock.patch('os.readlink', side_effect=["prefix/br0", OSError()]): + br = bridge_lib.BridgeDevice.get_interface_bridge('tap0') + self.assertIsInstance(br, bridge_lib.BridgeDevice) + self.assertEqual("br0", br.name) + + br = bridge_lib.BridgeDevice.get_interface_bridge('tap0') + self.assertIsNone(br) + def _test_br(self, namespace=None): br = bridge_lib.BridgeDevice.addbr(self._BR_NAME, namespace) self.assertEqual(namespace, br.namespace) @@ -63,3 +78,17 @@ class BridgeLibTest(base.BaseTestCase): def test_addbr_without_namespace(self): self._test_br() + + def test_owns_interface(self): + br = bridge_lib.BridgeDevice('br-int') + exists = lambda path: path == "/sys/class/net/br-int/brif/abc" + with mock.patch('os.path.exists', side_effect=exists): + self.assertTrue(br.owns_interface("abc")) + self.assertFalse(br.owns_interface("def")) + + def test_get_interfaces(self): + br = bridge_lib.BridgeDevice('br-int') + interfaces = ["tap1", "tap2"] + with mock.patch('os.listdir', side_effect=[interfaces, OSError()]): + self.assertEqual(interfaces, br.get_interfaces()) + self.assertEqual([], br.get_interfaces()) diff --git a/neutron/tests/unit/plugins/ml2/drivers/linuxbridge/agent/test_linuxbridge_neutron_agent.py b/neutron/tests/unit/plugins/ml2/drivers/linuxbridge/agent/test_linuxbridge_neutron_agent.py index 29c3a1452..dadd346b2 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/linuxbridge/agent/test_linuxbridge_neutron_agent.py +++ b/neutron/tests/unit/plugins/ml2/drivers/linuxbridge/agent/test_linuxbridge_neutron_agent.py @@ -12,7 +12,6 @@ # License for the specific language governing permissions and limitations # under the License. -import os import sys import mock @@ -399,17 +398,6 @@ class TestLinuxBridgeManager(base.BaseTestCase): self.assertEqual(1, log.call_count) exit.assert_called_once_with(1) - def test_interface_exists_on_bridge(self): - with mock.patch.object(os.path, 'exists') as exists_fn: - exists_fn.side_effect = ( - lambda p: p == '/sys/class/net/br-int/brif/abc') - self.assertTrue( - self.lbm.interface_exists_on_bridge("br-int", "abc") - ) - self.assertFalse( - self.lbm.interface_exists_on_bridge("br-int", "abd") - ) - def test_get_existing_bridge_name(self): phy_net = 'physnet0' self.assertEqual('br-eth2', @@ -464,58 +452,34 @@ class TestLinuxBridgeManager(base.BaseTestCase): result = br_list[1:3] result.append('br-eth2') - with mock.patch.object(os, 'listdir') as listdir_fn: - listdir_fn.return_value = br_list - self.assertEqual(self.lbm.get_all_neutron_bridges(), - result) - self.assertTrue(listdir_fn.called) - - def test_get_interfaces_on_bridge(self): - with mock.patch.object(utils, 'execute'),\ - mock.patch.object(os, 'listdir') as listdir_fn,\ - mock.patch.object(ip_lib, 'device_exists', return_value=True): - listdir_fn.return_value = ["qbr1"] - self.assertEqual(self.lbm.get_interfaces_on_bridge("br0"), - ["qbr1"]) - - def test_get_interfaces_on_bridge_not_existing(self): - with mock.patch.object(ip_lib, 'device_exists', return_value=False): - self.assertEqual([], self.lbm.get_interfaces_on_bridge("br0")) + with mock.patch.object( + bridge_lib, 'get_bridge_names', return_value=br_list): + self.assertEqual(result, self.lbm.get_all_neutron_bridges()) def test_get_tap_devices_count(self): - with mock.patch.object(os, 'listdir') as listdir_fn: - listdir_fn.return_value = ['tap2101', 'eth0.100', 'vxlan-1000'] + with mock.patch.object( + bridge_lib.BridgeDevice, 'get_interfaces') as get_ifs_fn: + get_ifs_fn.return_value = ['tap2101', 'eth0.100', 'vxlan-1000'] self.assertEqual(self.lbm.get_tap_devices_count('br0'), 1) - listdir_fn.side_effect = OSError() - self.assertEqual(self.lbm.get_tap_devices_count('br0'), 0) def test_get_bridge_for_tap_device(self): - with mock.patch.object(os, 'readlink') as readlink: - readlink.return_value = ( - 'blah/%s-fake' % linuxbridge_neutron_agent.BRIDGE_NAME_PREFIX) - self.assertEqual(self.lbm.get_bridge_for_tap_device("tap1"), - "brq-fake") + with mock.patch.object( + bridge_lib.BridgeDevice, 'get_interface_bridge') as get_br: + get_br.return_value = bridge_lib.BridgeDevice("brq-fake") + self.assertEqual(get_br.return_value, + self.lbm.get_bridge_for_tap_device("tap1")) - readlink.return_value = 'blah/%s' % BRIDGE_MAPPING_VALUE - self.assertEqual(self.lbm.get_bridge_for_tap_device("tap2"), - BRIDGE_MAPPING_VALUE) + get_br.return_value = bridge_lib.BridgeDevice(BRIDGE_MAPPING_VALUE) + self.assertEqual(get_br.return_value, + self.lbm.get_bridge_for_tap_device("tap2")) - readlink.return_value = 'blah/notneutronbridge' + get_br.return_value = bridge_lib.BridgeDevice('notneutronbridge') self.assertIsNone(self.lbm.get_bridge_for_tap_device("tap3")) - readlink.side_effect = OSError() + get_br.return_value = None self.assertIsNone(self.lbm.get_bridge_for_tap_device("tap4")) - def test_is_device_on_bridge(self): - self.assertTrue(not self.lbm.is_device_on_bridge("")) - with mock.patch.object(os.path, 'exists') as exists_fn: - exists_fn.return_value = True - self.assertTrue(self.lbm.is_device_on_bridge("tap1")) - exists_fn.assert_called_with( - "/sys/class/net/tap1/brport" - ) - def test_get_interface_details(self): with mock.patch.object(ip_lib.IpAddrCommand, 'list') as list_fn,\ mock.patch.object(ip_lib.IpRouteCommand, @@ -688,12 +652,10 @@ class TestLinuxBridgeManager(base.BaseTestCase): with mock.patch.object(self.lbm, '_bridge_exists_and_ensure_up') as de_fn,\ mock.patch.object(bridge_lib, "BridgeDevice", - return_value=bridge_device_old) as br_fn, \ + return_value=bridge_device) as br_fn,\ mock.patch.object(self.lbm, 'update_interface_ip_details') as upd_fn,\ - mock.patch.object(self.lbm, - 'interface_exists_on_bridge') as ie_fn,\ - mock.patch.object(self.lbm, 'is_device_on_bridge'),\ + mock.patch.object(bridge_lib, 'is_bridged_interface'),\ mock.patch.object(self.lbm, 'get_bridge_for_tap_device') as get_if_br_fn: de_fn.return_value = False @@ -702,26 +664,28 @@ class TestLinuxBridgeManager(base.BaseTestCase): bridge_device.disable_stp.return_value = False bridge_device.link.set_up.return_value = False self.assertEqual(self.lbm.ensure_bridge("br0", None), "br0") - ie_fn.return_Value = False + + bridge_device.owns_interface.return_value = False self.lbm.ensure_bridge("br0", "eth0") upd_fn.assert_called_with("br0", "eth0", None, None) - ie_fn.assert_called_with("br0", "eth0") + bridge_device.owns_interface.assert_called_with("eth0") self.lbm.ensure_bridge("br0", "eth0", "ips", "gateway") upd_fn.assert_called_with("br0", "eth0", "ips", "gateway") - ie_fn.assert_called_with("br0", "eth0") + bridge_device.owns_interface.assert_called_with("eth0") de_fn.return_value = True bridge_device.delif.side_effect = Exception() self.lbm.ensure_bridge("br0", "eth0") - ie_fn.assert_called_with("br0", "eth0") + bridge_device.owns_interface.assert_called_with("eth0") de_fn.return_value = True - ie_fn.return_value = False - get_if_br_fn.return_value = "br1" + bridge_device.owns_interface.return_value = False + get_if_br_fn.return_value = bridge_device_old + bridge_device.addif.reset_mock() self.lbm.ensure_bridge("br0", "eth0") bridge_device_old.delif.assert_called_once_with('eth0') - br_fn.return_value.addif.assert_called_once_with('eth0') + bridge_device.addif.assert_called_once_with('eth0') def test_ensure_physical_in_bridge(self): self.assertFalse( @@ -821,8 +785,8 @@ class TestLinuxBridgeManager(base.BaseTestCase): def test_delete_bridge(self): with mock.patch.object(ip_lib.IPDevice, "exists") as de_fn,\ mock.patch.object(ip_lib, "IpLinkCommand") as link_cmd,\ - mock.patch.object(self.lbm, - "get_interfaces_on_bridge") as getif_fn,\ + mock.patch.object(bridge_lib.BridgeDevice, + "get_interfaces") as getif_fn,\ mock.patch.object(self.lbm, "remove_interface"),\ mock.patch.object(self.lbm, "get_interface_details") as if_det_fn,\ @@ -844,8 +808,6 @@ class TestLinuxBridgeManager(base.BaseTestCase): def test_delete_bridge_with_ip(self): bridge_device = mock.Mock() with mock.patch.object(ip_lib, "device_exists") as de_fn,\ - mock.patch.object(self.lbm, - "get_interfaces_on_bridge") as getif_fn,\ mock.patch.object(self.lbm, "remove_interface"),\ mock.patch.object(self.lbm, "get_interface_details") as if_det_fn,\ @@ -855,7 +817,7 @@ class TestLinuxBridgeManager(base.BaseTestCase): mock.patch.object(bridge_lib, "BridgeDevice", return_value=bridge_device): de_fn.return_value = True - getif_fn.return_value = ["eth0", "eth1.1"] + bridge_device.get_interfaces.return_value = ["eth0", "eth1.1"] if_det_fn.return_value = ("ips", "gateway") bridge_device.link.set_down.return_value = False self.lbm.delete_bridge("br0") @@ -865,8 +827,6 @@ class TestLinuxBridgeManager(base.BaseTestCase): def test_delete_bridge_no_ip(self): bridge_device = mock.Mock() with mock.patch.object(ip_lib, "device_exists") as de_fn,\ - mock.patch.object(self.lbm, - "get_interfaces_on_bridge") as getif_fn,\ mock.patch.object(self.lbm, "remove_interface"),\ mock.patch.object(self.lbm, "get_interface_details") as if_det_fn,\ @@ -876,7 +836,7 @@ class TestLinuxBridgeManager(base.BaseTestCase): mock.patch.object(bridge_lib, "BridgeDevice", return_value=bridge_device): de_fn.return_value = True - getif_fn.return_value = ["eth0", "eth1.1"] + bridge_device.get_interfaces.return_value = ["eth0", "eth1.1"] bridge_device.link.set_down.return_value = False if_det_fn.return_value = ([], None) self.lbm.delete_bridge("br0") @@ -897,8 +857,8 @@ class TestLinuxBridgeManager(base.BaseTestCase): with mock.patch.object(ip_lib.IPDevice, "exists") as de_fn,\ mock.patch.object(ip_lib, "IpLinkCommand") as link_cmd,\ - mock.patch.object(lbm, - "get_interfaces_on_bridge") as getif_fn,\ + mock.patch.object(bridge_lib.BridgeDevice, + "get_interfaces") as getif_fn,\ mock.patch.object(lbm, "remove_interface"),\ mock.patch.object(lbm, "delete_interface") as del_interface: de_fn.return_value = False @@ -915,14 +875,13 @@ class TestLinuxBridgeManager(base.BaseTestCase): self.lbm.interface_mappings.update({"physnet2": "eth1.4000"}) bridge_device = mock.Mock() with mock.patch.object(ip_lib, "device_exists") as de_fn,\ - mock.patch.object(self.lbm, "get_interfaces_on_bridge") as getif_fn,\ mock.patch.object(self.lbm, "remove_interface"),\ mock.patch.object(self.lbm, "get_interface_details") as if_det_fn,\ mock.patch.object(self.lbm, "delete_interface") as del_int,\ mock.patch.object(bridge_lib, "BridgeDevice", return_value=bridge_device): de_fn.return_value = True - getif_fn.return_value = ["eth1.1", "eth1.4000"] + bridge_device.get_interfaces.return_value = ["eth1.1", "eth1.4000"] if_det_fn.return_value = ([], None) bridge_device.link.set_down.return_value = False self.lbm.delete_bridge("br0") @@ -960,8 +919,8 @@ class TestLinuxBridgeManager(base.BaseTestCase): def test_remove_interface(self): with mock.patch.object(ip_lib.IPDevice, "exists") as de_fn,\ - mock.patch.object(self.lbm, - "is_device_on_bridge") as isdev_fn,\ + mock.patch.object(bridge_lib, + 'is_bridged_interface') as isdev_fn,\ mock.patch.object(bridge_lib.BridgeDevice, "delif") as delif_fn: de_fn.return_value = False