Merge "Change IPAM DB API to use context instead of session object."

changes/17/385617/25
Jenkins 6 years ago committed by Gerrit Code Review
commit efe87156c5

@ -23,8 +23,8 @@ from neutron.ipam.drivers.neutrondb_ipam import db_models
class IpamSubnetManager(object):
@classmethod
def load_by_neutron_subnet_id(cls, session, neutron_subnet_id):
return session.query(db_models.IpamSubnet).filter_by(
def load_by_neutron_subnet_id(cls, context, neutron_subnet_id):
return context.session.query(db_models.IpamSubnet).filter_by(
neutron_subnet_id=neutron_subnet_id).first()
def __init__(self, ipam_subnet_id, neutron_subnet_id):
@ -35,13 +35,13 @@ class IpamSubnetManager(object):
def neutron_id(self):
return self._neutron_subnet_id
def create(self, session):
def create(self, context):
"""Create database models for an IPAM subnet.
This method creates a subnet resource for the IPAM driver and
associates it with its neutron identifier, if specified.
:param session: database sesssion.
:param context: neutron api request context
:returns: the idenfier of created IPAM subnet
"""
if not self._ipam_subnet_id:
@ -49,23 +49,23 @@ class IpamSubnetManager(object):
ipam_subnet = db_models.IpamSubnet(
id=self._ipam_subnet_id,
neutron_subnet_id=self._neutron_subnet_id)
session.add(ipam_subnet)
context.session.add(ipam_subnet)
return self._ipam_subnet_id
@classmethod
def delete(cls, session, neutron_subnet_id):
def delete(cls, context, neutron_subnet_id):
"""Delete IPAM subnet.
IPAM subnet no longer has foreign key to neutron subnet,
so need to perform delete manually
:param session: database sesssion
:param context: neutron api request context
:param neutron_subnet_id: neutron subnet id associated with ipam subnet
"""
return session.query(db_models.IpamSubnet).filter_by(
return context.session.query(db_models.IpamSubnet).filter_by(
neutron_subnet_id=neutron_subnet_id).delete()
def create_pool(self, session, pool_start, pool_end):
def create_pool(self, context, pool_start, pool_end):
"""Create an allocation pool for the subnet.
This method does not perform any validation on parameters; it simply
@ -79,50 +79,50 @@ class IpamSubnetManager(object):
ipam_subnet_id=self._ipam_subnet_id,
first_ip=pool_start,
last_ip=pool_end)
session.add(ip_pool)
context.session.add(ip_pool)
return ip_pool
def delete_allocation_pools(self, session):
def delete_allocation_pools(self, context):
"""Remove all allocation pools for the current subnet.
:param session: database session
:param context: neutron api request context
"""
session.query(db_models.IpamAllocationPool).filter_by(
context.session.query(db_models.IpamAllocationPool).filter_by(
ipam_subnet_id=self._ipam_subnet_id).delete()
def list_pools(self, session):
def list_pools(self, context):
"""Return pools for the current subnet."""
return session.query(
return context.session.query(
db_models.IpamAllocationPool).filter_by(
ipam_subnet_id=self._ipam_subnet_id)
def check_unique_allocation(self, session, ip_address):
def check_unique_allocation(self, context, ip_address):
"""Validate that the IP address on the subnet is not in use."""
iprequest = session.query(db_models.IpamAllocation).filter_by(
iprequest = context.session.query(db_models.IpamAllocation).filter_by(
ipam_subnet_id=self._ipam_subnet_id, status='ALLOCATED',
ip_address=ip_address).first()
if iprequest:
return False
return True
def list_allocations(self, session, status='ALLOCATED'):
def list_allocations(self, context, status='ALLOCATED'):
"""Return current allocations for the subnet.
:param session: database session
:param context: neutron api request context
:param status: IP allocation status
:returns: a list of IP allocation as instance of
neutron.ipam.drivers.neutrondb_ipam.db_models.IpamAllocation
"""
return session.query(
return context.session.query(
db_models.IpamAllocation).filter_by(
ipam_subnet_id=self._ipam_subnet_id,
status=status)
def create_allocation(self, session, ip_address,
def create_allocation(self, context, ip_address,
status='ALLOCATED'):
"""Create an IP allocation entry.
:param session: database session
:param context: neutron api request context
:param ip_address: the IP address to allocate
:param status: IP allocation status
"""
@ -130,16 +130,16 @@ class IpamSubnetManager(object):
ip_address=ip_address,
status=status,
ipam_subnet_id=self._ipam_subnet_id)
session.add(ip_request)
context.session.add(ip_request)
def delete_allocation(self, session, ip_address):
def delete_allocation(self, context, ip_address):
"""Remove an IP allocation for this subnet.
:param session: database session
:param context: neutron api request context
:param ip_address: IP address for which the allocation entry should
be removed.
"""
return session.query(db_models.IpamAllocation).filter_by(
return context.session.query(db_models.IpamAllocation).filter_by(
ip_address=ip_address,
ipam_subnet_id=self._ipam_subnet_id).delete(
synchronize_session=False)

@ -43,14 +43,14 @@ class NeutronDbSubnet(ipam_base.Subnet):
"""
@classmethod
def create_allocation_pools(cls, subnet_manager, session, pools, cidr):
def create_allocation_pools(cls, subnet_manager, context, pools, cidr):
for pool in pools:
# IPv6 addresses that start '::1', '::2', etc cause IP version
# ambiguity when converted to integers by pool.first and pool.last.
# Infer the IP version from the subnet cidr.
ip_version = cidr.version
subnet_manager.create_pool(
session,
context,
netaddr.IPAddress(pool.first, ip_version).format(),
netaddr.IPAddress(pool.last, ip_version).format())
@ -61,8 +61,7 @@ class NeutronDbSubnet(ipam_base.Subnet):
ipam_subnet_id,
subnet_request.subnet_id)
# Create subnet resource
session = ctx.session
subnet_manager.create(session)
subnet_manager.create(ctx)
# If allocation pools are not specified, define them around
# the subnet's gateway IP
if not subnet_request.allocation_pools:
@ -71,7 +70,7 @@ class NeutronDbSubnet(ipam_base.Subnet):
else:
pools = subnet_request.allocation_pools
# Create IPAM allocation pools
cls.create_allocation_pools(subnet_manager, session, pools,
cls.create_allocation_pools(subnet_manager, ctx, pools,
subnet_request.subnet_cidr)
return cls(ipam_subnet_id,
@ -89,7 +88,7 @@ class NeutronDbSubnet(ipam_base.Subnet):
:param neutron_subnet_id: neutron subnet identifier.
"""
ipam_subnet = ipam_db_api.IpamSubnetManager.load_by_neutron_subnet_id(
ctx.session, neutron_subnet_id)
ctx, neutron_subnet_id)
if not ipam_subnet:
LOG.error(_LE("IPAM subnet referenced to "
"Neutron subnet %s does not exist"),
@ -132,15 +131,15 @@ class NeutronDbSubnet(ipam_base.Subnet):
self._subnet_id)
self._context = ctx
def _verify_ip(self, session, ip_address):
def _verify_ip(self, context, ip_address):
"""Verify whether IP address can be allocated on subnet.
:param session: database session
:param context: neutron api request context
:param ip_address: String representing the IP address to verify
:raises: InvalidInput, IpAddressAlreadyAllocated
"""
# Ensure that the IP's are unique
if not self.subnet_manager.check_unique_allocation(session,
if not self.subnet_manager.check_unique_allocation(context,
ip_address):
raise ipam_exc.IpAddressAlreadyAllocated(
subnet_id=self.subnet_manager.neutron_id,
@ -152,13 +151,13 @@ class NeutronDbSubnet(ipam_base.Subnet):
subnet_id=self.subnet_manager.neutron_id,
ip=ip_address)
def _generate_ip(self, session, prefer_next=False):
def _generate_ip(self, context, prefer_next=False):
"""Generate an IP address from the set of available addresses."""
ip_allocations = netaddr.IPSet()
for ipallocation in self.subnet_manager.list_allocations(session):
for ipallocation in self.subnet_manager.list_allocations(context):
ip_allocations.add(netaddr.IPAddress(ipallocation.ip_address))
for ip_pool in self.subnet_manager.list_pools(session):
for ip_pool in self.subnet_manager.list_pools(context):
ip_set = netaddr.IPSet()
ip_set.add(netaddr.IPRange(ip_pool.first_ip, ip_pool.last_ip))
av_set = ip_set.difference(ip_allocations)
@ -183,7 +182,6 @@ class NeutronDbSubnet(ipam_base.Subnet):
# running transaction, which is started on create_port or upper level.
# To be able to do rollback/retry actions correctly ipam driver
# should not create new nested transaction blocks.
session = self._context.session
all_pool_id = None
# NOTE(salv-orlando): It would probably better to have a simpler
# model for address requests and just check whether there is a
@ -192,22 +190,24 @@ class NeutronDbSubnet(ipam_base.Subnet):
# This handles both specific and automatic address requests
# Check availability of requested IP
ip_address = str(address_request.address)
self._verify_ip(session, ip_address)
self._verify_ip(self._context, ip_address)
else:
prefer_next = isinstance(address_request,
ipam_req.PreferNextAddressRequest)
ip_address, all_pool_id = self._generate_ip(session, prefer_next)
ip_address, all_pool_id = self._generate_ip(self._context,
prefer_next)
# Create IP allocation request object
# The only defined status at this stage is 'ALLOCATED'.
# More states will be available in the future - e.g.: RECYCLABLE
try:
with session.begin(subtransactions=True):
with self._context.session.begin(subtransactions=True):
# NOTE(kevinbenton): we use a subtransaction to force
# a flush here so we can capture DBReferenceErrors due
# to concurrent subnet deletions. (galera would deadlock
# later on final commit)
self.subnet_manager.create_allocation(session, ip_address)
self.subnet_manager.create_allocation(self._context,
ip_address)
except db_exc.DBReferenceError:
raise n_exc.SubnetNotFound(
subnet_id=self.subnet_manager.neutron_id)
@ -215,21 +215,19 @@ class NeutronDbSubnet(ipam_base.Subnet):
def deallocate(self, address):
# This is almost a no-op because the Neutron DB IPAM driver does not
# delete IPAllocation objects at every deallocation. The only operation
# it performs is to delete an IPRequest entry.
session = self._context.session
# delete IPAllocation objects at every deallocation. The only
# operation it performs is to delete an IPRequest entry.
count = self.subnet_manager.delete_allocation(
session, address)
self._context, address)
# count can hardly be greater than 1, but it can be 0...
if not count:
raise ipam_exc.IpAddressAllocationNotFound(
subnet_id=self.subnet_manager.neutron_id,
ip_address=address)
def _no_pool_changes(self, session, pools):
def _no_pool_changes(self, context, pools):
"""Check if pool updates in db are required."""
db_pools = self.subnet_manager.list_pools(session)
db_pools = self.subnet_manager.list_pools(context)
iprange_pools = [netaddr.IPRange(pool.first_ip, pool.last_ip)
for pool in db_pools]
return pools == iprange_pools
@ -238,11 +236,11 @@ class NeutronDbSubnet(ipam_base.Subnet):
# Pools have already been validated in the subnet request object which
# was sent to the subnet pool driver. Further validation should not be
# required.
session = self._context.session
if self._no_pool_changes(session, pools):
if self._no_pool_changes(self._context, pools):
return
self.subnet_manager.delete_allocation_pools(session)
self.create_allocation_pools(self.subnet_manager, session, pools, cidr)
self.subnet_manager.delete_allocation_pools(self._context)
self.create_allocation_pools(self.subnet_manager, self._context, pools,
cidr)
self._pools = pools
def get_details(self):
@ -313,7 +311,7 @@ class NeutronDbPool(subnet_alloc.SubnetAllocator):
IPAM-related data has no foreign key relationships to neutron subnet,
so removing ipam subnet manually
"""
count = ipam_db_api.IpamSubnetManager.delete(self._context.session,
count = ipam_db_api.IpamSubnetManager.delete(self._context,
subnet_id)
if count < 1:
LOG.error(_LE("IPAM subnet referenced to "

@ -34,7 +34,7 @@ class TestIpamSubnetManager(testlib_api.SqlTestCase):
self.multi_pool = (('1.2.3.2', '1.2.3.12'), ('1.2.3.15', '1.2.3.24'))
self.subnet_manager = db_api.IpamSubnetManager(self.ipam_subnet_id,
self.neutron_subnet_id)
self.subnet_manager_id = self.subnet_manager.create(self.ctx.session)
self.subnet_manager_id = self.subnet_manager.create(self.ctx)
self.ctx.session.flush()
def test_create(self):
@ -44,7 +44,7 @@ class TestIpamSubnetManager(testlib_api.SqlTestCase):
self.assertEqual(1, len(subnets))
def test_remove(self):
count = db_api.IpamSubnetManager.delete(self.ctx.session,
count = db_api.IpamSubnetManager.delete(self.ctx,
self.neutron_subnet_id)
self.assertEqual(1, count)
subnets = self.ctx.session.query(db_models.IpamSubnet).filter_by(
@ -52,7 +52,7 @@ class TestIpamSubnetManager(testlib_api.SqlTestCase):
self.assertEqual(0, len(subnets))
def test_remove_non_existent_subnet(self):
count = db_api.IpamSubnetManager.delete(self.ctx.session,
count = db_api.IpamSubnetManager.delete(self.ctx,
'non-existent')
self.assertEqual(0, count)
@ -61,7 +61,7 @@ class TestIpamSubnetManager(testlib_api.SqlTestCase):
any(pool == (db_pool.first_ip, db_pool.last_ip) for pool in pools))
def test_create_pool(self):
self.subnet_manager.create_pool(self.ctx.session,
self.subnet_manager.create_pool(self.ctx,
self.single_pool[0],
self.single_pool[1])
@ -71,25 +71,25 @@ class TestIpamSubnetManager(testlib_api.SqlTestCase):
def test_check_unique_allocation(self):
self.assertTrue(self.subnet_manager.check_unique_allocation(
self.ctx.session, self.subnet_ip))
self.ctx, self.subnet_ip))
def test_check_unique_allocation_negative(self):
self.subnet_manager.create_allocation(self.ctx.session,
self.subnet_manager.create_allocation(self.ctx,
self.subnet_ip)
self.assertFalse(self.subnet_manager.check_unique_allocation(
self.ctx.session, self.subnet_ip))
self.ctx, self.subnet_ip))
def test_list_allocations(self):
ips = ['1.2.3.4', '1.2.3.6', '1.2.3.7']
for ip in ips:
self.subnet_manager.create_allocation(self.ctx.session, ip)
allocs = self.subnet_manager.list_allocations(self.ctx.session).all()
self.subnet_manager.create_allocation(self.ctx, ip)
allocs = self.subnet_manager.list_allocations(self.ctx).all()
self.assertEqual(len(ips), len(allocs))
for allocation in allocs:
self.assertIn(allocation.ip_address, ips)
def _test_create_allocation(self):
self.subnet_manager.create_allocation(self.ctx.session,
self.subnet_manager.create_allocation(self.ctx,
self.subnet_ip)
alloc = self.ctx.session.query(db_models.IpamAllocation).filter_by(
ipam_subnet_id=self.ipam_subnet_id).all()
@ -102,7 +102,7 @@ class TestIpamSubnetManager(testlib_api.SqlTestCase):
def test_delete_allocation(self):
allocs = self._test_create_allocation()
self.subnet_manager.delete_allocation(self.ctx.session,
self.subnet_manager.delete_allocation(self.ctx,
allocs[0].ip_address)
allocs = self.ctx.session.query(db_models.IpamAllocation).filter_by(

@ -275,14 +275,14 @@ class TestNeutronDbIpamSubnet(testlib_api.SqlTestCase,
def test__verify_ip_succeeds(self):
cidr = '10.0.0.0/24'
ipam_subnet = self._create_and_allocate_ipam_subnet(cidr)[0]
ipam_subnet._verify_ip(self.ctx.session, '10.0.0.2')
ipam_subnet._verify_ip(self.ctx, '10.0.0.2')
def test__verify_ip_not_in_subnet_fails(self):
cidr = '10.0.0.0/24'
ipam_subnet = self._create_and_allocate_ipam_subnet(cidr)[0]
self.assertRaises(ipam_exc.InvalidIpForSubnet,
ipam_subnet._verify_ip,
self.ctx.session,
self.ctx,
'192.168.0.2')
def test__verify_ip_bcast_and_network_fail(self):
@ -290,11 +290,11 @@ class TestNeutronDbIpamSubnet(testlib_api.SqlTestCase,
ipam_subnet = self._create_and_allocate_ipam_subnet(cidr)[0]
self.assertRaises(ipam_exc.InvalidIpForSubnet,
ipam_subnet._verify_ip,
self.ctx.session,
self.ctx,
'10.0.0.255')
self.assertRaises(ipam_exc.InvalidIpForSubnet,
ipam_subnet._verify_ip,
self.ctx.session,
self.ctx,
'10.0.0.0')
def _allocate_address(self, cidr, ip_version, address_request):
@ -415,7 +415,7 @@ class TestNeutronDbIpamSubnet(testlib_api.SqlTestCase,
last_ip='192.168.10.60')]
ipam_subnet.subnet_manager.list_pools = mock.Mock(return_value=pools)
return ipam_subnet._no_pool_changes(self.ctx.session, new_pools)
return ipam_subnet._no_pool_changes(self.ctx, new_pools)
def test__no_pool_changes_negative(self):
pool_list = [[netaddr.IPRange('192.168.10.2', '192.168.10.254')],

Loading…
Cancel
Save