def test_dhcp_stateless_router(self):
"""With all options below the router interface shall
receive first address in allocation pool of subnet,
because gateway is set explicitly to first IP in
'create_subnet' function.
"""
for ra_mode, add_mode in (
('dhcpv6-stateless', 'dhcpv6-stateless'),
('dhcpv6-stateless', None),
(None, 'dhcpv6-stateless'),
('slaac', 'slaac'),
('slaac', None),
(None, 'slaac')
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
kwargs = {k: v for k, v in kwargs.iteritems() if v}
subnet, port = self._create_subnet_router(kwargs)
port_ip = next(iter(port['fixed_ips']), None)['ip_address']
self._clean_network()
eui64_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet['cidr'],
port['mac_address']).format()
self.assertNotEqual(port_ip, eui64_ip,
("Port IP %s is the same as EUI64 "
"addressl: %s") % (port_ip, eui64_ip))
self.assertEqual(port_ip, subnet['gateway_ip'],
("Port IP %s is not as first IP from "
"subnets allocation pool: %s") % (
port_ip, subnet['gateway_ip']))
def test_dhcp_stateless_router_wogw(self):
"""With all options below the router interface shall
receive DHCPv6 IP SLAAC address according to its MAC,
because gateway is not set explicitly in local function
'_create_custom_subnet' and default is used.
"""
for ra_mode, add_mode in (
('dhcpv6-stateless', 'dhcpv6-stateless'),
# ('dhcpv6-stateless', None),
(None, 'dhcpv6-stateless'),
('slaac', 'slaac'),
# ('slaac', None),
(None, 'slaac')
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode,
'ip_version': 6}
kwargs = {k: v for k, v in kwargs.iteritems() if v}
subnet = self._create_custom_subnet(kwargs)
router = self.create_router(
router_name=data_utils.rand_name("routerv6-"),
admin_state_up=True)
port = self.create_router_interface(router['id'],
subnet['id'])
body = self.client.show_port(port['port_id'])
port = body['port']
port_ip = next(iter(port['fixed_ips']))['ip_address']
eui64_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet['cidr'],
port['mac_address']).format()
self._clean_network()
self.assertEqual(port_ip, eui64_ip,
("Port IP %s is not SLAAC %s") % (
port_ip, eui64_ip))
def test_dhcpv6_stateless_two_subnets(self):
"""When 2 subnets configured with dnsmasq SLAAC and DHCP stateless
and there is radvd, port shall receive IP addresses calculated
from its MAC and mask of subnet from both subnets.
"""
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
subnet1 = self.create_subnet(self.network, **kwargs)
subnet2 = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
port = self.create_port(self.network, mac_address=port_mac)
real_ips = [i['ip_address'] for i in port['fixed_ips']]
eui_ips = [
data_utils.get_ipv6_addr_by_EUI64(i['cidr'],
port_mac).format()
for i in (subnet1, subnet2)
]
self._clean_network()
self.assertSequenceEqual(sorted(real_ips), sorted(eui_ips),
('Real port IPs %s,%s are not equal to'
' SLAAC IPs: %s,%s') % tuple(real_ips +
eui_ips))
def test_dhcp_stateless_router_wogw(self):
"""With all options below the router interface shall
receive DHCPv6 IP SLAAC address according to its MAC,
because gateway is not set explicitly in local function
'_create_custom_subnet' and default is used.
"""
for ra_mode, add_mode in (
('dhcpv6-stateless', 'dhcpv6-stateless'),
# ('dhcpv6-stateless', None),
(None, 'dhcpv6-stateless'),
('slaac', 'slaac'),
# ('slaac', None),
(None, 'slaac')):
kwargs = {
'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode,
'ip_version': 6
}
kwargs = {k: v for k, v in kwargs.iteritems() if v}
subnet = self._create_custom_subnet(kwargs)
router = self.create_router(
router_name=data_utils.rand_name("routerv6-"),
admin_state_up=True)
port = self.create_router_interface(router['id'], subnet['id'])
body = self.client.show_port(port['port_id'])
port = body['port']
port_ip = next(iter(port['fixed_ips']))['ip_address']
eui64_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet['cidr'], port['mac_address']).format()
self._clean_network()
self.assertEqual(port_ip, eui64_ip,
("Port IP %s is not SLAAC %s") %
(port_ip, eui64_ip))
def test_dhcp_stateless_router(self):
"""With all options below the router interface shall
receive first address in allocation pool of subnet,
because gateway is set explicitly to first IP in
'create_subnet' function.
"""
for ra_mode, add_mode in (('dhcpv6-stateless', 'dhcpv6-stateless'),
('dhcpv6-stateless',
None), (None, 'dhcpv6-stateless'),
('slaac', 'slaac'), ('slaac',
None), (None, 'slaac')):
kwargs = {'ipv6_ra_mode': ra_mode, 'ipv6_address_mode': add_mode}
kwargs = {k: v for k, v in kwargs.iteritems() if v}
subnet, port = self._create_subnet_router(kwargs)
port_ip = next(iter(port['fixed_ips']), None)['ip_address']
self._clean_network()
eui64_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet['cidr'], port['mac_address']).format()
self.assertNotEqual(port_ip, eui64_ip,
("Port IP %s is the same as EUI64 "
"addressl: %s") % (port_ip, eui64_ip))
self.assertEqual(port_ip, subnet['gateway_ip'],
("Port IP %s is not as first IP from "
"subnets allocation pool: %s") %
(port_ip, subnet['gateway_ip']))
def test_dhcpv6_stateless_two_subnets(self):
"""When 2 subnets configured with dnsmasq SLAAC and DHCP stateless
and there is radvd, port shall receive IP addresses calculated
from its MAC and mask of subnet from both subnets.
"""
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode, 'ipv6_address_mode': add_mode}
subnet1 = self.create_subnet(self.network, **kwargs)
subnet2 = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
port = self.create_port(self.network, mac_address=port_mac)
real_ips = [i['ip_address'] for i in port['fixed_ips']]
eui_ips = [
data_utils.get_ipv6_addr_by_EUI64(i['cidr'],
port_mac).format()
for i in (subnet1, subnet2)
]
self._clean_network()
self.assertSequenceEqual(sorted(real_ips), sorted(eui_ips),
('Real port IPs %s,%s are not equal to'
' SLAAC IPs: %s,%s') %
tuple(real_ips + eui_ips))
def _get_ips_from_subnet(self, **kwargs):
subnet = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
port = self.create_port(self.network, mac_address=port_mac)
real_ip = next(iter(port['fixed_ips']), None)['ip_address']
eui_ip = data_utils.get_ipv6_addr_by_EUI64(subnet['cidr'],
port_mac).format()
return real_ip, eui_ip
def _get_ips_from_subnet(self, **kwargs):
subnet = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
port = self.create_port(self.network, mac_address=port_mac)
real_ip = next(iter(port['fixed_ips']), None)['ip_address']
eui_ip = data_utils.get_ipv6_addr_by_EUI64(subnet['cidr'],
port_mac).format()
return real_ip, eui_ip
def test_dhcpv6_two_subnets(self):
"""When one IPv6 subnet configured with dnsmasq SLAAC or DHCP stateless
and other IPv6 is with DHCP stateful, port shall receive EUI-64 IP
addresses from first subnet and DHCP address from second one.
Order of subnet creating should be unimportant.
"""
for order in ("slaac_first", "dhcp_first"):
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
kwargs_dhcp = {'ipv6_address_mode': 'dhcpv6-stateful'}
if order == "slaac_first":
subnet_slaac = self.create_subnet(self.network, **kwargs)
subnet_dhcp = self.create_subnet(
self.network, **kwargs_dhcp)
else:
subnet_dhcp = self.create_subnet(
self.network, **kwargs_dhcp)
subnet_slaac = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
dhcp_ip = subnet_dhcp["allocation_pools"][0]["start"]
eui_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet_slaac['cidr'],
port_mac
).format()
# TODO(sergsh): remove this when 1219795 is fixed
dhcp_ip = [dhcp_ip, (netaddr.IPAddress(dhcp_ip) + 1).format()]
port = self.create_port(self.network, mac_address=port_mac)
real_ips = dict([(k['subnet_id'], k['ip_address'])
for k in port['fixed_ips']])
real_dhcp_ip, real_eui_ip = [real_ips[sub['id']]
for sub in subnet_dhcp,
subnet_slaac]
self.client.delete_port(port['id'])
self.ports.pop()
body = self.client.list_ports()
ports_id_list = [i['id'] for i in body['ports']]
self.assertNotIn(port['id'], ports_id_list)
self._clean_network()
self.assertEqual(real_eui_ip,
eui_ip,
'Real IP is {0}, but shall be {1}'.format(
real_eui_ip,
eui_ip))
self.assertIn(
real_dhcp_ip, dhcp_ip,
'Real IP is {0}, but shall be one from {1}'.format(
real_dhcp_ip,
str(dhcp_ip)))
def test_dhcpv6_two_subnets(self):
"""When one IPv6 subnet configured with dnsmasq SLAAC or DHCP stateless
and other IPv6 is with DHCP stateful, port shall receive EUI-64 IP
addresses from first subnet and DHCP address from second one.
Order of subnet creating should be unimportant.
"""
for order in ("slaac_first", "dhcp_first"):
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {
'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode
}
kwargs_dhcp = {'ipv6_address_mode': 'dhcpv6-stateful'}
if order == "slaac_first":
subnet_slaac = self.create_subnet(self.network, **kwargs)
subnet_dhcp = self.create_subnet(self.network,
**kwargs_dhcp)
else:
subnet_dhcp = self.create_subnet(self.network,
**kwargs_dhcp)
subnet_slaac = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
dhcp_ip = subnet_dhcp["allocation_pools"][0]["start"]
eui_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet_slaac['cidr'], port_mac).format()
# TODO(sergsh): remove this when 1219795 is fixed
dhcp_ip = [dhcp_ip, (netaddr.IPAddress(dhcp_ip) + 1).format()]
port = self.create_port(self.network, mac_address=port_mac)
real_ips = dict([(k['subnet_id'], k['ip_address'])
for k in port['fixed_ips']])
real_dhcp_ip, real_eui_ip = [
real_ips[sub['id']] for sub in subnet_dhcp, subnet_slaac
]
self.client.delete_port(port['id'])
self.ports.pop()
body = self.client.list_ports()
ports_id_list = [i['id'] for i in body['ports']]
self.assertNotIn(port['id'], ports_id_list)
self._clean_network()
self.assertEqual(
real_eui_ip, eui_ip,
'Real IP is {0}, but shall be {1}'.format(
real_eui_ip, eui_ip))
self.assertIn(
real_dhcp_ip, dhcp_ip,
'Real IP is {0}, but shall be one from {1}'.format(
real_dhcp_ip, str(dhcp_ip)))
def test_dhcpv6_two_subnets(self):
# NOTE: When one IPv6 subnet configured with dnsmasq SLAAC or DHCP
# stateless and other IPv6 is with DHCP stateful, port shall receive
# EUI-64 IP addresses from first subnet and DHCP address from second
# one. Order of subnet creating should be unimportant.
for order in ("slaac_first", "dhcp_first"):
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
kwargs_dhcp = {'ipv6_address_mode': 'dhcpv6-stateful'}
if order == "slaac_first":
subnet_slaac = self.create_subnet(self.network, **kwargs)
subnet_dhcp = self.create_subnet(
self.network, **kwargs_dhcp)
else:
subnet_dhcp = self.create_subnet(
self.network, **kwargs_dhcp)
subnet_slaac = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
eui_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet_slaac['cidr'],
port_mac
).format()
port = self.create_port(self.network, mac_address=port_mac)
real_ips = dict([(k['subnet_id'], k['ip_address'])
for k in port['fixed_ips']])
real_dhcp_ip, real_eui_ip = [real_ips[sub['id']]
for sub in [subnet_dhcp,
subnet_slaac]]
self.ports_client.delete_port(port['id'])
self.ports.pop()
body = self.ports_client.list_ports()
ports_id_list = [i['id'] for i in body['ports']]
self.assertNotIn(port['id'], ports_id_list)
self._clean_network()
self.assertEqual(real_eui_ip,
eui_ip,
'Real IP is {0}, but shall be {1}'.format(
real_eui_ip,
eui_ip))
msg = ('Real IP address is {0} and it is NOT on '
'subnet {1}'.format(real_dhcp_ip, subnet_dhcp['cidr']))
self.assertIn(netaddr.IPAddress(real_dhcp_ip),
netaddr.IPNetwork(subnet_dhcp['cidr']), msg)
def test_dhcpv6_two_subnets(self):
# NOTE: When one IPv6 subnet configured with dnsmasq SLAAC or DHCP
# stateless and other IPv6 is with DHCP stateful, port shall receive
# EUI-64 IP addresses from first subnet and DHCP address from second
# one. Order of subnet creating should be unimportant.
for order in ("slaac_first", "dhcp_first"):
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
kwargs_dhcp = {'ipv6_address_mode': 'dhcpv6-stateful'}
if order == "slaac_first":
subnet_slaac = self.create_subnet(self.network, **kwargs)
subnet_dhcp = self.create_subnet(
self.network, **kwargs_dhcp)
else:
subnet_dhcp = self.create_subnet(
self.network, **kwargs_dhcp)
subnet_slaac = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
eui_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet_slaac['cidr'],
port_mac
).format()
port = self.create_port(self.network, mac_address=port_mac)
real_ips = dict([(k['subnet_id'], k['ip_address'])
for k in port['fixed_ips']])
real_dhcp_ip, real_eui_ip = [real_ips[sub['id']]
for sub in [subnet_dhcp,
subnet_slaac]]
self.ports_client.delete_port(port['id'])
self.ports.pop()
body = self.ports_client.list_ports()
ports_id_list = [i['id'] for i in body['ports']]
self.assertNotIn(port['id'], ports_id_list)
self._clean_network()
self.assertEqual(real_eui_ip,
eui_ip,
'Real IP is {0}, but shall be {1}'.format(
real_eui_ip,
eui_ip))
msg = ('Real IP address is {0} and it is NOT on '
'subnet {1}'.format(real_dhcp_ip, subnet_dhcp['cidr']))
self.assertIn(netaddr.IPAddress(real_dhcp_ip),
netaddr.IPNetwork(subnet_dhcp['cidr']), msg)
def test_dhcpv6_64_subnets(self):
"""When one IPv6 subnet configured with dnsmasq SLAAC or DHCP stateless
and other IPv4 is with DHCP of IPv4, port shall receive EUI-64 IP
addresses from first subnet and IPv4 DHCP address from second one.
Order of subnet creating should be unimportant.
"""
for order in ("slaac_first", "dhcp_first"):
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
if order == "slaac_first":
subnet_slaac = self.create_subnet(self.network, **kwargs)
subnet_dhcp = self.create_subnet(
self.network, ip_version=4)
else:
subnet_dhcp = self.create_subnet(
self.network, ip_version=4)
subnet_slaac = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
eui_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet_slaac['cidr'],
port_mac
).format()
port = self.create_port(self.network, mac_address=port_mac)
real_ips = dict([(k['subnet_id'], k['ip_address'])
for k in port['fixed_ips']])
real_dhcp_ip, real_eui_ip = [real_ips[sub['id']]
for sub in [subnet_dhcp,
subnet_slaac]]
self._clean_network()
self.assertEqual(real_eui_ip,
eui_ip,
'Real IP is {0}, but shall be {1}'.format(
real_eui_ip,
eui_ip))
msg = ('Real IP address is {0} and it is NOT on '
'subnet {1}'.format(real_dhcp_ip, subnet_dhcp['cidr']))
self.assertIn(netaddr.IPAddress(real_dhcp_ip),
netaddr.IPNetwork(subnet_dhcp['cidr']), msg)
def test_dhcpv6_64_subnets(self):
"""When one IPv6 subnet configured with dnsmasq SLAAC or DHCP stateless
and other IPv4 is with DHCP of IPv4, port shall receive EUI-64 IP
addresses from first subnet and IPv4 DHCP address from second one.
Order of subnet creating should be unimportant.
"""
for order in ("slaac_first", "dhcp_first"):
for ra_mode, add_mode in (
('slaac', 'slaac'),
('dhcpv6-stateless', 'dhcpv6-stateless'),
):
kwargs = {'ipv6_ra_mode': ra_mode,
'ipv6_address_mode': add_mode}
if order == "slaac_first":
subnet_slaac = self.create_subnet(self.network, **kwargs)
subnet_dhcp = self.create_subnet(
self.network, ip_version=4)
else:
subnet_dhcp = self.create_subnet(
self.network, ip_version=4)
subnet_slaac = self.create_subnet(self.network, **kwargs)
port_mac = data_utils.rand_mac_address()
eui_ip = data_utils.get_ipv6_addr_by_EUI64(
subnet_slaac['cidr'],
port_mac
).format()
port = self.create_port(self.network, mac_address=port_mac)
real_ips = dict([(k['subnet_id'], k['ip_address'])
for k in port['fixed_ips']])
real_dhcp_ip, real_eui_ip = [real_ips[sub['id']]
for sub in [subnet_dhcp,
subnet_slaac]]
self._clean_network()
self.assertEqual(real_eui_ip,
eui_ip,
'Real IP is {0}, but shall be {1}'.format(
real_eui_ip,
eui_ip))
msg = ('Real IP address is {0} and it is NOT on '
'subnet {1}'.format(real_dhcp_ip, subnet_dhcp['cidr']))
self.assertIn(netaddr.IPAddress(real_dhcp_ip),
netaddr.IPNetwork(subnet_dhcp['cidr']), msg)
def _eui64(self, port, sub):
return data_utils.get_ipv6_addr_by_EUI64(
sub['cidr'],
port['mac_address'].lower()).format()
def _eui64(self, port, sub):
return data_utils.get_ipv6_addr_by_EUI64(
sub['cidr'], port['mac_address'].lower()).format()
