diff --git a/neutron/plugins/ml2/driver_api.py b/neutron/plugins/ml2/driver_api.py index c1787c84d22..2d87c05f396 100644 --- a/neutron/plugins/ml2/driver_api.py +++ b/neutron/plugins/ml2/driver_api.py @@ -36,22 +36,7 @@ BOUND_SEGMENT = 'bound_segment' @six.add_metaclass(abc.ABCMeta) -class TypeDriver(object): - """Define stable abstract interface for ML2 type drivers. - - ML2 type drivers each support a specific network_type for provider - and/or tenant network segments. Type drivers must implement this - abstract interface, which defines the API by which the plugin uses - the driver to manage the persistent type-specific resource - allocation state associated with network segments of that type. - - Network segments are represented by segment dictionaries using the - NETWORK_TYPE, PHYSICAL_NETWORK, and SEGMENTATION_ID keys defined - above, corresponding to the provider attributes. Future revisions - of the TypeDriver API may add additional segment dictionary - keys. Attributes not applicable for a particular network_type may - either be excluded or stored as None. - """ +class _TypeDriverBase(object): @abc.abstractmethod def get_type(self): @@ -99,6 +84,42 @@ class TypeDriver(object): """ pass + @abc.abstractmethod + def get_mtu(self, physical): + """Get driver's network MTU. + + :returns mtu: maximum transmission unit + + Returns the mtu for the network based on the config values and + the network type. + """ + pass + + +@six.add_metaclass(abc.ABCMeta) +class TypeDriver(_TypeDriverBase): + """Define abstract interface for ML2 type drivers. + + ML2 type drivers each support a specific network_type for provider + and/or tenant network segments. Type drivers must implement this + abstract interface, which defines the API by which the plugin uses + the driver to manage the persistent type-specific resource + allocation state associated with network segments of that type. + + Network segments are represented by segment dictionaries using the + NETWORK_TYPE, PHYSICAL_NETWORK, and SEGMENTATION_ID keys defined + above, corresponding to the provider attributes. Future revisions + of the TypeDriver API may add additional segment dictionary + keys. Attributes not applicable for a particular network_type may + either be excluded or stored as None. + + TypeDriver passes session as argument for: + - reserve_provider_segment + - allocate_tenant_segment + - release_segment + - get_allocation + """ + @abc.abstractmethod def reserve_provider_segment(self, session, segment): """Reserve resource associated with a provider network segment. @@ -144,14 +165,73 @@ class TypeDriver(object): """ pass + +@six.add_metaclass(abc.ABCMeta) +class ML2TypeDriver(_TypeDriverBase): + """Define abstract interface for ML2 type drivers. + + ML2 type drivers each support a specific network_type for provider + and/or tenant network segments. Type drivers must implement this + abstract interface, which defines the API by which the plugin uses + the driver to manage the persistent type-specific resource + allocation state associated with network segments of that type. + + Network segments are represented by segment dictionaries using the + NETWORK_TYPE, PHYSICAL_NETWORK, and SEGMENTATION_ID keys defined + above, corresponding to the provider attributes. Future revisions + of the TypeDriver API may add additional segment dictionary + keys. Attributes not applicable for a particular network_type may + either be excluded or stored as None. + + ML2TypeDriver passes context as argument for: + - reserve_provider_segment + - allocate_tenant_segment + - release_segment + - get_allocation + """ + @abc.abstractmethod - def get_mtu(self, physical): - """Get driver's network MTU. + def reserve_provider_segment(self, context, segment): + """Reserve resource associated with a provider network segment. - :returns mtu: maximum transmission unit + :param context: instance of neutron context with DB session + :param segment: segment dictionary + :returns: segment dictionary - Returns the mtu for the network based on the config values and - the network type. + Called inside transaction context on session to reserve the + type-specific resource for a provider network segment. The + segment dictionary passed in was returned by a previous + validate_provider_segment() call. + """ + pass + + @abc.abstractmethod + def allocate_tenant_segment(self, context): + """Allocate resource for a new tenant network segment. + + :param context: instance of neutron context with DB session + :returns: segment dictionary using keys defined above + + Called inside transaction context on session to allocate a new + tenant network, typically from a type-specific resource + pool. If successful, return a segment dictionary describing + the segment. If tenant network segment cannot be allocated + (i.e. tenant networks not supported or resource pool is + exhausted), return None. + """ + pass + + @abc.abstractmethod + def release_segment(self, context, segment): + """Release network segment. + + :param context: instance of neutron context with DB session + :param segment: segment dictionary using keys defined above + + Called inside transaction context on session to release a + tenant or provider network's type-specific resource. Runtime + errors are not expected, but raising an exception will result + in rollback of the transaction. """ pass diff --git a/neutron/plugins/ml2/driver_context.py b/neutron/plugins/ml2/driver_context.py index afc73911615..42ba876e462 100644 --- a/neutron/plugins/ml2/driver_context.py +++ b/neutron/plugins/ml2/driver_context.py @@ -263,4 +263,4 @@ class PortContext(MechanismDriverContext, api.PortContext): def release_dynamic_segment(self, segment_id): return self._plugin.type_manager.release_dynamic_segment( - self._plugin_context.session, segment_id) + self._plugin_context, segment_id) diff --git a/neutron/plugins/ml2/drivers/helpers.py b/neutron/plugins/ml2/drivers/helpers.py index 331ceadbaa4..c58e5bbec24 100644 --- a/neutron/plugins/ml2/drivers/helpers.py +++ b/neutron/plugins/ml2/drivers/helpers.py @@ -31,7 +31,7 @@ LOG = log.getLogger(__name__) IDPOOL_SELECT_SIZE = 100 -class BaseTypeDriver(api.TypeDriver): +class BaseTypeDriver(api.ML2TypeDriver): """BaseTypeDriver for functions common to Segment and flat.""" def __init__(self): @@ -60,7 +60,7 @@ class SegmentTypeDriver(BaseTypeDriver): self.primary_keys = set(dict(model.__table__.columns)) self.primary_keys.remove("allocated") - def allocate_fully_specified_segment(self, session, **raw_segment): + def allocate_fully_specified_segment(self, context, **raw_segment): """Allocate segment fully specified by raw_segment. If segment exists, then try to allocate it and return db object @@ -70,9 +70,10 @@ class SegmentTypeDriver(BaseTypeDriver): network_type = self.get_type() try: - with session.begin(subtransactions=True): - alloc = (session.query(self.model).filter_by(**raw_segment). - first()) + with context.session.begin(subtransactions=True): + alloc = ( + context.session.query(self.model).filter_by(**raw_segment). + first()) if alloc: if alloc.allocated: # Segment already allocated @@ -83,7 +84,7 @@ class SegmentTypeDriver(BaseTypeDriver): "started ", {"type": network_type, "segment": raw_segment}) - count = (session.query(self.model). + count = (context.session.query(self.model). filter_by(allocated=False, **raw_segment). update({"allocated": True})) if count: @@ -104,7 +105,7 @@ class SegmentTypeDriver(BaseTypeDriver): LOG.debug("%(type)s segment %(segment)s create started", {"type": network_type, "segment": raw_segment}) alloc = self.model(allocated=True, **raw_segment) - alloc.save(session) + alloc.save(context.session) LOG.debug("%(type)s segment %(segment)s create done", {"type": network_type, "segment": raw_segment}) @@ -116,15 +117,15 @@ class SegmentTypeDriver(BaseTypeDriver): return alloc - def allocate_partially_specified_segment(self, session, **filters): + def allocate_partially_specified_segment(self, context, **filters): """Allocate model segment from pool partially specified by filters. Return allocated db object or None. """ network_type = self.get_type() - with session.begin(subtransactions=True): - select = (session.query(self.model). + with context.session.begin(subtransactions=True): + select = (context.session.query(self.model). filter_by(allocated=False, **filters)) # Selected segment can be allocated before update by someone else, @@ -140,7 +141,7 @@ class SegmentTypeDriver(BaseTypeDriver): "started with %(segment)s ", {"type": network_type, "segment": raw_segment}) - count = (session.query(self.model). + count = (context.session.query(self.model). filter_by(allocated=False, **raw_segment). update({"allocated": True})) if count: diff --git a/neutron/plugins/ml2/drivers/type_flat.py b/neutron/plugins/ml2/drivers/type_flat.py index e369c90c267..78716a6c768 100644 --- a/neutron/plugins/ml2/drivers/type_flat.py +++ b/neutron/plugins/ml2/drivers/type_flat.py @@ -90,29 +90,29 @@ class FlatTypeDriver(helpers.BaseTypeDriver): msg = _("%s prohibited for flat provider network") % key raise exc.InvalidInput(error_message=msg) - def reserve_provider_segment(self, session, segment): + def reserve_provider_segment(self, context, segment): physical_network = segment[api.PHYSICAL_NETWORK] - with session.begin(subtransactions=True): + with context.session.begin(subtransactions=True): try: LOG.debug("Reserving flat network on physical " "network %s", physical_network) alloc = type_flat_model.FlatAllocation( physical_network=physical_network) - alloc.save(session) + alloc.save(context.session) except db_exc.DBDuplicateEntry: raise n_exc.FlatNetworkInUse( physical_network=physical_network) segment[api.MTU] = self.get_mtu(alloc.physical_network) return segment - def allocate_tenant_segment(self, session): + def allocate_tenant_segment(self, context): # Tenant flat networks are not supported. return - def release_segment(self, session, segment): + def release_segment(self, context, segment): physical_network = segment[api.PHYSICAL_NETWORK] - with session.begin(subtransactions=True): - count = (session.query(type_flat_model.FlatAllocation). + with context.session.begin(subtransactions=True): + count = (context.session.query(type_flat_model.FlatAllocation). filter_by(physical_network=physical_network). delete()) if count: diff --git a/neutron/plugins/ml2/drivers/type_local.py b/neutron/plugins/ml2/drivers/type_local.py index 12f3f9e4883..93335c1c342 100644 --- a/neutron/plugins/ml2/drivers/type_local.py +++ b/neutron/plugins/ml2/drivers/type_local.py @@ -24,7 +24,7 @@ from neutron.plugins.ml2 import driver_api as api LOG = log.getLogger(__name__) -class LocalTypeDriver(api.TypeDriver): +class LocalTypeDriver(api.ML2TypeDriver): """Manage state for local networks with ML2. The LocalTypeDriver implements the 'local' network_type. Local @@ -52,15 +52,15 @@ class LocalTypeDriver(api.TypeDriver): msg = _("%s prohibited for local provider network") % key raise exc.InvalidInput(error_message=msg) - def reserve_provider_segment(self, session, segment): + def reserve_provider_segment(self, context, segment): # No resources to reserve return segment - def allocate_tenant_segment(self, session): + def allocate_tenant_segment(self, context): # No resources to allocate return {api.NETWORK_TYPE: p_const.TYPE_LOCAL} - def release_segment(self, session, segment): + def release_segment(self, context, segment): # No resources to release pass diff --git a/neutron/plugins/ml2/drivers/type_tunnel.py b/neutron/plugins/ml2/drivers/type_tunnel.py index 31abab5f16e..5fa97751e75 100644 --- a/neutron/plugins/ml2/drivers/type_tunnel.py +++ b/neutron/plugins/ml2/drivers/type_tunnel.py @@ -49,16 +49,12 @@ def chunks(iterable, chunk_size): @six.add_metaclass(abc.ABCMeta) -class TunnelTypeDriver(helpers.SegmentTypeDriver): - """Define stable abstract interface for ML2 type drivers. +class _TunnelTypeDriverBase(helpers.SegmentTypeDriver): - tunnel type networks rely on tunnel endpoints. This class defines abstract - methods to manage these endpoints. - """ BULK_SIZE = 100 def __init__(self, model): - super(TunnelTypeDriver, self).__init__(model) + super(_TunnelTypeDriverBase, self).__init__(model) self.segmentation_key = next(iter(self.primary_keys)) @abc.abstractmethod @@ -193,6 +189,32 @@ class TunnelTypeDriver(helpers.SegmentTypeDriver): {'key': key, 'tunnel': segment.get(api.NETWORK_TYPE)}) raise exc.InvalidInput(error_message=msg) + def get_mtu(self, physical_network=None): + seg_mtu = super(_TunnelTypeDriverBase, self).get_mtu() + mtu = [] + if seg_mtu > 0: + mtu.append(seg_mtu) + if cfg.CONF.ml2.path_mtu > 0: + mtu.append(cfg.CONF.ml2.path_mtu) + version = cfg.CONF.ml2.overlay_ip_version + ip_header_length = p_const.IP_HEADER_LENGTH[version] + return min(mtu) - ip_header_length if mtu else 0 + + +@six.add_metaclass(abc.ABCMeta) +class TunnelTypeDriver(_TunnelTypeDriverBase): + """Define stable abstract interface for ML2 type drivers. + + tunnel type networks rely on tunnel endpoints. This class defines abstract + methods to manage these endpoints. + + ML2 type driver that passes session to functions: + - reserve_provider_segment + - allocate_tenant_segment + - release_segment + - get_allocation + """ + def reserve_provider_segment(self, session, segment): if self.is_partial_segment(segment): alloc = self.allocate_partially_specified_segment(session) @@ -246,19 +268,76 @@ class TunnelTypeDriver(helpers.SegmentTypeDriver): filter_by(**{self.segmentation_key: tunnel_id}). first()) - def get_mtu(self, physical_network=None): - seg_mtu = super(TunnelTypeDriver, self).get_mtu() - mtu = [] - if seg_mtu > 0: - mtu.append(seg_mtu) - if cfg.CONF.ml2.path_mtu > 0: - mtu.append(cfg.CONF.ml2.path_mtu) - version = cfg.CONF.ml2.overlay_ip_version - ip_header_length = p_const.IP_HEADER_LENGTH[version] - return min(mtu) - ip_header_length if mtu else 0 + +@six.add_metaclass(abc.ABCMeta) +class ML2TunnelTypeDriver(_TunnelTypeDriverBase): + """Define stable abstract interface for ML2 type drivers. + + tunnel type networks rely on tunnel endpoints. This class defines abstract + methods to manage these endpoints. + + ML2 type driver that passes context as argument to functions: + - reserve_provider_segment + - allocate_tenant_segment + - release_segment + - get_allocation + """ + + def reserve_provider_segment(self, context, segment): + if self.is_partial_segment(segment): + alloc = self.allocate_partially_specified_segment(context) + if not alloc: + raise exc.NoNetworkAvailable() + else: + segmentation_id = segment.get(api.SEGMENTATION_ID) + alloc = self.allocate_fully_specified_segment( + context, **{self.segmentation_key: segmentation_id}) + if not alloc: + raise exc.TunnelIdInUse(tunnel_id=segmentation_id) + return {api.NETWORK_TYPE: self.get_type(), + api.PHYSICAL_NETWORK: None, + api.SEGMENTATION_ID: getattr(alloc, self.segmentation_key), + api.MTU: self.get_mtu()} + + def allocate_tenant_segment(self, context): + alloc = self.allocate_partially_specified_segment(context) + if not alloc: + return + return {api.NETWORK_TYPE: self.get_type(), + api.PHYSICAL_NETWORK: None, + api.SEGMENTATION_ID: getattr(alloc, self.segmentation_key), + api.MTU: self.get_mtu()} + + def release_segment(self, context, segment): + tunnel_id = segment[api.SEGMENTATION_ID] + + inside = any(lo <= tunnel_id <= hi for lo, hi in self.tunnel_ranges) + + info = {'type': self.get_type(), 'id': tunnel_id} + with context.session.begin(subtransactions=True): + query = (context.session.query(self.model). + filter_by(**{self.segmentation_key: tunnel_id})) + if inside: + count = query.update({"allocated": False}) + if count: + LOG.debug("Releasing %(type)s tunnel %(id)s to pool", + info) + else: + count = query.delete() + if count: + LOG.debug("Releasing %(type)s tunnel %(id)s outside pool", + info) + + if not count: + LOG.warning(_LW("%(type)s tunnel %(id)s not found"), info) + + def get_allocation(self, context, tunnel_id): + return (context.session.query(self.model). + filter_by(**{self.segmentation_key: tunnel_id}). + first()) -class EndpointTunnelTypeDriver(TunnelTypeDriver): +class EndpointTunnelTypeDriver(ML2TunnelTypeDriver): def __init__(self, segment_model, endpoint_model): super(EndpointTunnelTypeDriver, self).__init__(segment_model) diff --git a/neutron/plugins/ml2/drivers/type_vlan.py b/neutron/plugins/ml2/drivers/type_vlan.py index 0b31e1b90a6..f52c0d1997b 100644 --- a/neutron/plugins/ml2/drivers/type_vlan.py +++ b/neutron/plugins/ml2/drivers/type_vlan.py @@ -161,7 +161,7 @@ class VlanTypeDriver(helpers.SegmentTypeDriver): msg = _("%s prohibited for VLAN provider network") % key raise exc.InvalidInput(error_message=msg) - def reserve_provider_segment(self, session, segment): + def reserve_provider_segment(self, context, segment): filters = {} physical_network = segment.get(api.PHYSICAL_NETWORK) if physical_network is not None: @@ -172,12 +172,12 @@ class VlanTypeDriver(helpers.SegmentTypeDriver): if self.is_partial_segment(segment): alloc = self.allocate_partially_specified_segment( - session, **filters) + context, **filters) if not alloc: raise exc.NoNetworkAvailable() else: alloc = self.allocate_fully_specified_segment( - session, **filters) + context, **filters) if not alloc: raise exc.VlanIdInUse(**filters) @@ -186,8 +186,8 @@ class VlanTypeDriver(helpers.SegmentTypeDriver): api.SEGMENTATION_ID: alloc.vlan_id, api.MTU: self.get_mtu(alloc.physical_network)} - def allocate_tenant_segment(self, session): - alloc = self.allocate_partially_specified_segment(session) + def allocate_tenant_segment(self, context): + alloc = self.allocate_partially_specified_segment(context) if not alloc: return return {api.NETWORK_TYPE: p_const.TYPE_VLAN, @@ -195,15 +195,15 @@ class VlanTypeDriver(helpers.SegmentTypeDriver): api.SEGMENTATION_ID: alloc.vlan_id, api.MTU: self.get_mtu(alloc.physical_network)} - def release_segment(self, session, segment): + def release_segment(self, context, segment): physical_network = segment[api.PHYSICAL_NETWORK] vlan_id = segment[api.SEGMENTATION_ID] ranges = self.network_vlan_ranges.get(physical_network, []) inside = any(lo <= vlan_id <= hi for lo, hi in ranges) - with session.begin(subtransactions=True): - query = (session.query(vlan_alloc_model.VlanAllocation). + with context.session.begin(subtransactions=True): + query = (context.session.query(vlan_alloc_model.VlanAllocation). filter_by(physical_network=physical_network, vlan_id=vlan_id)) if inside: diff --git a/neutron/plugins/ml2/managers.py b/neutron/plugins/ml2/managers.py index 60489212f3c..6ae90c57eff 100644 --- a/neutron/plugins/ml2/managers.py +++ b/neutron/plugins/ml2/managers.py @@ -197,18 +197,18 @@ class TypeManager(stevedore.named.NamedExtensionManager): if segments: for segment_index, segment in enumerate(segments): segment = self.reserve_provider_segment( - session, segment) + context, segment) self._add_network_segment(context, network_id, segment, segment_index) elif (cfg.CONF.ml2.external_network_type and self._get_attribute(network, external_net.EXTERNAL)): - segment = self._allocate_ext_net_segment(session) + segment = self._allocate_ext_net_segment(context) self._add_network_segment(context, network_id, segment) else: - segment = self._allocate_tenant_net_segment(session) + segment = self._allocate_tenant_net_segment(context) self._add_network_segment(context, network_id, segment) - def reserve_network_segment(self, session, segment_data): + def reserve_network_segment(self, context, segment_data): """Call type drivers to reserve a network segment.""" # Validate the data of segment if not validators.is_attr_set(segment_data[api.NETWORK_TYPE]): @@ -225,8 +225,8 @@ class TypeManager(stevedore.named.NamedExtensionManager): self.validate_provider_segment(segment) # Reserve segment in type driver - with session.begin(subtransactions=True): - return self.reserve_provider_segment(session, segment) + with context.session.begin(subtransactions=True): + return self.reserve_provider_segment(context, segment) def is_partial_segment(self, segment): network_type = segment[api.NETWORK_TYPE] @@ -246,41 +246,53 @@ class TypeManager(stevedore.named.NamedExtensionManager): msg = _("network_type value '%s' not supported") % network_type raise exc.InvalidInput(error_message=msg) - def reserve_provider_segment(self, session, segment): + def reserve_provider_segment(self, context, segment): network_type = segment.get(api.NETWORK_TYPE) driver = self.drivers.get(network_type) - return driver.obj.reserve_provider_segment(session, segment) + if isinstance(driver.obj, api.TypeDriver): + return driver.obj.reserve_provider_segment(context.session, + segment) + else: + return driver.obj.reserve_provider_segment(context, + segment) - def _allocate_segment(self, session, network_type): + def _allocate_segment(self, context, network_type): driver = self.drivers.get(network_type) - return driver.obj.allocate_tenant_segment(session) + if isinstance(driver.obj, api.TypeDriver): + return driver.obj.allocate_tenant_segment(context.session) + else: + return driver.obj.allocate_tenant_segment(context) - def _allocate_tenant_net_segment(self, session): + def _allocate_tenant_net_segment(self, context): for network_type in self.tenant_network_types: - segment = self._allocate_segment(session, network_type) + segment = self._allocate_segment(context, network_type) if segment: return segment raise exc.NoNetworkAvailable() - def _allocate_ext_net_segment(self, session): + def _allocate_ext_net_segment(self, context): network_type = cfg.CONF.ml2.external_network_type - segment = self._allocate_segment(session, network_type) + segment = self._allocate_segment(context, network_type) if segment: return segment raise exc.NoNetworkAvailable() - def release_network_segments(self, session, network_id): - segments = segments_db.get_network_segments(session, network_id, + def release_network_segments(self, context, network_id): + segments = segments_db.get_network_segments(context.session, + network_id, filter_dynamic=None) for segment in segments: - self.release_network_segment(session, segment) + self.release_network_segment(context, segment) - def release_network_segment(self, session, segment): + def release_network_segment(self, context, segment): network_type = segment.get(api.NETWORK_TYPE) driver = self.drivers.get(network_type) if driver: - driver.obj.release_segment(session, segment) + if isinstance(driver.obj, api.TypeDriver): + driver.obj.release_segment(context.session, segment) + else: + driver.obj.release_segment(context, segment) else: LOG.error(_LE("Failed to release segment '%s' because " "network type is not supported."), segment) @@ -295,20 +307,28 @@ class TypeManager(stevedore.named.NamedExtensionManager): return dynamic_segment driver = self.drivers.get(segment.get(api.NETWORK_TYPE)) - dynamic_segment = driver.obj.reserve_provider_segment(context.session, - segment) - segments_db.add_network_segment(context, network_id, dynamic_segment, + if isinstance(driver.obj, api.TypeDriver): + dynamic_segment = driver.obj.reserve_provider_segment( + context.session, segment) + else: + dynamic_segment = driver.obj.reserve_provider_segment( + context, segment) + segments_db.add_network_segment(context, + network_id, dynamic_segment, is_dynamic=True) return dynamic_segment - def release_dynamic_segment(self, session, segment_id): + def release_dynamic_segment(self, context, segment_id): """Delete a dynamic segment.""" - segment = segments_db.get_segment_by_id(session, segment_id) + segment = segments_db.get_segment_by_id(context.session, segment_id) if segment: driver = self.drivers.get(segment.get(api.NETWORK_TYPE)) if driver: - driver.obj.release_segment(session, segment) - segments_db.delete_network_segment(session, segment_id) + if isinstance(driver.obj, api.TypeDriver): + driver.obj.release_segment(context.session, segment) + else: + driver.obj.release_segment(context, segment) + segments_db.delete_network_segment(context.session, segment_id) else: LOG.error(_LE("Failed to release segment '%s' because " "network type is not supported."), segment) diff --git a/neutron/plugins/ml2/plugin.py b/neutron/plugins/ml2/plugin.py index 3690ca2648e..fd06bc76ea5 100644 --- a/neutron/plugins/ml2/plugin.py +++ b/neutron/plugins/ml2/plugin.py @@ -1868,17 +1868,16 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2, # by unifying segment creation procedure. return - session = context.session network_id = segment.get('network_id') if event == events.PRECOMMIT_CREATE: updated_segment = self.type_manager.reserve_network_segment( - session, segment) + context, segment) # The segmentation id might be from ML2 type driver, update it # in the original segment. segment[api.SEGMENTATION_ID] = updated_segment[api.SEGMENTATION_ID] elif event == events.PRECOMMIT_DELETE: - self.type_manager.release_network_segment(session, segment) + self.type_manager.release_network_segment(context, segment) try: self._notify_mechanism_driver_for_segment_change( diff --git a/neutron/tests/unit/plugins/ml2/drivers/base_type_tunnel.py b/neutron/tests/unit/plugins/ml2/drivers/base_type_tunnel.py index 82900258c42..80a33fb176c 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/base_type_tunnel.py +++ b/neutron/tests/unit/plugins/ml2/drivers/base_type_tunnel.py @@ -19,7 +19,7 @@ from six import moves import testtools from testtools import matchers -from neutron.db import api as db +from neutron import context from neutron.plugins.common import constants as p_const from neutron.plugins.ml2 import config from neutron.plugins.ml2 import driver_api as api @@ -45,7 +45,7 @@ class TunnelTypeTestMixin(object): self.driver = self.DRIVER_CLASS() self.driver.tunnel_ranges = TUNNEL_RANGES self.driver.sync_allocations() - self.session = db.get_session() + self.context = context.Context() def test_tunnel_type(self): self.assertEqual(self.TYPE, self.driver.get_type()) @@ -66,47 +66,47 @@ class TunnelTypeTestMixin(object): def test_sync_tunnel_allocations(self): self.assertIsNone( - self.driver.get_allocation(self.session, (TUN_MIN - 1))) + self.driver.get_allocation(self.context, (TUN_MIN - 1))) self.assertFalse( - self.driver.get_allocation(self.session, (TUN_MIN)).allocated) + self.driver.get_allocation(self.context, (TUN_MIN)).allocated) self.assertFalse( - self.driver.get_allocation(self.session, (TUN_MIN + 1)).allocated) + self.driver.get_allocation(self.context, (TUN_MIN + 1)).allocated) self.assertFalse( - self.driver.get_allocation(self.session, (TUN_MAX - 1)).allocated) + self.driver.get_allocation(self.context, (TUN_MAX - 1)).allocated) self.assertFalse( - self.driver.get_allocation(self.session, (TUN_MAX)).allocated) + self.driver.get_allocation(self.context, (TUN_MAX)).allocated) self.assertIsNone( - self.driver.get_allocation(self.session, (TUN_MAX + 1))) + self.driver.get_allocation(self.context, (TUN_MAX + 1))) self.driver.tunnel_ranges = UPDATED_TUNNEL_RANGES self.driver.sync_allocations() self.assertIsNone( - self.driver.get_allocation(self.session, (TUN_MIN + 5 - 1))) + self.driver.get_allocation(self.context, (TUN_MIN + 5 - 1))) self.assertFalse( - self.driver.get_allocation(self.session, (TUN_MIN + 5)).allocated) + self.driver.get_allocation(self.context, (TUN_MIN + 5)).allocated) self.assertFalse( - self.driver.get_allocation(self.session, + self.driver.get_allocation(self.context, (TUN_MIN + 5 + 1)).allocated) self.assertFalse( - self.driver.get_allocation(self.session, + self.driver.get_allocation(self.context, (TUN_MAX + 5 - 1)).allocated) self.assertFalse( - self.driver.get_allocation(self.session, (TUN_MAX + 5)).allocated) + self.driver.get_allocation(self.context, (TUN_MAX + 5)).allocated) self.assertIsNone( - self.driver.get_allocation(self.session, (TUN_MAX + 5 + 1))) + self.driver.get_allocation(self.context, (TUN_MAX + 5 + 1))) def _test_sync_allocations_and_allocated(self, tunnel_id): segment = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: None, api.SEGMENTATION_ID: tunnel_id} - self.driver.reserve_provider_segment(self.session, segment) + self.driver.reserve_provider_segment(self.context, segment) self.driver.tunnel_ranges = UPDATED_TUNNEL_RANGES self.driver.sync_allocations() self.assertTrue( - self.driver.get_allocation(self.session, tunnel_id).allocated) + self.driver.get_allocation(self.context, tunnel_id).allocated) def test_sync_allocations_and_allocated_in_initial_range(self): self._test_sync_allocations_and_allocated(TUN_MIN + 2) @@ -141,27 +141,27 @@ class TunnelTypeTestMixin(object): segment = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: None, api.SEGMENTATION_ID: 101} - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self.driver.get_allocation(self.session, + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self.driver.get_allocation(self.context, observed[api.SEGMENTATION_ID]) self.assertTrue(alloc.allocated) with testtools.ExpectedException(exc.TunnelIdInUse): - self.driver.reserve_provider_segment(self.session, segment) + self.driver.reserve_provider_segment(self.context, segment) - self.driver.release_segment(self.session, segment) - alloc = self.driver.get_allocation(self.session, + self.driver.release_segment(self.context, segment) + alloc = self.driver.get_allocation(self.context, observed[api.SEGMENTATION_ID]) self.assertFalse(alloc.allocated) segment[api.SEGMENTATION_ID] = 1000 - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self.driver.get_allocation(self.session, + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self.driver.get_allocation(self.context, observed[api.SEGMENTATION_ID]) self.assertTrue(alloc.allocated) - self.driver.release_segment(self.session, segment) - alloc = self.driver.get_allocation(self.session, + self.driver.release_segment(self.context, segment) + alloc = self.driver.get_allocation(self.context, observed[api.SEGMENTATION_ID]) self.assertIsNone(alloc) @@ -172,7 +172,7 @@ class TunnelTypeTestMixin(object): api.SEGMENTATION_ID: None} for x in moves.range(TUN_MIN, TUN_MAX + 1): - segment = self.driver.reserve_provider_segment(self.session, + segment = self.driver.reserve_provider_segment(self.context, specs) self.assertEqual(self.TYPE, segment[api.NETWORK_TYPE]) self.assertThat(segment[api.SEGMENTATION_ID], @@ -182,14 +182,14 @@ class TunnelTypeTestMixin(object): tunnel_ids.add(segment[api.SEGMENTATION_ID]) with testtools.ExpectedException(exc.NoNetworkAvailable): - segment = self.driver.reserve_provider_segment(self.session, + segment = self.driver.reserve_provider_segment(self.context, specs) segment = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: 'None', api.SEGMENTATION_ID: tunnel_ids.pop()} - self.driver.release_segment(self.session, segment) - segment = self.driver.reserve_provider_segment(self.session, specs) + self.driver.release_segment(self.context, segment) + segment = self.driver.reserve_provider_segment(self.context, specs) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], @@ -198,26 +198,26 @@ class TunnelTypeTestMixin(object): for tunnel_id in tunnel_ids: segment[api.SEGMENTATION_ID] = tunnel_id - self.driver.release_segment(self.session, segment) + self.driver.release_segment(self.context, segment) def test_allocate_tenant_segment(self): tunnel_ids = set() for x in moves.range(TUN_MIN, TUN_MAX + 1): - segment = self.driver.allocate_tenant_segment(self.session) + segment = self.driver.allocate_tenant_segment(self.context) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(segment[api.SEGMENTATION_ID]) - segment = self.driver.allocate_tenant_segment(self.session) + segment = self.driver.allocate_tenant_segment(self.context) self.assertIsNone(segment) segment = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: 'None', api.SEGMENTATION_ID: tunnel_ids.pop()} - self.driver.release_segment(self.session, segment) - segment = self.driver.allocate_tenant_segment(self.session) + self.driver.release_segment(self.context, segment) + segment = self.driver.allocate_tenant_segment(self.context) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], @@ -226,7 +226,7 @@ class TunnelTypeTestMixin(object): for tunnel_id in tunnel_ids: segment[api.SEGMENTATION_ID] = tunnel_id - self.driver.release_segment(self.session, segment) + self.driver.release_segment(self.context, segment) def add_endpoint(self, ip=TUNNEL_IP_ONE, host=HOST_ONE): return self.driver.add_endpoint(ip, host) @@ -289,19 +289,19 @@ class TunnelTypeMultiRangeTestMixin(object): self.driver = self.DRIVER_CLASS() self.driver.tunnel_ranges = self.TUNNEL_MULTI_RANGES self.driver.sync_allocations() - self.session = db.get_session() + self.context = context.Context() def test_release_segment(self): - segments = [self.driver.allocate_tenant_segment(self.session) + segments = [self.driver.allocate_tenant_segment(self.context) for i in range(4)] # Release them in random order. No special meaning. for i in (0, 2, 1, 3): - self.driver.release_segment(self.session, segments[i]) + self.driver.release_segment(self.context, segments[i]) for key in (self.TUN_MIN0, self.TUN_MAX0, self.TUN_MIN1, self.TUN_MAX1): - alloc = self.driver.get_allocation(self.session, key) + alloc = self.driver.get_allocation(self.context, key) self.assertFalse(alloc.allocated) diff --git a/neutron/tests/unit/plugins/ml2/drivers/test_helpers.py b/neutron/tests/unit/plugins/ml2/drivers/test_helpers.py index 8f607344008..68485f0f558 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/test_helpers.py +++ b/neutron/tests/unit/plugins/ml2/drivers/test_helpers.py @@ -17,7 +17,7 @@ import mock from oslo_db import exception as exc from sqlalchemy.orm import query -import neutron.db.api as db +from neutron import context from neutron.plugins.ml2.drivers import type_vlan from neutron.tests.unit import testlib_api @@ -38,7 +38,7 @@ class HelpersTest(testlib_api.SqlTestCase): self.driver = type_vlan.VlanTypeDriver() self.driver.network_vlan_ranges = NETWORK_VLAN_RANGES self.driver._sync_vlan_allocations() - self.session = db.get_session() + self.context = context.get_admin_context() def check_raw_segment(self, expected, observed): for key, value in expected.items(): @@ -50,15 +50,15 @@ class HelpersTest(testlib_api.SqlTestCase): def test_allocate_specific_unallocated_segment_in_pools(self): expected = dict(physical_network=TENANT_NET, vlan_id=VLAN_MIN) - observed = self.driver.allocate_fully_specified_segment(self.session, + observed = self.driver.allocate_fully_specified_segment(self.context, **expected) self.check_raw_segment(expected, observed) def test_allocate_specific_allocated_segment_in_pools(self): raw_segment = dict(physical_network=TENANT_NET, vlan_id=VLAN_MIN) - self.driver.allocate_fully_specified_segment(self.session, + self.driver.allocate_fully_specified_segment(self.context, **raw_segment) - observed = self.driver.allocate_fully_specified_segment(self.session, + observed = self.driver.allocate_fully_specified_segment(self.context, **raw_segment) self.assertIsNone(observed) @@ -69,20 +69,20 @@ class HelpersTest(testlib_api.SqlTestCase): raw_segment = dict(physical_network=TENANT_NET, vlan_id=VLAN_MIN) with mock.patch.object(query.Query, 'update', return_value=0): observed = self.driver.allocate_fully_specified_segment( - self.session, **raw_segment) + self.context, **raw_segment) self.assertIsNone(observed) def test_allocate_specific_unallocated_segment_outside_pools(self): expected = dict(physical_network=TENANT_NET, vlan_id=VLAN_OUTSIDE) - observed = self.driver.allocate_fully_specified_segment(self.session, + observed = self.driver.allocate_fully_specified_segment(self.context, **expected) self.check_raw_segment(expected, observed) def test_allocate_specific_allocated_segment_outside_pools(self): raw_segment = dict(physical_network=TENANT_NET, vlan_id=VLAN_OUTSIDE) - self.driver.allocate_fully_specified_segment(self.session, + self.driver.allocate_fully_specified_segment(self.context, **raw_segment) - observed = self.driver.allocate_fully_specified_segment(self.session, + observed = self.driver.allocate_fully_specified_segment(self.context, **raw_segment) self.assertIsNone(observed) @@ -93,32 +93,32 @@ class HelpersTest(testlib_api.SqlTestCase): expected = dict(physical_network=TENANT_NET, vlan_id=VLAN_MIN) with mock.patch.object(self.driver.model, 'save'): observed = self.driver.allocate_fully_specified_segment( - self.session, **expected) + self.context, **expected) self.check_raw_segment(expected, observed) def test_allocate_partial_segment_without_filters(self): expected = dict(physical_network=TENANT_NET) observed = self.driver.allocate_partially_specified_segment( - self.session) + self.context) self.check_raw_segment(expected, observed) def test_allocate_partial_segment_with_filter(self): expected = dict(physical_network=TENANT_NET) observed = self.driver.allocate_partially_specified_segment( - self.session, **expected) + self.context, **expected) self.check_raw_segment(expected, observed) def test_allocate_partial_segment_no_resource_available(self): for i in range(VLAN_MIN, VLAN_MAX + 1): - self.driver.allocate_partially_specified_segment(self.session) + self.driver.allocate_partially_specified_segment(self.context) observed = self.driver.allocate_partially_specified_segment( - self.session) + self.context) self.assertIsNone(observed) def test_allocate_partial_segment_outside_pools(self): raw_segment = dict(physical_network='other_phys_net') observed = self.driver.allocate_partially_specified_segment( - self.session, **raw_segment) + self.context, **raw_segment) self.assertIsNone(observed) def test_allocate_partial_segment_first_attempt_fails(self): @@ -127,7 +127,7 @@ class HelpersTest(testlib_api.SqlTestCase): self.assertRaises( exc.RetryRequest, self.driver.allocate_partially_specified_segment, - self.session, **expected) + self.context, **expected) observed = self.driver.allocate_partially_specified_segment( - self.session, **expected) + self.context, **expected) self.check_raw_segment(expected, observed) diff --git a/neutron/tests/unit/plugins/ml2/drivers/test_type_flat.py b/neutron/tests/unit/plugins/ml2/drivers/test_type_flat.py index 42e40a53398..3fa40bfff78 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/test_type_flat.py +++ b/neutron/tests/unit/plugins/ml2/drivers/test_type_flat.py @@ -16,7 +16,7 @@ from neutron_lib import exceptions as exc from neutron.common import exceptions as n_exc -import neutron.db.api as db +from neutron import context from neutron.db.models.plugins.ml2 import flatallocation as type_flat_model from neutron.plugins.common import constants as p_const from neutron.plugins.ml2 import config @@ -36,11 +36,11 @@ class FlatTypeTest(testlib_api.SqlTestCase): config.cfg.CONF.set_override('flat_networks', FLAT_NETWORKS, group='ml2_type_flat') self.driver = type_flat.FlatTypeDriver() - self.session = db.get_session() + self.context = context.Context() self.driver.physnet_mtus = [] - def _get_allocation(self, session, segment): - return session.query(type_flat_model.FlatAllocation).filter_by( + def _get_allocation(self, context, segment): + return context.session.query(type_flat_model.FlatAllocation).filter_by( physical_network=segment[api.PHYSICAL_NETWORK]).first() def test_is_partial_segment(self): @@ -100,28 +100,28 @@ class FlatTypeTest(testlib_api.SqlTestCase): def test_reserve_provider_segment(self): segment = {api.NETWORK_TYPE: p_const.TYPE_FLAT, api.PHYSICAL_NETWORK: 'flat_net1'} - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self._get_allocation(self.session, observed) + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self._get_allocation(self.context, observed) self.assertEqual(segment[api.PHYSICAL_NETWORK], alloc.physical_network) def test_release_segment(self): segment = {api.NETWORK_TYPE: p_const.TYPE_FLAT, api.PHYSICAL_NETWORK: 'flat_net1'} - self.driver.reserve_provider_segment(self.session, segment) - self.driver.release_segment(self.session, segment) - alloc = self._get_allocation(self.session, segment) + self.driver.reserve_provider_segment(self.context, segment) + self.driver.release_segment(self.context, segment) + alloc = self._get_allocation(self.context, segment) self.assertIsNone(alloc) def test_reserve_provider_segment_already_reserved(self): segment = {api.NETWORK_TYPE: p_const.TYPE_FLAT, api.PHYSICAL_NETWORK: 'flat_net1'} - self.driver.reserve_provider_segment(self.session, segment) + self.driver.reserve_provider_segment(self.context, segment) self.assertRaises(n_exc.FlatNetworkInUse, self.driver.reserve_provider_segment, - self.session, segment) + self.context, segment) def test_allocate_tenant_segment(self): - observed = self.driver.allocate_tenant_segment(self.session) + observed = self.driver.allocate_tenant_segment(self.context) self.assertIsNone(observed) def test_get_mtu(self): diff --git a/neutron/tests/unit/plugins/ml2/drivers/test_type_gre.py b/neutron/tests/unit/plugins/ml2/drivers/test_type_gre.py index d968b13e389..0f873feac5a 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/test_type_gre.py +++ b/neutron/tests/unit/plugins/ml2/drivers/test_type_gre.py @@ -13,7 +13,6 @@ # License for the specific language governing permissions and limitations # under the License. -from neutron.db.models.plugins.ml2 import gre_allocation_endpoints as gre_model from neutron.plugins.common import constants as p_const from neutron.plugins.ml2.drivers import type_gre from neutron.tests.unit.plugins.ml2.drivers import base_type_tunnel @@ -27,16 +26,6 @@ HOST_ONE = 'fake_host_one' HOST_TWO = 'fake_host_two' -def _add_allocation(session, gre_id, allocated=False): - allocation = gre_model.GreAllocation(gre_id=gre_id, allocated=allocated) - allocation.save(session) - - -def _get_allocation(session, gre_id): - return session.query(gre_model.GreAllocation).filter_by( - gre_id=gre_id).one() - - class GreTypeTest(base_type_tunnel.TunnelTypeTestMixin, testlib_api.SqlTestCase): DRIVER_MODULE = type_gre diff --git a/neutron/tests/unit/plugins/ml2/drivers/test_type_local.py b/neutron/tests/unit/plugins/ml2/drivers/test_type_local.py index 1f10187b6c3..4c7714019d0 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/test_type_local.py +++ b/neutron/tests/unit/plugins/ml2/drivers/test_type_local.py @@ -26,7 +26,7 @@ class LocalTypeTest(base.BaseTestCase): def setUp(self): super(LocalTypeTest, self).setUp() self.driver = type_local.LocalTypeDriver() - self.session = None + self.context = None def test_is_partial_segment(self): segment = {api.NETWORK_TYPE: p_const.TYPE_LOCAL} @@ -52,15 +52,15 @@ class LocalTypeTest(base.BaseTestCase): def test_reserve_provider_segment(self): segment = {api.NETWORK_TYPE: p_const.TYPE_LOCAL} - observed = self.driver.reserve_provider_segment(self.session, segment) + observed = self.driver.reserve_provider_segment(self.context, segment) self.assertEqual(segment, observed) def test_release_provider_segment(self): segment = {api.NETWORK_TYPE: p_const.TYPE_LOCAL} - observed = self.driver.reserve_provider_segment(self.session, segment) - self.driver.release_segment(self.session, observed) + observed = self.driver.reserve_provider_segment(self.context, segment) + self.driver.release_segment(self.context, observed) def test_allocate_tenant_segment(self): expected = {api.NETWORK_TYPE: p_const.TYPE_LOCAL} - observed = self.driver.allocate_tenant_segment(self.session) + observed = self.driver.allocate_tenant_segment(self.context) self.assertEqual(expected, observed) diff --git a/neutron/tests/unit/plugins/ml2/drivers/test_type_vlan.py b/neutron/tests/unit/plugins/ml2/drivers/test_type_vlan.py index 205b25e3b46..3ab5d3adeae 100644 --- a/neutron/tests/unit/plugins/ml2/drivers/test_type_vlan.py +++ b/neutron/tests/unit/plugins/ml2/drivers/test_type_vlan.py @@ -17,7 +17,7 @@ import mock from neutron_lib import exceptions as exc from testtools import matchers -import neutron.db.api as db +from neutron import context from neutron.db.models.plugins.ml2 import vlanallocation as vlan_alloc_model from neutron.plugins.common import constants as p_const from neutron.plugins.common import utils as plugin_utils @@ -49,7 +49,7 @@ class VlanTypeTest(testlib_api.SqlTestCase): NETWORK_VLAN_RANGES) self.driver = type_vlan.VlanTypeDriver() self.driver._sync_vlan_allocations() - self.session = db.get_session() + self.context = context.Context() self.driver.physnet_mtus = [] def test_parse_network_exception_handling(self): @@ -59,8 +59,9 @@ class VlanTypeTest(testlib_api.SqlTestCase): self.assertRaises(SystemExit, self.driver._parse_network_vlan_ranges) - def _get_allocation(self, session, segment): - return session.query(vlan_alloc_model.VlanAllocation).filter_by( + def _get_allocation(self, context, segment): + return context.session.query( + vlan_alloc_model.VlanAllocation).filter_by( physical_network=segment[api.PHYSICAL_NETWORK], vlan_id=segment[api.SEGMENTATION_ID]).first() @@ -129,17 +130,17 @@ class VlanTypeTest(testlib_api.SqlTestCase): segment[api.SEGMENTATION_ID] = vlan_min - 1 self.assertIsNone( - self._get_allocation(self.session, segment)) + self._get_allocation(self.context, segment)) segment[api.SEGMENTATION_ID] = vlan_max + 1 self.assertIsNone( - self._get_allocation(self.session, segment)) + self._get_allocation(self.context, segment)) segment[api.SEGMENTATION_ID] = vlan_min self.assertFalse( - self._get_allocation(self.session, segment).allocated) + self._get_allocation(self.context, segment).allocated) segment[api.SEGMENTATION_ID] = vlan_max self.assertFalse( - self._get_allocation(self.session, segment).allocated) + self._get_allocation(self.context, segment).allocated) check_in_ranges(self.network_vlan_ranges) self.driver.network_vlan_ranges = UPDATED_VLAN_RANGES @@ -150,37 +151,37 @@ class VlanTypeTest(testlib_api.SqlTestCase): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN, api.PHYSICAL_NETWORK: PROVIDER_NET, api.SEGMENTATION_ID: 101} - alloc = self._get_allocation(self.session, segment) + alloc = self._get_allocation(self.context, segment) self.assertIsNone(alloc) - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self._get_allocation(self.session, observed) + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self._get_allocation(self.context, observed) self.assertTrue(alloc.allocated) def test_reserve_provider_segment_already_allocated(self): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN, api.PHYSICAL_NETWORK: PROVIDER_NET, api.SEGMENTATION_ID: 101} - observed = self.driver.reserve_provider_segment(self.session, segment) + observed = self.driver.reserve_provider_segment(self.context, segment) self.assertRaises(exc.VlanIdInUse, self.driver.reserve_provider_segment, - self.session, + self.context, observed) def test_reserve_provider_segment_in_tenant_pools(self): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN, api.PHYSICAL_NETWORK: TENANT_NET, api.SEGMENTATION_ID: VLAN_MIN} - alloc = self._get_allocation(self.session, segment) + alloc = self._get_allocation(self.context, segment) self.assertFalse(alloc.allocated) - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self._get_allocation(self.session, observed) + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self._get_allocation(self.context, observed) self.assertTrue(alloc.allocated) def test_reserve_provider_segment_without_segmentation_id(self): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN, api.PHYSICAL_NETWORK: TENANT_NET} - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self._get_allocation(self.session, observed) + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self._get_allocation(self.context, observed) self.assertTrue(alloc.allocated) vlan_id = observed[api.SEGMENTATION_ID] self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) @@ -188,8 +189,8 @@ class VlanTypeTest(testlib_api.SqlTestCase): def test_reserve_provider_segment_without_physical_network(self): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN} - observed = self.driver.reserve_provider_segment(self.session, segment) - alloc = self._get_allocation(self.session, observed) + observed = self.driver.reserve_provider_segment(self.context, segment) + alloc = self._get_allocation(self.context, observed) self.assertTrue(alloc.allocated) vlan_id = observed[api.SEGMENTATION_ID] self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) @@ -198,11 +199,11 @@ class VlanTypeTest(testlib_api.SqlTestCase): def test_reserve_provider_segment_all_allocateds(self): for __ in range(VLAN_MIN, VLAN_MAX + 1): - self.driver.allocate_tenant_segment(self.session) + self.driver.allocate_tenant_segment(self.context) segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN} self.assertRaises(exc.NoNetworkAvailable, self.driver.reserve_provider_segment, - self.session, + self.context, segment) def test_get_mtu(self): @@ -228,8 +229,8 @@ class VlanTypeTest(testlib_api.SqlTestCase): def test_allocate_tenant_segment(self): for __ in range(VLAN_MIN, VLAN_MAX + 1): - segment = self.driver.allocate_tenant_segment(self.session) - alloc = self._get_allocation(self.session, segment) + segment = self.driver.allocate_tenant_segment(self.context) + alloc = self._get_allocation(self.context, segment) self.assertTrue(alloc.allocated) vlan_id = segment[api.SEGMENTATION_ID] self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) @@ -238,14 +239,14 @@ class VlanTypeTest(testlib_api.SqlTestCase): def test_allocate_tenant_segment_no_available(self): for __ in range(VLAN_MIN, VLAN_MAX + 1): - self.driver.allocate_tenant_segment(self.session) - segment = self.driver.allocate_tenant_segment(self.session) + self.driver.allocate_tenant_segment(self.context) + segment = self.driver.allocate_tenant_segment(self.context) self.assertIsNone(segment) def test_release_segment(self): - segment = self.driver.allocate_tenant_segment(self.session) - self.driver.release_segment(self.session, segment) - alloc = self._get_allocation(self.session, segment) + segment = self.driver.allocate_tenant_segment(self.context) + self.driver.release_segment(self.context, segment) + alloc = self._get_allocation(self.context, segment) self.assertFalse(alloc.allocated) def test_release_segment_unallocated(self): @@ -253,7 +254,7 @@ class VlanTypeTest(testlib_api.SqlTestCase): api.PHYSICAL_NETWORK: PROVIDER_NET, api.SEGMENTATION_ID: 101} with mock.patch.object(type_vlan.LOG, 'warning') as log_warn: - self.driver.release_segment(self.session, segment) + self.driver.release_segment(self.context, segment) log_warn.assert_called_once_with( "No vlan_id %(vlan_id)s found on physical network " "%(physical_network)s", diff --git a/neutron/tests/unit/plugins/ml2/test_plugin.py b/neutron/tests/unit/plugins/ml2/test_plugin.py index 2fc802f6380..3b82280567c 100644 --- a/neutron/tests/unit/plugins/ml2/test_plugin.py +++ b/neutron/tests/unit/plugins/ml2/test_plugin.py @@ -1842,7 +1842,7 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase): dynamic_segmentation_id = dynamic_segment[driver_api.SEGMENTATION_ID] self.assertGreater(dynamic_segmentation_id, 0) self.driver.type_manager.release_dynamic_segment( - self.context.session, dynamic_segment[driver_api.ID]) + self.context, dynamic_segment[driver_api.ID]) self.assertIsNone(segments_db.get_dynamic_segment( self.context.session, network_id, 'physnet1')) @@ -2009,7 +2009,7 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase): with mock.patch('neutron.plugins.ml2.managers.segments_db') as db: db.get_network_segments.return_value = (segment,) self.driver.type_manager.release_network_segments( - self.context.session, network_id) + self.context, network_id) log.error.assert_called_once_with( "Failed to release segment '%s' because "