def test_subnet_request_good_gateway(self):
cfg.CONF.set_override('force_gateway_on_subnet', False)
request = ipam_req.SpecificSubnetRequest(self.tenant_id,
self.subnet_id,
'2001::1',
gateway_ip='2000::1')
self.assertEqual(netaddr.IPAddress('2000::1'), request.gateway_ip)
def get_subnet(self, subnet_id):
"""Gets the matching subnet if it has been allocated
:param subnet_id: the subnet identifier
:type subnet_id: str uuid
:returns: An instance of IPAM Subnet
:raises: IPAMAllocationNotFound
"""
subnet_request = neutron_ipam_req.SpecificSubnetRequest(self.subnet_json['tenant_id'],subnet_id,
self.subnet_json['cidr'],None,[])
subnetpool_name = self._subnetpool['name'] if self._subnetpool else self.pool_json['name']
start_addr,_,__ = str(self.subnet_json['cidr']).partition('/')
if self.subnet_json['ip_version'] == 4:
s = eip_rest.get_subnet_list_v4(start_addr,self.sitename,subnetpool_name)
elif self.subnet_json['ip_version'] == 6:
s = eip_rest.get_subnet_list_v6(start_addr,self.sitename,subnetpool_name)
if s is None:
LOG.error("Failed : to retrieve "+subnet_id+" in IPAM")
raise neutron_lib_exc.SubnetNotFound(subnet_id=subnet_id)
ret = eipSubnet(subnet_request)
return ret
def _create_and_allocate_ipam_subnet(
self,
cidr,
allocation_pools=attributes.ATTR_NOT_SPECIFIED,
ip_version=4,
v6_auto_address=False,
tenant_id=None):
v6_address_mode = attributes.ATTR_NOT_SPECIFIED
if v6_auto_address:
# set ip version to 6 regardless of what's been passed to the
# method
ip_version = 6
v6_address_mode = constants.IPV6_SLAAC
subnet = self._create_subnet(self.plugin,
self.ctx,
self.net_id,
cidr,
ip_version=ip_version,
allocation_pools=allocation_pools,
v6_address_mode=v6_address_mode)
# Build netaddr.IPRanges from allocation pools since IPAM SubnetRequest
# objects are strongly typed
allocation_pool_ranges = [
netaddr.IPRange(pool['start'], pool['end'])
for pool in subnet['allocation_pools']
]
subnet_req = ipam_req.SpecificSubnetRequest(
tenant_id,
subnet['id'],
cidr,
gateway_ip=subnet['gateway_ip'],
allocation_pools=allocation_pool_ranges)
ipam_subnet = self.ipam_pool.allocate_subnet(subnet_req)
return ipam_subnet, subnet
def get_details(self):
"""Return subnet data as a SpecificSubnetRequest"""
# get the pool from the backend
try:
pool_details = self.nsxlib_ipam.get(self._nsx_pool_id)
except Exception as e:
msg = _('Failed to get details for nsx pool: %(id)s: '
'%(e)s') % {
'id': self._nsx_pool_id,
'e': e
}
raise ipam_exc.IpamValueInvalid(message=msg)
first_range = pool_details.get('subnets', [None])[0]
if not first_range:
msg = _('Failed to get details for nsx pool: %(id)s') % {
'id': self._nsx_pool_id
}
raise ipam_exc.IpamValueInvalid(message=msg)
cidr = first_range.get('cidr')
gateway_ip = first_range.get('gateway_ip')
pools = []
for subnet in pool_details.get('subnets', []):
for ip_range in subnet.get('allocation_ranges', []):
pools.append(
netaddr.IPRange(ip_range.get('start'),
ip_range.get('end')))
return ipam_req.SpecificSubnetRequest(self._tenant_id,
self._subnet_id,
cidr,
gateway_ip=gateway_ip,
allocation_pools=pools)
def test_allocate_subnet_for_non_existent_subnet_pass(self):
# This test should pass because ipam subnet is no longer
# have foreign key relationship with neutron subnet.
# Creating ipam subnet before neutron subnet is a valid case.
subnet_req = ipam_req.SpecificSubnetRequest('tenant_id', 'meh',
'192.168.0.0/24')
self.ipam_pool.allocate_subnet(subnet_req)
def _prepare_mocks(self, address_factory=None, subnet_factory=None):
if address_factory is None:
address_factory = ipam_req.AddressRequestFactory
if subnet_factory is None:
subnet_factory = ipam_req.SubnetRequestFactory
mocks = {
'driver':
mock.Mock(),
'subnet':
mock.Mock(),
'subnets':
mock.Mock(),
'port': {
'device_owner': constants.DEVICE_OWNER_COMPUTE_PREFIX + 'None'
},
'subnet_request':
ipam_req.SpecificSubnetRequest(
self.tenant_id, self.subnet_id, '10.0.0.0/24', '10.0.0.1',
[netaddr.IPRange('10.0.0.2', '10.0.0.254')]),
}
mocks['driver'].get_subnet.return_value = mocks['subnet']
mocks['driver'].allocate_subnet.return_value = mocks['subnet']
mocks['driver'].get_allocator.return_value = mocks['subnets']
mocks['subnets'].allocate.return_value = (mock.sentinel.address,
mock.sentinel.subnet_id)
mocks['driver'].get_subnet_request_factory.return_value = (
subnet_factory)
mocks['driver'].get_address_request_factory.return_value = (
address_factory)
mocks['subnet'].get_details.return_value = mocks['subnet_request']
return mocks
def test_subnet_request(self):
request = ipam_req.SpecificSubnetRequest(self.tenant_id,
self.subnet_id,
'1.2.3.0/24',
gateway_ip='1.2.3.1')
self.assertEqual(24, request.prefixlen)
self.assertEqual(netaddr.IPAddress('1.2.3.1'), request.gateway_ip)
self.assertEqual(netaddr.IPNetwork('1.2.3.0/24'), request.subnet_cidr)
def _prepare_specific_subnet_request(self, cidr):
subnet = self._create_subnet(self.plugin, self.ctx, self.net_id, cidr)
subnet_req = ipam_req.SpecificSubnetRequest(
self._tenant_id,
subnet['id'],
cidr,
gateway_ip=subnet['gateway_ip'])
return subnet, subnet_req
def test_get_details_for_invalid_subnet_id_fails(self):
cidr = '10.0.0.0/24'
subnet_req = ipam_req.SpecificSubnetRequest(self._tenant_id,
'non-existent-id', cidr)
self.ipam_pool.allocate_subnet(subnet_req)
# Neutron subnet does not exist, so get_subnet should fail
self.assertRaises(n_exc.SubnetNotFound, self.ipam_pool.get_subnet,
'non-existent-id')
def get_details(self):
"""Return subnet detail as a SpecificSubnetRequest.
:returns: An instance of SpecificSubnetRequest with the subnet detail.
"""
### TODO : Maybe building the req is not efficient, we could store it in class attributes
return neutron_ipam_req.SpecificSubnetRequest(self.tenant_id,self.subnet_id,self.cidr,
self.gateway_ip,self.pools)
def test_insufficient_prefix_space_for_specific_allocation(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['10.1.0.0/24'], 21, 4)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'10.1.0.0/21')
self.assertRaises(n_exc.SubnetAllocationError, sa.allocate_subnet, req)
def test_subnetpool_concurrent_allocation_exception(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['fe80::/48'],
48, 6, default_quota=1)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'fe80::/63')
with mock.patch("sqlalchemy.orm.query.Query.update", return_value=0):
self.assertRaises(db_exc.RetryRequest, sa.allocate_subnet, req)
def _build_request_from_subnet(neutron_subnet):
alloc_pools = None
if neutron_subnet.get('allocation_pools'):
alloc_pools = [netaddr.IPRange(pool['start'], pool['end'])
for pool in neutron_subnet['allocation_pools']]
return ipam_req.SpecificSubnetRequest(
neutron_subnet['tenant_id'],
neutron_subnet['id'],
neutron_subnet['cidr'],
neutron_subnet['gateway_ip'],
alloc_pools)
def __init__(self,
tenant_id,
subnet_id,
cidr,
gateway_ip=None,
allocation_pools=None):
self._req = ipam_req.SpecificSubnetRequest(
tenant_id,
subnet_id,
cidr,
gateway_ip=gateway_ip,
allocation_pools=allocation_pools)
def test_subnetpool_default_quota_exceeded(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['fe80::/48'],
48, 6, default_quota=1)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'fe80::/63')
self.assertRaises(n_exc.SubnetPoolQuotaExceeded,
sa.allocate_subnet,
req)
def test_allocate_specific_subnet_specific_gateway(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['10.1.0.0/16', '192.168.1.0/24'], 21, 4)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
with self.ctx.session.begin(subtransactions=True):
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'10.1.2.0/24',
gateway_ip='10.1.2.254')
res = sa.allocate_subnet(req)
detail = res.get_details()
self.assertEqual(detail.gateway_ip,
netaddr.IPAddress('10.1.2.254'))
def test_allocate_specific_subnet(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['10.1.0.0/16', '192.168.1.0/24'], 21, 4)
with self.ctx.session.begin(subtransactions=True):
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'10.1.2.0/24')
res = sa.allocate_subnet(req)
detail = res.get_details()
sp = self._get_subnetpool(self.ctx, self.plugin, sp['id'])
self.assertEqual('10.1.2.0/24', str(detail.subnet_cidr))
self.assertEqual(24, detail.prefixlen)
def test_allocate_specific_subnet_specific_gateway(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['10.1.0.0/16', '192.168.1.0/24'], 21, 4)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
with db_api.context_manager.writer.using(self.ctx):
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'10.1.2.0/24',
gateway_ip='10.1.2.254')
res = sa.allocate_subnet(req)
detail = res.get_details()
self.assertEqual(netaddr.IPAddress('10.1.2.254'),
detail.gateway_ip)
def test_allocate_specific_subnet(self):
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['10.1.0.0/16', '192.168.1.0/24'], 21, 4)
with db_api.context_manager.writer.using(self.ctx):
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'10.1.2.0/24')
res = sa.allocate_subnet(req)
detail = res.get_details()
sp = self._get_subnetpool(self.ctx, self.plugin, sp['id'])
self.assertEqual('10.1.2.0/24', str(detail.subnet_cidr))
self.assertEqual(24, detail.prefixlen)
def test_allocate_specific_ipv6_subnet_specific_gateway(self):
# Same scenario as described in bug #1466322
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['2210::/64'], 64, 6)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
with self.ctx.session.begin(subtransactions=True):
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'2210::/64',
'2210::ffff:ffff:ffff:ffff')
res = sa.allocate_subnet(req)
detail = res.get_details()
self.assertEqual(detail.gateway_ip,
netaddr.IPAddress('2210::ffff:ffff:ffff:ffff'))
def test_allocate_ipam_subnet_no_neutron_subnet_id(self):
cidr = '10.0.0.0/24'
allocation_pools = [
netaddr.IPRange('10.0.0.100', '10.0.0.150'),
netaddr.IPRange('10.0.0.200', '10.0.0.250')
]
subnet_req = ipam_req.SpecificSubnetRequest(
self._tenant_id,
None,
cidr,
allocation_pools=allocation_pools,
gateway_ip='10.0.0.101')
ipam_subnet = self.ipam_pool.allocate_subnet(subnet_req)
self._verify_ipam_subnet_details(ipam_subnet, cidr, self._tenant_id,
'10.0.0.101', allocation_pools)
def test_allocate_specific_ipv6_subnet_specific_gateway(self):
# Same scenario as described in bug #1466322
sp = self._create_subnet_pool(self.plugin, self.ctx, 'test-sp',
['2210::/64'], 64, 6)
sp = self.plugin._get_subnetpool(self.ctx, sp['id'])
with db_api.context_manager.writer.using(self.ctx):
sa = subnet_alloc.SubnetAllocator(sp, self.ctx)
req = ipam_req.SpecificSubnetRequest(self._tenant_id,
uuidutils.generate_uuid(),
'2210::/64',
'2210::ffff:ffff:ffff:ffff')
res = sa.allocate_subnet(req)
detail = res.get_details()
self.assertEqual(netaddr.IPAddress('2210::ffff:ffff:ffff:ffff'),
detail.gateway_ip)
def get_details(self):
"""Return subnet data as a SpecificSubnetRequest"""
# get the pool from the backend
pool_details = self._vcns.get_ipam_ip_pool(self._nsx_pool_id)[1]
gateway_ip = pool_details['gateway']
# rebuild the cidr from the range & prefix
cidr = self._get_pool_cidr(pool_details)
pools = []
for ip_range in pool_details['ipRanges']:
pools.append(netaddr.IPRange(ip_range['startAddress'],
ip_range['endAddress']))
return ipam_req.SpecificSubnetRequest(
self._tenant_id, self._subnet_id,
cidr, gateway_ip=gateway_ip, allocation_pools=pools)
def test_update_subnet_pools(self):
cidr = '10.0.0.0/24'
subnet, subnet_req = self._prepare_specific_subnet_request(cidr)
self.ipam_pool.allocate_subnet(subnet_req)
allocation_pools = [netaddr.IPRange('10.0.0.100', '10.0.0.150'),
netaddr.IPRange('10.0.0.200', '10.0.0.250')]
update_subnet_req = ipam_req.SpecificSubnetRequest(
self._tenant_id,
subnet['id'],
cidr,
gateway_ip=subnet['gateway_ip'],
allocation_pools=allocation_pools)
ipam_subnet = self.ipam_pool.update_subnet(update_subnet_req)
self._verify_ipam_subnet_details(
ipam_subnet,
cidr, self._tenant_id, subnet['gateway_ip'], allocation_pools)
def test__allocate_specific_ip_out_of_range(self):
cidr = '10.0.0.0/24'
subnet = self._create_subnet(self.plugin, self.ctx, self.net_id, cidr)
subnet_req = ipam_req.SpecificSubnetRequest(
'tenant_id', subnet['id'], cidr, gateway_ip=subnet['gateway_ip'])
ipam_subnet = self.ipam_pool.allocate_subnet(subnet_req)
with self.ctx.session.begin():
ranges = ipam_subnet._allocate_specific_ip(self.ctx.session,
'192.168.0.1')
# In this case _allocate_specific_ips does not fail, but
# simply does not update availability ranges at all
self.assertEqual(1, len(ranges))
# 10.0.0.1 should be allocated for gateway ip
ranges.sort(key=convert_firstip_to_ipaddress)
self.assertEqual('10.0.0.2', ranges[0]['first_ip'])
self.assertEqual('10.0.0.254', ranges[0]['last_ip'])
def _test_update_subnet_pools(self, allocation_pools, expected_pools=None):
if expected_pools is None:
expected_pools = allocation_pools
cidr = '10.0.0.0/24'
subnet, subnet_req = self._prepare_specific_subnet_request(cidr)
self.ipam_pool.allocate_subnet(subnet_req)
update_subnet_req = ipam_req.SpecificSubnetRequest(
self._tenant_id,
subnet['id'],
cidr,
gateway_ip=subnet['gateway_ip'],
allocation_pools=allocation_pools)
self.ipam_pool.update_subnet(update_subnet_req)
ipam_subnet = self.ipam_pool.get_subnet(subnet['id'])
self._verify_ipam_subnet_details(ipam_subnet, cidr, self._tenant_id,
subnet['gateway_ip'], expected_pools)
def _prepare_mocks(self):
mocks = {
'driver':
mock.Mock(),
'subnet':
mock.Mock(),
'subnet_request':
ipam_req.SpecificSubnetRequest(
self.tenant_id, self.subnet_id, '10.0.0.0/24', '10.0.0.1',
[netaddr.IPRange('10.0.0.2', '10.0.0.254')]),
}
mocks['driver'].get_subnet.return_value = mocks['subnet']
mocks['driver'].allocate_subnet.return_value = mocks['subnet']
mocks['driver'].get_subnet_request_factory = (
ipam_req.SubnetRequestFactory)
mocks['driver'].get_address_request_factory = (
ipam_req.AddressRequestFactory)
mocks['subnet'].get_details.return_value = mocks['subnet_request']
return mocks
def get_request(cls, context, subnet, subnetpool):
"""Return RomanaAnySubnetRequest."""
LOG.debug("RomanaSubnetRequestFactory.get_request()")
cidr = subnet.get('cidr')
subnet_id = subnet.get('id', uuidutils.generate_uuid())
is_any_subnetpool_request = not attributes.is_attr_set(cidr)
if is_any_subnetpool_request:
prefixlen = subnet['prefixlen']
if not attributes.is_attr_set(prefixlen):
prefixlen = int(subnetpool['default_prefixlen'])
return RomanaAnySubnetRequest(
subnet['tenant_id'], subnet_id,
common_utils.ip_version_from_int(subnetpool['ip_version']),
prefixlen)
else:
return ipam_req.SpecificSubnetRequest(
subnet['tenant_id'], subnet_id, cidr, subnet.get('gateway_ip'),
subnet.get('allocation_pools'))
def get_details(self):
"""Return subnet data as a SpecificSubnetRequest"""
return ipam_req.SpecificSubnetRequest(self._tenant_id,
self.subnet_manager.neutron_id,
self._cidr, self._gateway_ip,
self._pools)
def test_subnet_request_gateway(self):
request = ipam_req.SpecificSubnetRequest(self.tenant_id,
self.subnet_id,
'2001::1',
gateway_ip='2000::1')
self.assertEqual(netaddr.IPAddress('2000::1'), request.gateway_ip)
