def create_network_namespace(namespace, **kwargs):
"""Create a network namespace.
:param namespace: The name of the namespace to create
:param kwargs: Callers add any filters they use as kwargs
"""
privileged.create_netns(namespace, **kwargs)
def setUp(self):
super(TcQdiscTestCase, self).setUp()
self.namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._remove_ns, self.namespace)
self.device = 'int_dummy'
priv_ip_lib.create_interface(self.device, self.namespace, 'dummy')
def test_get_ip_addresses(self):
namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(namespace)
self.addCleanup(self._remove_ns, namespace)
interfaces = {
'20': {
'cidr': '192.168.10.20/24',
'scope': 'link',
'add_broadcast': True
},
'30': {
'cidr': '2001::1/64',
'scope': 'global',
'add_broadcast': False
}
}
for int_name, int_parameters in interfaces.items():
priv_ip_lib.create_interface(int_name,
namespace,
'dummy',
index=int(int_name))
ip_lib.add_ip_address(int_parameters['cidr'], int_name, namespace,
int_parameters['scope'],
int_parameters['add_broadcast'])
ip_addresses = priv_ip_lib.get_ip_addresses(namespace)
for ip_address in ip_addresses:
int_name = str(ip_address['index'])
ip = ip_lib.get_attr(ip_address, 'IFA_ADDRESS')
mask = ip_address['prefixlen']
cidr = common_utils.ip_to_cidr(ip, mask)
self.assertEqual(interfaces[int_name]['cidr'], cidr)
self.assertEqual(interfaces[int_name]['scope'],
ip_lib.IP_ADDRESS_SCOPE[ip_address['scope']])
def create_network_namespace(namespace, **kwargs):
"""Create a network namespace.
:param namespace: The name of the namespace to create
:param kwargs: Callers add any filters they use as kwargs
"""
privileged.create_netns(namespace, **kwargs)
def test_get_ip_addresses(self):
namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(namespace)
self.addCleanup(self._remove_ns, namespace)
interfaces = {
'20': {'cidr': '192.168.10.20/24', 'scope': 'link',
'add_broadcast': True},
'30': {'cidr': '2001::1/64', 'scope': 'global',
'add_broadcast': False}}
for int_name, int_parameters in interfaces.items():
priv_ip_lib.create_interface(int_name, namespace, 'dummy',
index=int(int_name))
ip_lib.add_ip_address(
int_parameters['cidr'], int_name, namespace,
int_parameters['scope'], int_parameters['add_broadcast'])
ip_addresses = priv_ip_lib.get_ip_addresses(namespace)
for ip_address in ip_addresses:
int_name = str(ip_address['index'])
ip = _get_attr(ip_address, 'IFA_ADDRESS')
mask = ip_address['prefixlen']
cidr = common_utils.ip_to_cidr(ip, mask)
self.assertEqual(interfaces[int_name]['cidr'], cidr)
self.assertEqual(interfaces[int_name]['scope'],
ip_lib.IP_ADDRESS_SCOPE[ip_address['scope']])
def setUp(self):
super(TcFilterClassTestCase, self).setUp()
self.namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._remove_ns, self.namespace)
self.device = 'int_dummy'
priv_ip_lib.create_interface('int_dummy', self.namespace, 'dummy')
def setUp(self):
super(GetDevicesInfoTestCase, self).setUp()
self.namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._remove_ns, self.namespace)
self.interfaces = ['int_01', 'int_02']
self.interfaces_to_exclude = (ip_lib.FB_TUNNEL_DEVICE_NAMES +
[ip_lib.LOOPBACK_DEVNAME])
def setUp(self):
super(IpMonitorTestCase, self).setUp()
self.addCleanup(self._cleanup)
if self.namespace:
priv_ip_lib.create_netns(self.namespace)
self.devices = [('int_' + uuidutils.generate_uuid())[
:constants.DEVICE_NAME_MAX_LEN] for _ in range(5)]
self.ip_wrapper = ip_lib.IPWrapper(self.namespace)
self.temp_file = self.get_temp_file_path('out_' + self.devices[0] +
'.tmp')
self.proc = self._run_ip_monitor(ip_monitor)
def _create_two_namespaces_connected_using_vxlan(self):
"""Create two namespaces connected with a veth pair and VXLAN
--------------------------------- ----------------------------------
(ns1) | | (ns2)
int1: 10.0.100.1/24 <-----------|----|------------> int2: 10.0.100.2/24
| | | |
|> int1_vxlan1: 10.0.200.1/24 | | int1_vxlan2: 10.0.200.2/24 <|
--------------------------------- ----------------------------------
"""
self.vxlan_id = 100
self.ns = [
'ns1_' + uuidutils.generate_uuid(),
'ns2_' + uuidutils.generate_uuid()
]
self.device = ['int1', 'int2']
self.device_vxlan = ['int_vxlan1', 'int_vxlan2']
self.mac_vxlan = []
self.ip = ['10.100.0.1/24', '10.100.0.2/24']
self.ip_vxlan = ['10.200.0.1/24', '10.200.0.2/24']
for i, ns in enumerate(self.ns):
priv_ip_lib.create_netns(ns)
self.addCleanup(self._remove_ns, ns)
ip_wrapper = ip_lib.IPWrapper(ns)
if i == 0:
ip_wrapper.add_veth(self.device[0], self.device[1], self.ns[1])
ip_wrapper.add_vxlan(self.device_vxlan[i],
self.vxlan_id,
dev=self.device[i])
ip_device = ip_lib.IPDevice(self.device[i], ns)
ip_device.link.set_up()
ip_device.addr.add(self.ip[i])
ip_device_vxlan = ip_lib.IPDevice(self.device_vxlan[i], ns)
self.mac_vxlan.append(ip_device_vxlan.link.address)
ip_device_vxlan.link.set_up()
ip_device_vxlan.addr.add(self.ip_vxlan[i])
bridge_lib.FdbInterface.append('00:00:00:00:00:00',
self.device_vxlan[0],
namespace=self.ns[0],
dst_ip=str(
netaddr.IPNetwork(self.ip[1]).ip))
bridge_lib.FdbInterface.append('00:00:00:00:00:00',
self.device_vxlan[1],
namespace=self.ns[1],
dst_ip=str(
netaddr.IPNetwork(self.ip[0]).ip))
def setUp(self):
super(FdbInterfaceTestCase, self).setUp()
self.device = 'interface'
self.device_vxlan = 'int_vxlan'
self.ip = '10.220.0.1/24'
self.ip_vxlan = '10.221.0.1/24'
if self.namespace:
priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._cleanup)
ip_wrapper = ip_lib.IPWrapper(self.namespace)
ip_wrapper.add_dummy(self.device)
ip_wrapper.add_vxlan(self.device_vxlan, 100, dev=self.device)
ip_device = ip_lib.IPDevice(self.device, self.namespace)
ip_device.link.set_up()
ip_device.addr.add(self.ip)
ip_device_vxlan = ip_lib.IPDevice(self.device_vxlan, self.namespace)
ip_device_vxlan.link.set_up()
ip_device_vxlan.addr.add(self.ip_vxlan)
def setUp(self):
super(FdbInterfaceTestCase, self).setUp()
self.device = 'interface'
self.device_vxlan = 'int_vxlan'
self.ip = '10.220.0.1/24'
self.ip_vxlan = '10.221.0.1/24'
if self.namespace:
priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._cleanup)
ip_wrapper = ip_lib.IPWrapper(self.namespace)
ip_wrapper.add_dummy(self.device)
ip_wrapper.add_vxlan(self.device_vxlan, 100, dev=self.device)
ip_device = ip_lib.IPDevice(self.device, self.namespace)
ip_device.link.set_up()
ip_device.addr.add(self.ip)
ip_device_vxlan = ip_lib.IPDevice(self.device_vxlan, self.namespace)
ip_device_vxlan.link.set_up()
ip_device_vxlan.addr.add(self.ip_vxlan)
def test_get_devices(self):
namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(namespace)
self.addCleanup(self._remove_ns, namespace)
interfaces = ['int_01', 'int_02', 'int_03', 'int_04', 'int_05']
interfaces_to_check = (interfaces + ip_lib.FB_TUNNEL_DEVICE_NAMES +
[ip_lib.LOOPBACK_DEVNAME])
for interface in interfaces:
priv_ip_lib.create_interface(interface, namespace, 'dummy')
device_names = priv_ip_lib.get_devices(namespace)
for name in device_names:
self.assertIn(name, interfaces_to_check)
for interface in interfaces:
priv_ip_lib.delete_interface(interface, namespace)
device_names = priv_ip_lib.get_devices(namespace)
for name in device_names:
self.assertNotIn(name, interfaces)
def test_get_devices_info_veth_different_namespaces(self):
namespace2 = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(namespace2)
self.addCleanup(self._remove_ns, namespace2)
ip_wrapper = ip_lib.IPWrapper(self.namespace)
ip_wrapper.add_veth('veth1_1', 'veth1_2', namespace2)
devices = priv_ip_lib.get_link_devices(self.namespace)
for device in devices:
name = ip_lib.get_attr(device, 'IFLA_IFNAME')
if name == 'veth1_1':
veth1_1 = device
break
else:
self.fail('Interface "veth1_1" not found')
ifla_linkinfo = ip_lib.get_attr(veth1_1, 'IFLA_LINKINFO')
self.assertEqual(ip_lib.get_attr(ifla_linkinfo, 'IFLA_INFO_KIND'),
'veth')
self.assertIsNone(ip_lib.get_attr(veth1_1, 'IFLA_LINK'))
def setUp(self):
super(FdbInterfaceTestCase, self).setUp()
self.device = (
'int_' + uuidutils.generate_uuid())[:constants.DEVICE_NAME_MAX_LEN]
self.device_vxlan = (
'vxlan_' +
uuidutils.generate_uuid())[:constants.DEVICE_NAME_MAX_LEN]
self.ip = '10.220.0.1/24'
self.ip_vxlan = '10.221.0.1/24'
if self.namespace:
priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._cleanup)
ip_wrapper = ip_lib.IPWrapper(self.namespace)
ip_wrapper.add_dummy(self.device)
ip_wrapper.add_vxlan(self.device_vxlan, 100, dev=self.device)
ip_device = ip_lib.IPDevice(self.device, self.namespace)
ip_device.link.set_up()
ip_device.addr.add(self.ip)
ip_device_vxlan = ip_lib.IPDevice(self.device_vxlan, self.namespace)
ip_device_vxlan.link.set_up()
ip_device_vxlan.addr.add(self.ip_vxlan)
def test_get_device_names(self):
namespace = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(namespace)
self.addCleanup(self._remove_ns, namespace)
interfaces = ['int_01', 'int_02', 'int_03', 'int_04', 'int_05']
interfaces_to_check = (interfaces + ip_lib.FB_TUNNEL_DEVICE_NAMES +
[ip_lib.LOOPBACK_DEVNAME])
for interface in interfaces:
priv_ip_lib.create_interface(interface, namespace, 'dummy')
device_names = priv_ip_lib.get_device_names(namespace)
self.assertGreater(len(device_names), 0)
for name in device_names:
self.assertIn(name, interfaces_to_check)
for interface in interfaces:
priv_ip_lib.delete_interface(interface, namespace)
device_names = priv_ip_lib.get_device_names(namespace)
self.assertGreater(len(device_names), 0)
for name in device_names:
self.assertNotIn(name, interfaces)
def test_get_devices_info_veth_different_namespaces(self):
namespace2 = 'ns_test-' + uuidutils.generate_uuid()
priv_ip_lib.create_netns(namespace2)
self.addCleanup(self._remove_ns, namespace2)
# Create a random number of dummy interfaces in namespace2, in order
# to increase the 'veth1_2' interface index in its namespace.
for idx in range(5, random.randint(15, 20)):
priv_ip_lib.create_interface('int_%s' % idx, namespace2, 'dummy')
ip_wrapper = ip_lib.IPWrapper(self.namespace)
ip_wrapper.add_veth('veth1_1', 'veth1_2', namespace2)
veth1_1 = self._retrieve_interface('veth1_1', self.namespace)
veth1_2 = self._retrieve_interface('veth1_2', namespace2)
ifla_linkinfo = ip_lib.get_attr(veth1_1, 'IFLA_LINKINFO')
self.assertEqual(ip_lib.get_attr(ifla_linkinfo, 'IFLA_INFO_KIND'),
'veth')
# NOTE(ralonsoh): since kernel_version=4.15.0-60-generic, iproute2
# provides the veth pair index, even if the pair interface is in other
# namespace. In previous versions, the parameter 'IFLA_LINK' was not
# present. We need to handle both cases.
self.assertIn(ip_lib.get_attr(veth1_1, 'IFLA_LINK'),
[None, veth1_2['index']])
def setUp(self):
super(RuleTestCase, self).setUp()
self.namespace = 'ns_test-' + uuidutils.generate_uuid()
self.ns = priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._remove_ns)
def setUp(self):
super(ListIpRulesTestCase, self).setUp()
self.namespace = 'ns_test-' + uuidutils.generate_uuid()
self.ns = priv_ip_lib.create_netns(self.namespace)
self.addCleanup(self._remove_ns)
