def test_unplug(self, bridge=None):
if not bridge:
bridge = 'br-int'
with mock.patch('neutron.agent.linux.ovs_lib.OVSBridge') as ovs_br:
ovs = interface.OVSInterfaceDriver(self.conf)
ovs.unplug('tap0')
ovs_br.assert_has_calls([mock.call(bridge, 'sudo'),
mock.call().delete_port('tap0')])
def _test_plug(self, bridge=None, namespace=None):
with mock.patch('neutron.agent.ovsdb.impl_idl._connection'):
if not bridge:
bridge = 'br-int'
def device_exists(dev, namespace=None):
return dev == bridge
with mock.patch.object(ovs_lib.OVSBridge,
'replace_port') as replace:
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
link = self.ip.return_value.device.return_value.link
link.set_address.side_effect = (RuntimeError, None)
namespace_obj = (
self.ip.return_value.ensure_namespace.return_value)
self.ip.ensure_namespace.return_value = namespace_obj
namespace_obj.add_device_to_namespace.side_effect = (
ip_lib.NetworkInterfaceNotFound, utils.WaitTimeout, None)
ovs.plug('01234567-1234-1234-99',
'port-1234',
'tap0',
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace,
mtu=9000)
replace.assert_called_once_with(
'tap0', ('type', 'internal'),
('external_ids', {
'iface-id': 'port-1234',
'iface-status': 'active',
'attached-mac': 'aa:bb:cc:dd:ee:ff'
}))
expected = [
mock.call(),
mock.call().device('tap0'),
mock.call().device().link.set_address('aa:bb:cc:dd:ee:ff'),
mock.call().device().link.set_address('aa:bb:cc:dd:ee:ff')
]
if namespace:
expected.extend([
mock.call().ensure_namespace(namespace),
mock.call().ensure_namespace().add_device_to_namespace(
mock.ANY),
mock.call().ensure_namespace().add_device_to_namespace(
mock.ANY),
mock.call().ensure_namespace().add_device_to_namespace(
mock.ANY)
])
expected.extend([
mock.call(namespace=namespace),
mock.call().device('tap0'),
mock.call().device().link.set_mtu(9000),
mock.call().device().link.set_up(),
])
self.ip.assert_has_calls(expected)
def _test_plug(self,
devname=None,
bridge=None,
namespace=None,
prefix=None):
with mock.patch('neutron.agent.ovsdb.impl_idl._connection'):
if not devname:
devname = 'ns-0'
if not bridge:
bridge = 'br-int'
def device_exists(dev, namespace=None):
return dev == bridge
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
root_dev = mock.Mock()
ns_dev = mock.Mock()
self.ip().add_veth = mock.Mock(return_value=(root_dev, ns_dev))
mock.patch.object(interface,
'_get_veth',
return_value=(root_dev, ns_dev)).start()
ns_dev.name = devname
expected = [
mock.call(),
mock.call().add_veth('tap0', devname, namespace2=namespace)
]
with mock.patch.object(ovs_lib.OVSBridge,
'replace_port') as replace:
ovs.plug('01234567-1234-1234-99',
'port-1234',
devname,
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace,
prefix=prefix,
mtu=9000)
replace.assert_called_once_with(
'tap0', ('external_ids', {
'iface-id': 'port-1234',
'iface-status': 'active',
'attached-mac': 'aa:bb:cc:dd:ee:ff'
}))
ns_dev.assert_has_calls(
[mock.call.link.set_address('aa:bb:cc:dd:ee:ff')])
ns_dev.assert_has_calls([mock.call.link.set_mtu(9000)])
root_dev.assert_has_calls([mock.call.link.set_mtu(9000)])
self.ip.assert_has_calls(expected)
root_dev.assert_has_calls([mock.call.link.set_up()])
ns_dev.assert_has_calls([mock.call.link.set_up()])
self.eth_offload.assert_has_calls(
[mock.call(devname, rx=False, tx=False, namespace=namespace)])
def test_unplug(self):
bridge = 'br-int'
with mock.patch('neutron.agent.common.ovs_lib.OVSBridge') as ovs_br:
ovs = interface.OVSInterfaceDriver(self.conf)
ovs.unplug('ns-0', bridge=bridge)
ovs_br.assert_has_calls([mock.call(bridge),
mock.call().delete_port('tap0')])
self.ip_dev.assert_has_calls([mock.call('ns-0', namespace=None),
mock.call().link.delete()])
def _test_plug(self,
devname=None,
bridge=None,
namespace=None,
prefix=None,
mtu=None):
if not devname:
devname = 'ns-0'
if not bridge:
bridge = 'br-int'
def device_exists(dev, root_helper=None, namespace=None):
return dev == bridge
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
root_dev = mock.Mock()
ns_dev = mock.Mock()
self.ip().add_veth = mock.Mock(return_value=(root_dev, ns_dev))
expected = [
mock.call('sudo'),
mock.call().add_veth('tap0', devname, namespace2=namespace)
]
vsctl_cmd = [
'ovs-vsctl', '--', '--if-exists', 'del-port', 'tap0', '--',
'add-port', bridge, 'tap0', '--', 'set', 'Interface', 'tap0',
'external-ids:iface-id=port-1234', '--', 'set', 'Interface',
'tap0', 'external-ids:iface-status=active', '--', 'set',
'Interface', 'tap0', 'external-ids:attached-mac=aa:bb:cc:dd:ee:ff'
]
with mock.patch.object(utils, 'execute') as execute:
ovs.plug('01234567-1234-1234-99',
'port-1234',
devname,
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace,
prefix=prefix)
execute.assert_called_once_with(vsctl_cmd, 'sudo')
ns_dev.assert_has_calls(
[mock.call.link.set_address('aa:bb:cc:dd:ee:ff')])
if mtu:
ns_dev.assert_has_calls([mock.call.link.set_mtu(mtu)])
root_dev.assert_has_calls([mock.call.link.set_mtu(mtu)])
self.ip.assert_has_calls(expected)
root_dev.assert_has_calls([mock.call.link.set_up()])
ns_dev.assert_has_calls([mock.call.link.set_up()])
def __init__(self):
self.agent_api = None
self.ovs_api = None
self.bmv2_api = Bmv2Api()
bind_opts = [
cfg.StrOpt('ovs_use_veth',
default=True,
help=""),
]
interface_config = cfg.ConfigOpts()
interface_config.register_opts(bind_opts)
LOG.info("Loading cfg " + str(interface_config))
self.ovs_interface = interface.OVSInterfaceDriver(interface_config)
self.bridge_interface = interface.BridgeInterfaceDriver(interface_config)
def plug_port(self, port_name):
# TODO(jlibosva): Don't use interface driver for fullstack fake
# machines as the port should be treated by OVS agent and not by
# external party
interface_config = cfg.ConfigOpts()
interface_config.register_opts(interface.OPTS)
ovs_interface = interface.OVSInterfaceDriver(interface_config)
ovs_interface.plug_new(None,
self.port_id,
port_name,
self.mac,
bridge=self.bridge.br_name,
namespace=self.namespace)
self.addCleanup(self.bridge.delete_port, port_name)
self.port = ip_lib.IPDevice(port_name, self.namespace)
def _setUp(self):
super(OVSPortFixture, self)._setUp()
interface_config = cfg.ConfigOpts()
interface_config.register_opts(interface.OPTS)
ovs_interface = interface.OVSInterfaceDriver(interface_config)
port_name = tests_base.get_rand_device_name(PORT_PREFIX)
ovs_interface.plug_new(None,
self.port_id,
port_name,
self.mac,
bridge=self.bridge.br_name,
namespace=self.namespace)
self.addCleanup(self.bridge.delete_port, port_name)
self.port = ip_lib.IPDevice(port_name, self.namespace)
def setUp(self):
super(OVSAgentTestFramework, self).setUp()
agent_rpc = ('neutron.plugins.ml2.drivers.openvswitch.agent.'
'ovs_neutron_agent.OVSPluginApi')
mock.patch(agent_rpc).start()
mock.patch('neutron.agent.rpc.PluginReportStateAPI').start()
self.br_int = base.get_rand_name(n_const.DEVICE_NAME_MAX_LEN,
prefix='br-int')
self.br_tun = base.get_rand_name(n_const.DEVICE_NAME_MAX_LEN,
prefix='br-tun')
patch_name_len = n_const.DEVICE_NAME_MAX_LEN - len("-patch-tun")
self.patch_tun = "%s-patch-tun" % self.br_int[patch_name_len:]
self.patch_int = "%s-patch-int" % self.br_tun[patch_name_len:]
self.ovs = ovs_lib.BaseOVS()
self.config = self._configure_agent()
self.driver = interface.OVSInterfaceDriver(self.config)
def _test_plug(self,
additional_expectation=[],
bridge=None,
namespace=None):
if not bridge:
bridge = 'br-int'
def device_exists(dev, root_helper=None, namespace=None):
return dev == bridge
vsctl_cmd = [
'ovs-vsctl', '--', '--if-exists', 'del-port', 'tap0', '--',
'add-port', bridge, 'tap0', '--', 'set', 'Interface', 'tap0',
'type=internal', '--', 'set', 'Interface', 'tap0',
'external-ids:iface-id=port-1234', '--', 'set', 'Interface',
'tap0', 'external-ids:iface-status=active', '--', 'set',
'Interface', 'tap0', 'external-ids:attached-mac=aa:bb:cc:dd:ee:ff'
]
with mock.patch.object(utils, 'execute') as execute:
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
ovs.plug('01234567-1234-1234-99',
'port-1234',
'tap0',
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace)
execute.assert_called_once_with(vsctl_cmd, 'sudo')
expected = [
mock.call('sudo'),
mock.call().device('tap0'),
mock.call().device().link.set_address('aa:bb:cc:dd:ee:ff')
]
expected.extend(additional_expectation)
if namespace:
expected.extend([
mock.call().ensure_namespace(namespace),
mock.call().ensure_namespace().add_device_to_namespace(
mock.ANY)
])
expected.extend([mock.call().device().link.set_up()])
self.ip.assert_has_calls(expected)
def _test_plug(self, bridge=None, namespace=None):
with mock.patch('neutron.agent.ovsdb.native.connection.'
'Connection.start'):
if not bridge:
bridge = 'br-int'
def device_exists(dev, namespace=None):
return dev == bridge
with mock.patch.object(ovs_lib.OVSBridge,
'replace_port') as replace:
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
ovs.plug('01234567-1234-1234-99',
'port-1234',
'tap0',
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace,
mtu=9000)
replace.assert_called_once_with(
'tap0', ('type', 'internal'),
('external_ids', {
'iface-id': 'port-1234',
'iface-status': 'active',
'attached-mac': 'aa:bb:cc:dd:ee:ff'
}))
expected = [
mock.call(),
mock.call().device('tap0'),
mock.call().device().link.set_address('aa:bb:cc:dd:ee:ff')
]
if namespace:
expected.extend([
mock.call().ensure_namespace(namespace),
mock.call().ensure_namespace().add_device_to_namespace(
mock.ANY)
])
expected.extend([
mock.call().device().link.set_mtu(9000),
mock.call().device().link.set_up(),
])
self.ip.assert_has_calls(expected)
def _test_plug(self, devname=None, bridge=None, namespace=None,
prefix=None, mtu=None):
if not devname:
devname = 'ns-0'
if not bridge:
bridge = 'br-int'
def device_exists(dev, root_helper=None, namespace=None):
return dev == bridge
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
root_dev = mock.Mock()
ns_dev = mock.Mock()
self.ip().add_veth = mock.Mock(return_value=(root_dev, ns_dev))
expected = [mock.call('sudo'),
mock.call().add_veth('tap0', devname,
namespace2=namespace)]
with mock.patch.object(ovs_lib.OVSBridge, 'replace_port') as replace:
ovs.plug('01234567-1234-1234-99',
'port-1234',
devname,
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace,
prefix=prefix)
replace.assert_called_once_with(
'tap0',
('external_ids', {
'iface-id': 'port-1234',
'iface-status': 'active',
'attached-mac': 'aa:bb:cc:dd:ee:ff'}))
ns_dev.assert_has_calls(
[mock.call.link.set_address('aa:bb:cc:dd:ee:ff')])
if mtu:
ns_dev.assert_has_calls([mock.call.link.set_mtu(mtu)])
root_dev.assert_has_calls([mock.call.link.set_mtu(mtu)])
self.ip.assert_has_calls(expected)
root_dev.assert_has_calls([mock.call.link.set_up()])
ns_dev.assert_has_calls([mock.call.link.set_up()])
def plug_port(self, port_name):
# TODO(jlibosva): Don't use interface driver for fullstack fake
# machines as the port should be treated by OVS agent and not by
# external party
interface_config = cfg.ConfigOpts()
config.register_interface_opts(interface_config)
ovs_interface = interface.OVSInterfaceDriver(interface_config)
ovs_interface.plug_new(None,
self.port_id,
port_name,
self.mac,
bridge=self.bridge.br_name,
namespace=self.namespace)
# NOTE(mangelajo): for OVS implementations remove the DEAD VLAN tag
# on ports that we intend to use as fake vm interfaces, they
# need to be flat. This is related to lp#1767422
self.bridge.clear_db_attribute("Port", port_name, "tag")
self.addCleanup(self.bridge.delete_port, port_name)
self.port = ip_lib.IPDevice(port_name, self.namespace)
def _setUp(self):
super(OVSPortFixture, self)._setUp()
interface_config = cfg.ConfigOpts()
interface_config.register_opts(interface.OPTS)
ovs_interface = interface.OVSInterfaceDriver(interface_config)
# because in some tests this port can be used to providing connection
# between linuxbridge agents and vlan_id can be also added to this
# device name it has to be max LB_DEVICE_NAME_MAX_LEN long
port_name = tests_base.get_rand_name(LB_DEVICE_NAME_MAX_LEN,
PORT_PREFIX)
ovs_interface.plug_new(None,
self.port_id,
port_name,
self.mac,
bridge=self.bridge.br_name,
namespace=self.namespace)
self.addCleanup(self.bridge.delete_port, port_name)
self.port = ip_lib.IPDevice(port_name, self.namespace)
def _test_plug(self, additional_expectation=[], bridge=None,
namespace=None):
if not bridge:
bridge = 'br-int'
def device_exists(dev, root_helper=None, namespace=None):
return dev == bridge
with mock.patch.object(ovs_lib.OVSBridge, 'replace_port') as replace:
ovs = interface.OVSInterfaceDriver(self.conf)
self.device_exists.side_effect = device_exists
ovs.plug('01234567-1234-1234-99',
'port-1234',
'tap0',
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace)
replace.assert_called_once_with(
'tap0',
('type', 'internal'),
('external-ids:iface-id', 'port-1234'),
('external-ids:iface-status', 'active'),
('external-ids:attached-mac', 'aa:bb:cc:dd:ee:ff'))
expected = [mock.call('sudo'),
mock.call().device('tap0'),
mock.call().device().link.set_address('aa:bb:cc:dd:ee:ff')]
expected.extend(additional_expectation)
if namespace:
expected.extend(
[mock.call().ensure_namespace(namespace),
mock.call().ensure_namespace().add_device_to_namespace(
mock.ANY)])
expected.extend([mock.call().device().link.set_up()])
self.ip.assert_has_calls(expected)
def test_plug_configured_bridge(self):
br = 'br-v'
self.conf.set_override('ovs_use_veth', False)
self.conf.set_override('ovs_integration_bridge', br)
self.assertEqual(self.conf.ovs_integration_bridge, br)
def device_exists(dev, namespace=None):
return dev == br
ovs = interface.OVSInterfaceDriver(self.conf)
with mock.patch.object(ovs, '_ovs_add_port') as add_port:
self.device_exists.side_effect = device_exists
ovs.plug('01234567-1234-1234-99',
'port-1234',
'tap0',
'aa:bb:cc:dd:ee:ff',
bridge=None,
namespace=None)
add_port.assert_called_once_with('br-v',
'tap0',
'port-1234',
'aa:bb:cc:dd:ee:ff',
internal=True)
def test_plug_new(self):
with mock.patch('neutron.agent.ovsdb.impl_idl._connection'):
bridge = 'br-int'
namespace = '01234567-1234-1234-99'
with mock.patch.object(ovs_lib.OVSBridge,
'delete_port') as delete_port:
with mock.patch.object(ovs_lib.OVSBridge, 'replace_port'):
ovs = interface.OVSInterfaceDriver(self.conf)
reraise = mock.patch.object(excutils,
'save_and_reraise_exception')
reraise.start()
proEr = exceptions.ProcessExecutionError('', 2)
processExecutionError = mock.Mock(side_effect=proEr)
ip = self.ip.return_value
ip.ensure_namespace.side_effect = processExecutionError
ovs.plug_new('01234567-1234-1234-99',
'port-1234',
'tap0',
'aa:bb:cc:dd:ee:ff',
bridge=bridge,
namespace=namespace,
prefix='veth',
mtu=9000)
delete_port.assert_called_once_with('tap0')
def setUp(self):
super(OVSInterfaceDriverTestCase, self).setUp()
conf = cfg.ConfigOpts()
conf.register_opts(interface.OPTS)
self.interface = interface.OVSInterfaceDriver(conf)
def test_unplug(self):
with mock.patch('neutron.agent.common.ovs_lib.OVSBridge') as ovs_br:
ovs = interface.OVSInterfaceDriver(self.conf)
ovs.unplug('tap0')
ovs_br.assert_has_calls([mock.call('br-int'),
mock.call().delete_port('tap0')])
def __init__(self, conf, driver_type):
self.conf = conf
self.driver_type = driver_type
self.process = None
self.interface_driver = interface.OVSInterfaceDriver(self.conf)
def setUp(self):
super(OVSInterfaceDriverTestCase, self).setUp()
conf = cfg.ConfigOpts()
conf.register_opts(interface.OPTS)
self.interface = interface.OVSInterfaceDriver(conf)
self.bridge = self.useFixture(net_helpers.OVSBridgeFixture()).bridge
user = sys.argv[2]
pw = sys.argv[3]
tenant = sys.argv[4]
interface = sys.argv[5]
mac_addr = sys.argv[6]
vm_uuid = sys.argv[7]
port_id = sys.argv[10]
nw_id = sys.argv[12]
br_name = 'br-ex'
conf = cfg.CONF
config.register_root_helper(conf)
conf.register_opts(vif_driver.OPTS)
driver = vif_driver.OVSInterfaceDriver(cfg.CONF)
print "Unplug %s for %s" % (interface, br_name)
driver.unplug(interface, br_name)
KEYSTONE_URL = 'http://' + host + ':5000/v2.0'
qc = qclient.Client('2.0',
auth_url=KEYSTONE_URL,
username=user,
tenant_name=tenant,
password=pw)
try:
qc.delete_port(port_id)
print "Deleted port %s from Neutron" % port_id
except qcexp.NeutronClientException as qce:
def test_get_device_name(self):
br = interface.OVSInterfaceDriver(self.conf)
device_name = br.get_device_name(FakePort())
self.assertEqual('ns-abcdef01-12', device_name)
def getInterfaceDriver(*args, **kwargs):
return interface.OVSInterfaceDriver(*args, **kwargs)