Cesar77RR's picture
download
raw
66.4 kB
from eventlet import greenthread from neutron_lib.api.definitions import extra_dhcp_opt as edo_ext from neutron_lib.api.definitions import network as net_def from neutron_lib.api.definitions import port as port_def from neutron_lib.api.definitions import port_security as psec from neutron_lib.api.definitions import portbindings from neutron_lib.api.definitions import subnet as subnet_def from neutron_lib.api import validators from neutron_lib.callbacks import events from neutron_lib.callbacks import exceptions from neutron_lib.callbacks import registry from neutron_lib.callbacks import resources from neutron_lib import constants as const from neutron_lib import exceptions as exc from neutron_lib.exceptions import port_security as psec_exc from neutron_lib.plugins import constants as plugin_constants from neutron_lib.plugins import directory from neutron_lib.plugins.ml2 import api from oslo_config import cfg from oslo_db import exception as os_db_exception from oslo_log import helpers as log_helpers from oslo_log import log from oslo_serialization import jsonutils from oslo_utils import excutils from oslo_utils import importutils from oslo_utils import uuidutils import sqlalchemy from sqlalchemy.orm import exc as sa_exc from neutron._i18n import _ from neutron.agent import securitygroups_rpc as sg_rpc from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api from neutron.api.rpc.handlers import dhcp_rpc from neutron.api.rpc.handlers import dvr_rpc from neutron.api.rpc.handlers import metadata_rpc from neutron.api.rpc.handlers import resources_rpc from neutron.api.rpc.handlers import securitygroups_rpc from neutron.common import constants as n_const from neutron.common import rpc as n_rpc from neutron.common import topics from neutron.common import utils from neutron.db import _model_query as model_query from neutron.db import _resource_extend as resource_extend from neutron.db import _utils as db_utils from neutron.db import address_scope_db from neutron.db import agents_db from neutron.db import agentschedulers_db from neutron.db import allowedaddresspairs_db as addr_pair_db from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron.db import dvr_mac_db from neutron.db import external_net_db from neutron.db import extradhcpopt_db from neutron.db.models import securitygroup as sg_models from neutron.db import models_v2 from neutron.db import provisioning_blocks from neutron.db.quota import driver from neutron.db import securitygroups_rpc_base as sg_db_rpc from neutron.db import segments_db from neutron.db import subnet_service_type_db_models as service_type_db from neutron.db import vlantransparent_db from neutron.extensions import allowedaddresspairs as addr_pair from neutron.extensions import availability_zone as az_ext from neutron.extensions import netmtu_writable as mtu_ext from neutron.extensions import providernet as provider from neutron.extensions import vlantransparent from neutron.plugins.common import utils as p_utils from neutron.plugins.ml2.common import exceptions as ml2_exc from neutron.plugins.ml2 import config from neutron.plugins.ml2 import db from neutron.plugins.ml2 import driver_context from neutron.plugins.ml2.extensions import qos as qos_ext from neutron.plugins.ml2 import managers from neutron.plugins.ml2 import models from neutron.plugins.ml2 import ovo_rpc from neutron.plugins.ml2 import rpc from neutron.quota import resource_registry from neutron.services.qos import qos_consts from neutron.services.segments import plugin as segments_plugin LOG = log.getLogger(__name__) MAX_BIND_TRIES = 10 SERVICE_PLUGINS_REQUIRED_DRIVERS = {'qos': [qos_ext.QOS_EXT_DRIVER_ALIAS]} def _ml2_port_result_filter_hook(query, filters): values = (filters and filters.get(portbindings.HOST_ID, [])) if (not values): return query bind_criteria = models.PortBinding.host.in_(values) return query.filter(models_v2.Port.port_binding.has(bind_criteria)) @resource_extend.has_resource_extenders @registry.has_registry_receivers class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2, dvr_mac_db.DVRDbMixin, external_net_db.External_net_db_mixin, sg_db_rpc.SecurityGroupServerRpcMixin, agentschedulers_db.AZDhcpAgentSchedulerDbMixin, addr_pair_db.AllowedAddressPairsMixin, vlantransparent_db.Vlantransparent_db_mixin, extradhcpopt_db.ExtraDhcpOptMixin, address_scope_db.AddressScopeDbMixin, service_type_db.SubnetServiceTypeMixin, ): 'Implement the Neutron L2 abstractions using modules.\n\n Ml2Plugin is a Neutron plugin based on separately extensible sets\n of network types and mechanisms for connecting to networks of\n those types. The network types and mechanisms are implemented as\n drivers loaded via Python entry points. Networks can be made up of\n multiple segments (not yet fully implemented).\n ' __native_bulk_support = True __native_pagination_support = True __native_sorting_support = True _supported_extension_aliases = ['provider', 'external-net', 'binding', 'quotas', 'security-group', 'agent', 'dhcp_agent_scheduler', 'multi-provider', 'allowed-address-pairs', 'extra_dhcp_opt', 'subnet_allocation', 'net-mtu', 'net-mtu-writable', 'vlan-transparent', 'address-scope', 'availability_zone', 'network_availability_zone', 'default-subnetpools', 'subnet-service-types'] @property def supported_extension_aliases(self): if (not hasattr(self, '_aliases')): aliases = self._supported_extension_aliases[:] aliases += self.extension_manager.extension_aliases() sg_rpc.disable_security_group_extension_by_config(aliases) vlantransparent.disable_extension_by_config(aliases) self._aliases = aliases return self._aliases def __new__(cls, *args, **kwargs): model_query.register_hook(models_v2.Port, 'ml2_port_bindings', query_hook=None, filter_hook=None, result_filters=_ml2_port_result_filter_hook) return super(Ml2Plugin, cls).__new__(cls, *args, **kwargs) @resource_registry.tracked_resources(network=models_v2.Network, port=models_v2.Port, subnet=models_v2.Subnet, subnetpool=models_v2.SubnetPool, security_group=sg_models.SecurityGroup, security_group_rule=sg_models.SecurityGroupRule) def __init__(self): self.type_manager = managers.TypeManager() self.extension_manager = managers.ExtensionManager() self.mechanism_manager = managers.MechanismManager() super(Ml2Plugin, self).__init__() self.type_manager.initialize() self.extension_manager.initialize() self.mechanism_manager.initialize() self._setup_dhcp() self._start_rpc_notifiers() self.add_agent_status_check_worker(self.agent_health_check) self.add_workers(self.mechanism_manager.get_workers()) self._verify_service_plugins_requirements() LOG.info('Modular L2 Plugin initialization complete') def _setup_rpc(self): 'Initialize components to support agent communication.' self.endpoints = [rpc.RpcCallbacks(self.notifier, self.type_manager), securitygroups_rpc.SecurityGroupServerRpcCallback(), dvr_rpc.DVRServerRpcCallback(), dhcp_rpc.DhcpRpcCallback(), agents_db.AgentExtRpcCallback(), metadata_rpc.MetadataRpcCallback(), resources_rpc.ResourcesPullRpcCallback()] def _setup_dhcp(self): 'Initialize components to support DHCP.' self.network_scheduler = importutils.import_object(cfg.CONF.network_scheduler_driver) self.add_periodic_dhcp_agent_status_check() def _verify_service_plugins_requirements(self): for service_plugin in cfg.CONF.service_plugins: extension_drivers = SERVICE_PLUGINS_REQUIRED_DRIVERS.get(service_plugin, []) for extension_driver in extension_drivers: if (extension_driver not in self.extension_manager.names()): raise ml2_exc.ExtensionDriverNotFound(driver=extension_driver, service_plugin=service_plugin) @registry.receives(resources.PORT, [provisioning_blocks.PROVISIONING_COMPLETE]) def _port_provisioned(self, rtype, event, trigger, context, object_id, **kwargs): port_id = object_id port = db.get_port(context, port_id) if ((not port) or (not port.port_binding)): LOG.debug('Port %s was deleted so its status cannot be updated.', port_id) return if (port.port_binding.vif_type in (portbindings.VIF_TYPE_BINDING_FAILED, portbindings.VIF_TYPE_UNBOUND)): LOG.debug('Port %s cannot update to ACTIVE because it is not bound.', port_id) return elif provisioning_blocks.is_object_blocked(context, port_id, resources.PORT): LOG.debug('Port %s had new provisioning blocks added so it will not transition to active.', port_id) return self.update_port_status(context, port_id, const.PORT_STATUS_ACTIVE) @log_helpers.log_method_call def _start_rpc_notifiers(self): 'Initialize RPC notifiers for agents.' self.ovo_notifier = ovo_rpc.OVOServerRpcInterface() self.notifier = rpc.AgentNotifierApi(topics.AGENT) self.agent_notifiers[const.AGENT_TYPE_DHCP] = dhcp_rpc_agent_api.DhcpAgentNotifyAPI() @log_helpers.log_method_call def start_rpc_listeners(self): 'Start the RPC loop to let the plugin communicate with agents.' self._setup_rpc() self.topic = topics.PLUGIN self.conn = n_rpc.create_connection() self.conn.create_consumer(self.topic, self.endpoints, fanout=False) self.conn.create_consumer(topics.SERVER_RESOURCE_VERSIONS, [resources_rpc.ResourcesPushToServerRpcCallback()], fanout=True) self.conn.create_consumer(topics.REPORTS, [agents_db.AgentExtRpcCallback()], fanout=False) return self.conn.consume_in_threads() def start_rpc_state_reports_listener(self): self.conn_reports = n_rpc.create_connection() self.conn_reports.create_consumer(topics.REPORTS, [agents_db.AgentExtRpcCallback()], fanout=False) return self.conn_reports.consume_in_threads() def _filter_nets_provider(self, context, networks, filters): return [network for network in networks if self.type_manager.network_matches_filters(network, filters)] def _check_mac_update_allowed(self, orig_port, port, binding): unplugged_types = (portbindings.VIF_TYPE_BINDING_FAILED, portbindings.VIF_TYPE_UNBOUND) new_mac = port.get('mac_address') mac_change = ((new_mac is not None) and (orig_port['mac_address'] != new_mac)) if (mac_change and (binding.vif_type not in unplugged_types)): raise exc.PortBound(port_id=orig_port['id'], vif_type=binding.vif_type, old_mac=orig_port['mac_address'], new_mac=port['mac_address']) return mac_change def _process_port_binding(self, mech_context, attrs): plugin_context = mech_context._plugin_context binding = mech_context._binding port = mech_context.current port_id = port['id'] changes = False host = const.ATTR_NOT_SPECIFIED if (attrs and (portbindings.HOST_ID in attrs)): host = (attrs.get(portbindings.HOST_ID) or '') original_host = binding.host if (validators.is_attr_set(host) and (original_host != host)): binding.host = host changes = True vnic_type = (attrs and attrs.get(portbindings.VNIC_TYPE)) if (validators.is_attr_set(vnic_type) and (binding.vnic_type != vnic_type)): binding.vnic_type = vnic_type changes = True profile = None if (attrs and (portbindings.PROFILE in attrs)): profile = (attrs.get(portbindings.PROFILE) or {}) if (profile not in (None, const.ATTR_NOT_SPECIFIED, self._get_profile(binding))): binding.profile = jsonutils.dumps(profile) if (len(binding.profile) > models.BINDING_PROFILE_LEN): msg = _('binding:profile value too large') raise exc.InvalidInput(error_message=msg) changes = True if changes: binding.vif_type = portbindings.VIF_TYPE_UNBOUND binding.vif_details = '' db.clear_binding_levels(plugin_context, port_id, original_host) mech_context._clear_binding_levels() port['status'] = const.PORT_STATUS_DOWN super(Ml2Plugin, self).update_port(mech_context._plugin_context, port_id, {port_def.RESOURCE_NAME: {'status': const.PORT_STATUS_DOWN}}) if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): binding.vif_type = portbindings.VIF_TYPE_UNBOUND binding.vif_details = '' db.clear_binding_levels(plugin_context, port_id, original_host) mech_context._clear_binding_levels() binding.host = '' self._update_port_dict_binding(port, binding) binding.persist_state_to_session(plugin_context.session) return changes @db_api.retry_db_errors def _bind_port_if_needed(self, context, allow_notify=False, need_notify=False): if (not context.network.network_segments): LOG.debug('Network %s has no segments, skipping binding', context.network.current['id']) return context for count in range(1, (MAX_BIND_TRIES + 1)): if (count > 1): greenthread.sleep(0) LOG.info('Attempt %(count)s to bind port %(port)s', {'count': count, 'port': context.current['id']}) (bind_context, need_notify, try_again) = self._attempt_binding(context, need_notify) if ((count == MAX_BIND_TRIES) or (not try_again)): if self._should_bind_port(context): (context, need_notify, try_again) = self._commit_port_binding(context, bind_context, need_notify, try_again) else: context = bind_context if (not try_again): if (allow_notify and need_notify): self._notify_port_updated(context) return context LOG.error('Failed to commit binding results for %(port)s after %(max)s tries', {'port': context.current['id'], 'max': MAX_BIND_TRIES}) return context def _should_bind_port(self, context): return (context._binding.host and (context._binding.vif_type in (portbindings.VIF_TYPE_UNBOUND, portbindings.VIF_TYPE_BINDING_FAILED))) def _attempt_binding(self, context, need_notify): try_again = False if self._should_bind_port(context): bind_context = self._bind_port(context) if (bind_context.vif_type != portbindings.VIF_TYPE_BINDING_FAILED): need_notify = True else: try_again = True context = bind_context return (context, need_notify, try_again) def _bind_port(self, orig_context): port = orig_context.current orig_binding = orig_context._binding new_binding = models.PortBinding(host=orig_binding.host, vnic_type=orig_binding.vnic_type, profile=orig_binding.profile, vif_type=portbindings.VIF_TYPE_UNBOUND, vif_details='') self._update_port_dict_binding(port, new_binding) new_context = driver_context.PortContext(self, orig_context._plugin_context, port, orig_context.network.current, new_binding, None, original_port=orig_context.original) self.mechanism_manager.bind_port(new_context) return new_context def _commit_port_binding(self, orig_context, bind_context, need_notify, try_again): port_id = orig_context.current['id'] plugin_context = orig_context._plugin_context orig_binding = orig_context._binding new_binding = bind_context._binding registry.notify(resources.PORT, events.BEFORE_UPDATE, self, context=plugin_context, port=orig_context.current, original_port=orig_context.current, orig_binding=orig_binding, new_binding=new_binding) with db_api.context_manager.writer.using(plugin_context): try: port_db = self._get_port(plugin_context, port_id) cur_binding = port_db.port_binding except exc.PortNotFound: (port_db, cur_binding) = (None, None) if ((not port_db) or (not cur_binding)): LOG.debug('Port %s has been deleted concurrently', port_id) return (orig_context, False, False) oport = self._make_port_dict(port_db) port = self._make_port_dict(port_db) network = bind_context.network.current if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): cur_binding = db.get_distributed_port_binding_by_host(plugin_context, port_id, orig_binding.host) cur_context = driver_context.PortContext(self, plugin_context, port, network, cur_binding, None, original_port=oport) commit = ((cur_binding.vif_type in [portbindings.VIF_TYPE_UNBOUND, portbindings.VIF_TYPE_BINDING_FAILED]) and (orig_binding.host == cur_binding.host) and (orig_binding.vnic_type == cur_binding.vnic_type) and (orig_binding.profile == cur_binding.profile)) if commit: cur_binding.vif_type = new_binding.vif_type cur_binding.vif_details = new_binding.vif_details db.clear_binding_levels(plugin_context, port_id, cur_binding.host) db.set_binding_levels(plugin_context, bind_context._binding_levels) cur_context._binding = driver_context.InstanceSnapshot(cur_binding) cur_context._binding_levels = bind_context._binding_levels self._update_port_dict_binding(port, cur_binding) if (bind_context._binding_levels and bind_context._new_port_status): port_db.status = bind_context._new_port_status port['status'] = bind_context._new_port_status self.mechanism_manager.update_port_precommit(cur_context) if commit: kwargs = {'context': plugin_context, 'port': self._make_port_dict(port_db), 'mac_address_updated': False, 'original_port': oport} registry.notify(resources.PORT, events.AFTER_UPDATE, self, **kwargs) self.mechanism_manager.update_port_postcommit(cur_context) need_notify = True try_again = False else: try_again = True return (cur_context, need_notify, try_again) def _update_port_dict_binding(self, port, binding): port[portbindings.VNIC_TYPE] = binding.vnic_type port[portbindings.PROFILE] = self._get_profile(binding) if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): port[portbindings.HOST_ID] = '' port[portbindings.VIF_TYPE] = portbindings.VIF_TYPE_DISTRIBUTED port[portbindings.VIF_DETAILS] = {} else: port[portbindings.HOST_ID] = binding.host port[portbindings.VIF_TYPE] = binding.vif_type port[portbindings.VIF_DETAILS] = self._get_vif_details(binding) def _get_vif_details(self, binding): if binding.vif_details: try: return jsonutils.loads(binding.vif_details) except Exception: LOG.error("Serialized vif_details DB value '%(value)s' for port %(port)s is invalid", {'value': binding.vif_details, 'port': binding.port_id}) return {} def _get_profile(self, binding): if binding.profile: try: return jsonutils.loads(binding.profile) except Exception: LOG.error("Serialized profile DB value '%(value)s' for port %(port)s is invalid", {'value': binding.profile, 'port': binding.port_id}) return {} @staticmethod @resource_extend.extends([port_def.COLLECTION_NAME]) def _ml2_extend_port_dict_binding(port_res, port_db): plugin = directory.get_plugin() if port_db.port_binding: plugin._update_port_dict_binding(port_res, port_db.port_binding) @staticmethod @resource_extend.extends([net_def.COLLECTION_NAME]) def _ml2_md_extend_network_dict(result, netdb): plugin = directory.get_plugin() session = plugin._object_session_or_new_session(netdb) plugin.extension_manager.extend_network_dict(session, netdb, result) @staticmethod @resource_extend.extends([port_def.COLLECTION_NAME]) def _ml2_md_extend_port_dict(result, portdb): plugin = directory.get_plugin() session = plugin._object_session_or_new_session(portdb) plugin.extension_manager.extend_port_dict(session, portdb, result) @staticmethod @resource_extend.extends([subnet_def.COLLECTION_NAME]) def _ml2_md_extend_subnet_dict(result, subnetdb): plugin = directory.get_plugin() session = plugin._object_session_or_new_session(subnetdb) plugin.extension_manager.extend_subnet_dict(session, subnetdb, result) @staticmethod def _object_session_or_new_session(sql_obj): session = sqlalchemy.inspect(sql_obj).session if (not session): session = db_api.get_reader_session() return session def _notify_port_updated(self, mech_context): port = mech_context.current segment = mech_context.bottom_bound_segment if (not segment): network = mech_context.network.current LOG.debug('In _notify_port_updated(), no bound segment for port %(port_id)s on network %(network_id)s', {'port_id': port['id'], 'network_id': network['id']}) return self.notifier.port_update(mech_context._plugin_context, port, segment[api.NETWORK_TYPE], segment[api.SEGMENTATION_ID], segment[api.PHYSICAL_NETWORK]) def _delete_objects(self, context, resource, objects): delete_op = getattr(self, ('delete_%s' % resource)) for obj in objects: try: delete_op(context, obj['result']['id']) except KeyError: LOG.exception('Could not find %s to delete.', resource) except Exception: LOG.exception('Could not delete %(res)s %(id)s.', {'res': resource, 'id': obj['result']['id']}) def _create_bulk_ml2(self, resource, context, request_items): objects = [] collection = ('%ss' % resource) items = request_items[collection] obj_before_create = getattr(self, ('_before_create_%s' % resource)) for item in items: obj_before_create(context, item) with db_api.context_manager.writer.using(context): obj_creator = getattr(self, ('_create_%s_db' % resource)) for item in items: try: attrs = item[resource] (result, mech_context) = obj_creator(context, item) objects.append({'mech_context': mech_context, 'result': result, 'attributes': attrs}) except Exception as e: with excutils.save_and_reraise_exception(): utils.attach_exc_details(e, 'An exception occurred while creating the %(resource)s:%(item)s', {'resource': resource, 'item': item}) postcommit_op = getattr(self, ('_after_create_%s' % resource)) for obj in objects: try: postcommit_op(context, obj['result'], obj['mech_context']) except Exception: with excutils.save_and_reraise_exception(): resource_ids = [res['result']['id'] for res in objects] LOG.exception("ML2 _after_create_%(res)s failed for %(res)s: '%(failed_id)s'. Deleting %(res)ss %(resource_ids)s", {'res': resource, 'failed_id': obj['result']['id'], 'resource_ids': ', '.join(resource_ids)}) to_delete = [o for o in objects if (o != obj)] self._delete_objects(context, resource, to_delete) return objects def _get_network_mtu(self, network_db, validate=True): mtus = [] try: segments = network_db['segments'] except KeyError: segments = [network_db] for s in segments: segment_type = s.get('network_type') if (segment_type is None): continue try: type_driver = self.type_manager.drivers[segment_type].obj except KeyError: if (segment_type and s['segmentation_id']): LOG.warning('Failed to determine MTU for segment %(segment_type)s:%(segment_id)s; network %(network_id)s MTU calculation may be not accurate', {'segment_type': segment_type, 'segment_id': s['segmentation_id'], 'network_id': network_db['id']}) else: mtu = type_driver.get_mtu(s['physical_network']) if mtu: mtus.append(mtu) max_mtu = (min(mtus) if mtus else p_utils.get_deployment_physnet_mtu()) net_mtu = network_db.get('mtu') if validate: if (net_mtu and max_mtu and (max_mtu < net_mtu)): msg = (_('Requested MTU is too big, maximum is %d') % max_mtu) raise exc.InvalidInput(error_message=msg) return (net_mtu or max_mtu) def _before_create_network(self, context, network): net_data = network[net_def.RESOURCE_NAME] registry.notify(resources.NETWORK, events.BEFORE_CREATE, self, context=context, network=net_data) def _create_network_db(self, context, network): net_data = network[net_def.RESOURCE_NAME] tenant_id = net_data['tenant_id'] with db_api.context_manager.writer.using(context): net_db = self.create_network_db(context, network) net_data['id'] = net_db.id self.type_manager.create_network_segments(context, net_data, tenant_id) net_db.mtu = self._get_network_mtu(net_db) result = self._make_network_dict(net_db, process_extensions=False, context=context) self.extension_manager.process_create_network(context, {k: v for (k, v) in net_data.items() if (k != 'id')}, result) self._process_l3_create(context, result, net_data) self.type_manager.extend_network_dict_provider(context, result) if utils.is_extension_supported(self, 'vlan-transparent'): vlt = vlantransparent.get_vlan_transparent(net_data) net_db['vlan_transparent'] = vlt result['vlan_transparent'] = vlt if (az_ext.AZ_HINTS in net_data): self.validate_availability_zones(context, 'network', net_data[az_ext.AZ_HINTS]) az_hints = az_ext.convert_az_list_to_string(net_data[az_ext.AZ_HINTS]) net_db[az_ext.AZ_HINTS] = az_hints result[az_ext.AZ_HINTS] = az_hints registry.notify(resources.NETWORK, events.PRECOMMIT_CREATE, self, context=context, request=net_data, network=result) resource_extend.apply_funcs('networks', result, net_db) mech_context = driver_context.NetworkContext(self, context, result) self.mechanism_manager.create_network_precommit(mech_context) return (result, mech_context) @utils.transaction_guard @db_api.retry_if_session_inactive() def create_network(self, context, network): self._before_create_network(context, network) (result, mech_context) = self._create_network_db(context, network) return self._after_create_network(context, result, mech_context) def _after_create_network(self, context, result, mech_context): kwargs = {'context': context, 'network': result} registry.notify(resources.NETWORK, events.AFTER_CREATE, self, **kwargs) try: self.mechanism_manager.create_network_postcommit(mech_context) except ml2_exc.MechanismDriverError: with excutils.save_and_reraise_exception(): LOG.error("mechanism_manager.create_network_postcommit failed, deleting network '%s'", result['id']) self.delete_network(context, result['id']) return result @utils.transaction_guard @db_api.retry_if_session_inactive() def create_network_bulk(self, context, networks): objects = self._create_bulk_ml2(net_def.RESOURCE_NAME, context, networks) return [obj['result'] for obj in objects] @utils.transaction_guard @db_api.retry_if_session_inactive() def update_network(self, context, id, network): net_data = network[net_def.RESOURCE_NAME] provider._raise_if_updates_provider_attributes(net_data) need_network_update_notify = False with db_api.context_manager.writer.using(context): original_network = super(Ml2Plugin, self).get_network(context, id) updated_network = super(Ml2Plugin, self).update_network(context, id, network) self.extension_manager.process_update_network(context, net_data, updated_network) self._process_l3_update(context, updated_network, net_data) db_network = self._get_network(context, id) context.session.expire(db_network) if ((mtu_ext.MTU in net_data) or (db_network.mtu is None)): db_network.mtu = self._get_network_mtu(db_network, validate=False) need_network_update_notify = True updated_network = self._make_network_dict(db_network, context=context) self.type_manager.extend_network_dict_provider(context, updated_network) kwargs = {'context': context, 'network': updated_network, 'original_network': original_network, 'request': net_data} registry.notify(resources.NETWORK, events.PRECOMMIT_UPDATE, self, **kwargs) need_network_update_notify |= ((qos_consts.QOS_POLICY_ID in net_data) and (original_network[qos_consts.QOS_POLICY_ID] != updated_network[qos_consts.QOS_POLICY_ID])) mech_context = driver_context.NetworkContext(self, context, updated_network, original_network=original_network) self.mechanism_manager.update_network_precommit(mech_context) kwargs = {'context': context, 'network': updated_network, 'original_network': original_network} registry.notify(resources.NETWORK, events.AFTER_UPDATE, self, **kwargs) self.mechanism_manager.update_network_postcommit(mech_context) if need_network_update_notify: self.notifier.network_update(context, updated_network) return updated_network @db_api.retry_if_session_inactive() def get_network(self, context, id, fields=None): with db_api.context_manager.writer.using(context): net_db = self._get_network(context, id) if (net_db.mtu is None): net_db.mtu = self._get_network_mtu(net_db, validate=False) net_data = self._make_network_dict(net_db, context=context) self.type_manager.extend_network_dict_provider(context, net_data) return db_utils.resource_fields(net_data, fields) @db_api.retry_if_session_inactive() def get_networks(self, context, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False): with db_api.context_manager.writer.using(context): nets_db = super(Ml2Plugin, self)._get_networks(context, filters, None, sorts, limit, marker, page_reverse) net_data = [] for net in nets_db: if (net.mtu is None): net.mtu = self._get_network_mtu(net, validate=False) net_data.append(self._make_network_dict(net, context=context)) self.type_manager.extend_networks_dict_provider(context, net_data) nets = self._filter_nets_provider(context, net_data, filters) return [db_utils.resource_fields(net, fields) for net in nets] def get_network_contexts(self, context, network_ids): 'Return a map of network_id to NetworkContext for network_ids.' net_filters = {'id': list(set(network_ids))} nets_by_netid = {n['id']: n for n in self.get_networks(context, filters=net_filters)} segments_by_netid = segments_db.get_networks_segments(context, list(nets_by_netid.keys())) netctxs_by_netid = {net_id: driver_context.NetworkContext(self, context, nets_by_netid[net_id], segments=segments_by_netid[net_id]) for net_id in nets_by_netid.keys()} return netctxs_by_netid @utils.transaction_guard def delete_network(self, context, id): return super(Ml2Plugin, self).delete_network(context, id) @registry.receives(resources.NETWORK, [events.PRECOMMIT_DELETE]) def _network_delete_precommit_handler(self, rtype, event, trigger, context, network_id, **kwargs): network = self.get_network(context, network_id) mech_context = driver_context.NetworkContext(self, context, network) setattr(context, '_mech_context', mech_context) self.mechanism_manager.delete_network_precommit(mech_context) @registry.receives(resources.NETWORK, [events.AFTER_DELETE]) def _network_delete_after_delete_handler(self, rtype, event, trigger, context, network, **kwargs): try: self.mechanism_manager.delete_network_postcommit(context._mech_context) except ml2_exc.MechanismDriverError: LOG.error('mechanism_manager.delete_network_postcommit failed') self.notifier.network_delete(context, network['id']) def _before_create_subnet(self, context, subnet): pass def _create_subnet_db(self, context, subnet): with db_api.context_manager.writer.using(context): (result, net_db, ipam_sub) = self._create_subnet_precommit(context, subnet) if (net_db['mtu'] is None): net_db['mtu'] = self._get_network_mtu(net_db, validate=False) self.extension_manager.process_create_subnet(context, subnet[subnet_def.RESOURCE_NAME], result) network = self._make_network_dict(net_db, context=context) self.type_manager.extend_network_dict_provider(context, network) mech_context = driver_context.SubnetContext(self, context, result, network) self.mechanism_manager.create_subnet_precommit(mech_context) self._create_subnet_postcommit(context, result, net_db, ipam_sub) return (result, mech_context) @utils.transaction_guard @db_api.retry_if_session_inactive() def create_subnet(self, context, subnet): self._before_create_subnet(context, subnet) (result, mech_context) = self._create_subnet_db(context, subnet) return self._after_create_subnet(context, result, mech_context) def _after_create_subnet(self, context, result, mech_context): kwargs = {'context': context, 'subnet': result} registry.notify(resources.SUBNET, events.AFTER_CREATE, self, **kwargs) try: self.mechanism_manager.create_subnet_postcommit(mech_context) except ml2_exc.MechanismDriverError: with excutils.save_and_reraise_exception(): LOG.error("mechanism_manager.create_subnet_postcommit failed, deleting subnet '%s'", result['id']) self.delete_subnet(context, result['id']) return result @utils.transaction_guard @db_api.retry_if_session_inactive() def create_subnet_bulk(self, context, subnets): objects = self._create_bulk_ml2(subnet_def.RESOURCE_NAME, context, subnets) return [obj['result'] for obj in objects] @utils.transaction_guard @db_api.retry_if_session_inactive() def update_subnet(self, context, id, subnet): with db_api.context_manager.writer.using(context): (updated_subnet, original_subnet) = self._update_subnet_precommit(context, id, subnet) self.extension_manager.process_update_subnet(context, subnet[subnet_def.RESOURCE_NAME], updated_subnet) updated_subnet = self.get_subnet(context, id) mech_context = driver_context.SubnetContext(self, context, updated_subnet, network=None, original_subnet=original_subnet) self.mechanism_manager.update_subnet_precommit(mech_context) self._update_subnet_postcommit(context, original_subnet, updated_subnet) self.mechanism_manager.update_subnet_postcommit(mech_context) return updated_subnet @utils.transaction_guard def delete_subnet(self, context, id): return super(Ml2Plugin, self).delete_subnet(context, id) @registry.receives(resources.SUBNET, [events.PRECOMMIT_DELETE]) def _subnet_delete_precommit_handler(self, rtype, event, trigger, context, subnet_id, **kwargs): record = self._get_subnet(context, subnet_id) subnet = self._make_subnet_dict(record, context=context) network = self.get_network(context, subnet['network_id']) mech_context = driver_context.SubnetContext(self, context, subnet, network) setattr(context, '_mech_context', mech_context) self.mechanism_manager.delete_subnet_precommit(mech_context) @registry.receives(resources.SUBNET, [events.AFTER_DELETE]) def _subnet_delete_after_delete_handler(self, rtype, event, trigger, context, subnet, **kwargs): try: self.mechanism_manager.delete_subnet_postcommit(context._mech_context) except ml2_exc.MechanismDriverError: LOG.error('mechanism_manager.delete_subnet_postcommit failed') def _portsec_ext_port_create_processing(self, context, port_data, port): attrs = port[port_def.RESOURCE_NAME] port_security = ((port_data.get(psec.PORTSECURITY) is None) or port_data[psec.PORTSECURITY]) if self._check_update_has_allowed_address_pairs(port): if (not port_security): raise addr_pair.AddressPairAndPortSecurityRequired() else: attrs[addr_pair.ADDRESS_PAIRS] = [] if port_security: self._ensure_default_security_group_on_port(context, port) elif self._check_update_has_security_groups(port): raise psec_exc.PortSecurityAndIPRequiredForSecurityGroups() def _setup_dhcp_agent_provisioning_component(self, context, port): subnet_ids = [f['subnet_id'] for f in port['fixed_ips']] if (db.is_dhcp_active_on_any_subnet(context, subnet_ids) and len(self.get_dhcp_agents_hosting_networks(context, [port['network_id']]))): provisioning_blocks.add_provisioning_component(context, port['id'], resources.PORT, provisioning_blocks.DHCP_ENTITY) else: provisioning_blocks.remove_provisioning_component(context, port['id'], resources.PORT, provisioning_blocks.DHCP_ENTITY) def _before_create_port(self, context, port): attrs = port[port_def.RESOURCE_NAME] if (not attrs.get('status')): attrs['status'] = const.PORT_STATUS_DOWN registry.notify(resources.PORT, events.BEFORE_CREATE, self, context=context, port=attrs) self._ensure_default_security_group(context, attrs['tenant_id']) def _create_port_db(self, context, port): attrs = port[port_def.RESOURCE_NAME] with db_api.context_manager.writer.using(context): dhcp_opts = attrs.get(edo_ext.EXTRADHCPOPTS, []) port_db = self.create_port_db(context, port) result = self._make_port_dict(port_db, process_extensions=False) self.extension_manager.process_create_port(context, attrs, result) self._portsec_ext_port_create_processing(context, result, port) sgids = self._get_security_groups_on_port(context, port) self._process_port_create_security_group(context, result, sgids) network = self.get_network(context, result['network_id']) binding = db.add_port_binding(context, result['id']) mech_context = driver_context.PortContext(self, context, result, network, binding, None) self._process_port_binding(mech_context, attrs) result[addr_pair.ADDRESS_PAIRS] = self._process_create_allowed_address_pairs(context, result, attrs.get(addr_pair.ADDRESS_PAIRS)) self._process_port_create_extra_dhcp_opts(context, result, dhcp_opts) kwargs = {'context': context, 'port': result} registry.notify(resources.PORT, events.PRECOMMIT_CREATE, self, **kwargs) self.mechanism_manager.create_port_precommit(mech_context) self._setup_dhcp_agent_provisioning_component(context, result) resource_extend.apply_funcs('ports', result, port_db) return (result, mech_context) @utils.transaction_guard @db_api.retry_if_session_inactive() def create_port(self, context, port): self._before_create_port(context, port) (result, mech_context) = self._create_port_db(context, port) return self._after_create_port(context, result, mech_context) def _after_create_port(self, context, result, mech_context): kwargs = {'context': context, 'port': result} registry.notify(resources.PORT, events.AFTER_CREATE, self, **kwargs) try: self.mechanism_manager.create_port_postcommit(mech_context) except ml2_exc.MechanismDriverError: with excutils.save_and_reraise_exception(): LOG.error("mechanism_manager.create_port_postcommit failed, deleting port '%s'", result['id']) self.delete_port(context, result['id'], l3_port_check=False) try: bound_context = self._bind_port_if_needed(mech_context) except ml2_exc.MechanismDriverError: with excutils.save_and_reraise_exception(): LOG.error("_bind_port_if_needed failed, deleting port '%s'", result['id']) self.delete_port(context, result['id'], l3_port_check=False) return bound_context.current @utils.transaction_guard @db_api.retry_if_session_inactive() def create_port_bulk(self, context, ports): objects = self._create_bulk_ml2(port_def.RESOURCE_NAME, context, ports) return [obj['result'] for obj in objects] def _portsec_ext_port_update_processing(self, updated_port, context, port, id): port_security = ((updated_port.get(psec.PORTSECURITY) is None) or updated_port[psec.PORTSECURITY]) if port_security: return if self._check_update_has_allowed_address_pairs(port): raise addr_pair.AddressPairAndPortSecurityRequired() elif (not self._check_update_deletes_allowed_address_pairs(port)): updated_port[addr_pair.ADDRESS_PAIRS] = self.get_allowed_address_pairs(context, id) if updated_port[addr_pair.ADDRESS_PAIRS]: raise addr_pair.AddressPairAndPortSecurityRequired() if self._check_update_has_security_groups(port): raise psec_exc.PortSecurityAndIPRequiredForSecurityGroups() elif (not self._check_update_deletes_security_groups(port)): if (not utils.is_extension_supported(self, 'security-group')): return filters = {'port_id': [id]} security_groups = super(Ml2Plugin, self)._get_port_security_group_bindings(context, filters) if security_groups: raise psec_exc.PortSecurityPortHasSecurityGroup() @utils.transaction_guard @db_api.retry_if_session_inactive() def update_port(self, context, id, port): attrs = port[port_def.RESOURCE_NAME] need_port_update_notify = False bound_mech_contexts = [] original_port = self.get_port(context, id) registry.notify(resources.PORT, events.BEFORE_UPDATE, self, context=context, port=attrs, original_port=original_port) with db_api.context_manager.writer.using(context): port_db = self._get_port(context, id) binding = port_db.port_binding if (not binding): raise exc.PortNotFound(port_id=id) mac_address_updated = self._check_mac_update_allowed(port_db, attrs, binding) need_port_update_notify |= mac_address_updated original_port = self._make_port_dict(port_db) updated_port = super(Ml2Plugin, self).update_port(context, id, port) self.extension_manager.process_update_port(context, attrs, updated_port) self._portsec_ext_port_update_processing(updated_port, context, port, id) if ((psec.PORTSECURITY in attrs) and (original_port[psec.PORTSECURITY] != updated_port[psec.PORTSECURITY])): need_port_update_notify = True if ((qos_consts.QOS_POLICY_ID in attrs) and (original_port[qos_consts.QOS_POLICY_ID] != updated_port[qos_consts.QOS_POLICY_ID])): need_port_update_notify = True if (addr_pair.ADDRESS_PAIRS in attrs): need_port_update_notify |= self.update_address_pairs_on_port(context, id, port, original_port, updated_port) need_port_update_notify |= self.update_security_group_on_port(context, id, port, original_port, updated_port) network = self.get_network(context, original_port['network_id']) need_port_update_notify |= self._update_extra_dhcp_opts_on_port(context, id, port, updated_port) levels = db.get_binding_levels(context, id, binding.host) context.session.expire(port_db) updated_port.update(self._make_port_dict(port_db)) mech_context = driver_context.PortContext(self, context, updated_port, network, binding, levels, original_port=original_port) need_port_update_notify |= self._process_port_binding(mech_context, attrs) kwargs = {'context': context, 'port': updated_port, 'original_port': original_port} registry.notify(resources.PORT, events.PRECOMMIT_UPDATE, self, **kwargs) if (port_db['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): dist_binding_list = db.get_distributed_port_bindings(context, id) for dist_binding in dist_binding_list: levels = db.get_binding_levels(context, id, dist_binding.host) dist_mech_context = driver_context.PortContext(self, context, updated_port, network, dist_binding, levels, original_port=original_port) self.mechanism_manager.update_port_precommit(dist_mech_context) bound_mech_contexts.append(dist_mech_context) else: self.mechanism_manager.update_port_precommit(mech_context) if any(((updated_port[k] != original_port[k]) for k in ('fixed_ips', 'mac_address'))): self._setup_dhcp_agent_provisioning_component(context, updated_port) bound_mech_contexts.append(mech_context) kwargs = {'context': context, 'port': updated_port, 'mac_address_updated': mac_address_updated, 'original_port': original_port} registry.notify(resources.PORT, events.AFTER_UPDATE, self, **kwargs) try: for mech_context in bound_mech_contexts: self.mechanism_manager.update_port_postcommit(mech_context) except ml2_exc.MechanismDriverError: LOG.error('mechanism_manager.update_port_postcommit failed for port %s', id) self.check_and_notify_security_group_member_changed(context, original_port, updated_port) need_port_update_notify |= self.is_security_group_member_updated(context, original_port, updated_port) if (original_port['admin_state_up'] != updated_port['admin_state_up']): need_port_update_notify = True if (original_port['status'] != updated_port['status']): need_port_update_notify = True bound_context = self._bind_port_if_needed(mech_context, allow_notify=True, need_notify=need_port_update_notify) return bound_context.current def _process_distributed_port_binding(self, mech_context, context, attrs): plugin_context = mech_context._plugin_context binding = mech_context._binding port = mech_context.current port_id = port['id'] if (binding.vif_type != portbindings.VIF_TYPE_UNBOUND): binding.vif_details = '' binding.vif_type = portbindings.VIF_TYPE_UNBOUND if binding.host: db.clear_binding_levels(plugin_context, port_id, binding.host) binding.host = '' self._update_port_dict_binding(port, binding) binding.host = (attrs and attrs.get(portbindings.HOST_ID)) binding.router_id = (attrs and attrs.get('device_id')) binding.persist_state_to_session(plugin_context.session) @utils.transaction_guard @db_api.retry_if_session_inactive() def update_distributed_port_binding(self, context, id, port): attrs = port[port_def.RESOURCE_NAME] host = (attrs and attrs.get(portbindings.HOST_ID)) host_set = validators.is_attr_set(host) if (not host_set): LOG.error('No Host supplied to bind DVR Port %s', id) return binding = db.get_distributed_port_binding_by_host(context, id, host) device_id = (attrs and attrs.get('device_id')) router_id = (binding and binding.get('router_id')) update_required = ((not binding) or (binding.vif_type == portbindings.VIF_TYPE_BINDING_FAILED) or (router_id != device_id)) if update_required: try: with db_api.context_manager.writer.using(context): orig_port = self.get_port(context, id) if (not binding): binding = db.ensure_distributed_port_binding(context, id, host, router_id=device_id) network = self.get_network(context, orig_port['network_id']) levels = db.get_binding_levels(context, id, host) mech_context = driver_context.PortContext(self, context, orig_port, network, binding, levels, original_port=orig_port) self._process_distributed_port_binding(mech_context, context, attrs) except (os_db_exception.DBReferenceError, exc.PortNotFound): LOG.debug('DVR Port %s has been deleted concurrently', id) return self._bind_port_if_needed(mech_context) def _pre_delete_port(self, context, port_id, port_check): 'Do some preliminary operations before deleting the port.' LOG.debug('Deleting port %s', port_id) try: kwargs = {'context': context, 'port_id': port_id, 'port_check': port_check} registry.notify(resources.PORT, events.BEFORE_DELETE, self, **kwargs) except exceptions.CallbackFailure as e: if (len(e.errors) == 1): raise e.errors[0].error raise exc.ServicePortInUse(port_id=port_id, reason=e) @utils.transaction_guard @db_api.retry_if_session_inactive() def delete_port(self, context, id, l3_port_check=True): self._pre_delete_port(context, id, l3_port_check) router_ids = [] l3plugin = directory.get_plugin(plugin_constants.L3) with db_api.context_manager.writer.using(context): try: port_db = self._get_port(context, id) binding = port_db.port_binding except exc.PortNotFound: LOG.debug("The port '%s' was deleted", id) return port = self._make_port_dict(port_db) network = self.get_network(context, port['network_id']) bound_mech_contexts = [] device_owner = port['device_owner'] if (device_owner == const.DEVICE_OWNER_DVR_INTERFACE): bindings = db.get_distributed_port_bindings(context, id) for bind in bindings: levels = db.get_binding_levels(context, id, bind.host) mech_context = driver_context.PortContext(self, context, port, network, bind, levels) self.mechanism_manager.delete_port_precommit(mech_context) bound_mech_contexts.append(mech_context) else: levels = db.get_binding_levels(context, id, binding.host) mech_context = driver_context.PortContext(self, context, port, network, binding, levels) self.mechanism_manager.delete_port_precommit(mech_context) bound_mech_contexts.append(mech_context) if l3plugin: router_ids = l3plugin.disassociate_floatingips(context, id, do_notify=False) LOG.debug('Calling delete_port for %(port_id)s owned by %(owner)s', {'port_id': id, 'owner': device_owner}) super(Ml2Plugin, self).delete_port(context, id) self._post_delete_port(context, port, router_ids, bound_mech_contexts) def _post_delete_port(self, context, port, router_ids, bound_mech_contexts): kwargs = {'context': context, 'port': port, 'router_ids': router_ids} registry.notify(resources.PORT, events.AFTER_DELETE, self, **kwargs) try: for mech_context in bound_mech_contexts: self.mechanism_manager.delete_port_postcommit(mech_context) except ml2_exc.MechanismDriverError: LOG.error('mechanism_manager.delete_port_postcommit failed for port %s', port['id']) self.notifier.port_delete(context, port['id']) @utils.transaction_guard @db_api.retry_if_session_inactive(context_var_name='plugin_context') def get_bound_port_context(self, plugin_context, port_id, host=None, cached_networks=None): with db_api.context_manager.writer.using(plugin_context) as session: try: port_db = session.query(models_v2.Port).enable_eagerloads(False).filter(models_v2.Port.id.startswith(port_id)).one() except sa_exc.NoResultFound: LOG.info('No ports have port_id starting with %s', port_id) return except sa_exc.MultipleResultsFound: LOG.error('Multiple ports have port_id starting with %s', port_id) return port = self._make_port_dict(port_db) network = (cached_networks or {}).get(port['network_id']) if (not network): network = self.get_network(plugin_context, port['network_id']) if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): binding = db.get_distributed_port_binding_by_host(plugin_context, port['id'], host) if (not binding): LOG.error('Binding info for DVR port %s not found', port_id) return None levels = db.get_binding_levels(plugin_context, port_db.id, host) port_context = driver_context.PortContext(self, plugin_context, port, network, binding, levels) else: binding = port_db.port_binding if (not binding): LOG.info('Binding info for port %s was not found, it might have been deleted already.', port_id) return levels = db.get_binding_levels(plugin_context, port_db.id, port_db.port_binding.host) port_context = driver_context.PortContext(self, plugin_context, port, network, binding, levels) return self._bind_port_if_needed(port_context) @utils.transaction_guard @db_api.retry_if_session_inactive(context_var_name='plugin_context') def get_bound_ports_contexts(self, plugin_context, dev_ids, host=None): result = {} with db_api.context_manager.writer.using(plugin_context): dev_to_full_pids = db.partial_port_ids_to_full_ids(plugin_context, dev_ids) port_dbs_by_id = db.get_port_db_objects(plugin_context, dev_to_full_pids.values()) netctxs_by_netid = self.get_network_contexts(plugin_context, {p.network_id for p in port_dbs_by_id.values()}) for dev_id in dev_ids: port_id = dev_to_full_pids.get(dev_id) port_db = port_dbs_by_id.get(port_id) if ((not port_id) or (not port_db) or (port_db.network_id not in netctxs_by_netid)): result[dev_id] = None continue port = self._make_port_dict(port_db) if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): binding = db.get_distributed_port_binding_by_host(plugin_context, port['id'], host) bindlevelhost_match = host else: binding = port_db.port_binding bindlevelhost_match = (binding.host if binding else None) if (not binding): LOG.info('Binding info for port %s was not found, it might have been deleted already.', port_id) result[dev_id] = None continue levels = [l for l in port_db.binding_levels if (l.host == bindlevelhost_match)] levels = sorted(levels, key=(lambda l: l.level)) network_ctx = netctxs_by_netid.get(port_db.network_id) port_context = driver_context.PortContext(self, plugin_context, port, network_ctx, binding, levels) result[dev_id] = port_context return {d: (self._bind_port_if_needed(pctx) if pctx else None) for (d, pctx) in result.items()} def update_port_status(self, context, port_id, status, host=None, network=None): "\n Returns port_id (non-truncated uuid) if the port exists.\n Otherwise returns None.\n 'network' is deprecated and has no effect\n " full = db.partial_port_ids_to_full_ids(context, [port_id]) if (port_id not in full): return None port_id = full[port_id] return self.update_port_statuses(context, {port_id: status}, host)[port_id] @utils.transaction_guard @db_api.retry_if_session_inactive() def update_port_statuses(self, context, port_id_to_status, host=None): result = {} port_ids = port_id_to_status.keys() port_dbs_by_id = db.get_port_db_objects(context, port_ids) for (port_id, status) in port_id_to_status.items(): if (not port_dbs_by_id.get(port_id)): LOG.debug('Port %(port)s update to %(val)s by agent not found', {'port': port_id, 'val': status}) result[port_id] = None continue result[port_id] = self._safe_update_individual_port_db_status(context, port_dbs_by_id[port_id], status, host) return result def _safe_update_individual_port_db_status(self, context, port, status, host): port_id = port.id try: return self._update_individual_port_db_status(context, port, status, host) except Exception: with excutils.save_and_reraise_exception() as ectx: ectx.reraise = bool(db.get_port(context, port_id)) def _update_individual_port_db_status(self, context, port, status, host): updated = False network = None port_id = port.id if (((port.status != status) and (port['device_owner'] != const.DEVICE_OWNER_DVR_INTERFACE)) or (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE)): attr = {'id': port.id, portbindings.HOST_ID: host, 'status': status} registry.notify(resources.PORT, events.BEFORE_UPDATE, self, original_port=port, context=context, port=attr) with db_api.context_manager.writer.using(context): context.session.add(port) if ((port.status != status) and (port['device_owner'] != const.DEVICE_OWNER_DVR_INTERFACE)): original_port = self._make_port_dict(port) port.status = status context.session.flush() updated_port = self._make_port_dict(port) levels = db.get_binding_levels(context, port.id, port.port_binding.host) mech_context = driver_context.PortContext(self, context, updated_port, network, port.port_binding, levels, original_port=original_port) self.mechanism_manager.update_port_precommit(mech_context) updated = True elif (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): binding = db.get_distributed_port_binding_by_host(context, port['id'], host) if (not binding): return if (binding.status != status): binding.status = status updated = True if (updated and (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE)): with db_api.context_manager.writer.using(context): port = db.get_port(context, port_id) if (not port): LOG.warning('Port %s not found during update', port_id) return original_port = self._make_port_dict(port) network = (network or self.get_network(context, original_port['network_id'])) port.status = db.generate_distributed_port_status(context, port['id']) updated_port = self._make_port_dict(port) levels = db.get_binding_levels(context, port_id, host) mech_context = driver_context.PortContext(self, context, updated_port, network, binding, levels, original_port=original_port) self.mechanism_manager.update_port_precommit(mech_context) if updated: self.mechanism_manager.update_port_postcommit(mech_context) kwargs = {'context': context, 'port': mech_context.current, 'original_port': original_port} if (status == const.PORT_STATUS_ACTIVE): kwargs['update_device_up'] = True registry.notify(resources.PORT, events.AFTER_UPDATE, self, **kwargs) if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): db.delete_distributed_port_binding_if_stale(context, binding) return port['id'] @db_api.retry_if_session_inactive() def port_bound_to_host(self, context, port_id, host): if (not host): return port = db.get_port(context, port_id) if (not port): LOG.debug('No Port match for: %s', port_id) return if (port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE): bindings = db.get_distributed_port_bindings(context, port_id) for b in bindings: if (b.host == host): return port LOG.debug('No binding found for DVR port %s', port['id']) return else: port_host = db.get_port_binding_host(context, port_id) return (port if (port_host == host) else None) @db_api.retry_if_session_inactive() def get_ports_from_devices(self, context, devices): port_ids_to_devices = dict(((self._device_to_port_id(context, device), device) for device in devices)) port_ids = list(port_ids_to_devices.keys()) ports = db.get_ports_and_sgs(context, port_ids) for port in ports: port_id = next((port_id for port_id in port_ids if port['id'].startswith(port_id)), None) port['device'] = port_ids_to_devices.get(port_id) return ports @staticmethod def _device_to_port_id(context, device): for prefix in n_const.INTERFACE_PREFIXES: if device.startswith(prefix): return device[len(prefix):] if (not uuidutils.is_uuid_like(device)): port = db.get_port_from_device_mac(context, device) if port: return port.id return device def filter_hosts_with_network_access(self, context, network_id, candidate_hosts): segments = segments_db.get_network_segments(context, network_id) return self.mechanism_manager.filter_hosts_with_segment_access(context, segments, candidate_hosts, self.get_agents) def check_segment_for_agent(self, segment, agent): for mech_driver in self.mechanism_manager.ordered_mech_drivers: driver_agent_type = getattr(mech_driver.obj, 'agent_type', None) if (driver_agent_type and (driver_agent_type == agent['agent_type'])): if mech_driver.obj.check_segment_for_agent(segment, agent): return True return False @registry.receives(resources.SEGMENT, (events.PRECOMMIT_CREATE, events.PRECOMMIT_DELETE, events.AFTER_CREATE, events.AFTER_DELETE)) def _handle_segment_change(self, rtype, event, trigger, context, segment): if ((event == events.PRECOMMIT_CREATE) and (not isinstance(trigger, segments_plugin.Plugin))): return network_id = segment.get('network_id') if (event == events.PRECOMMIT_CREATE): updated_segment = self.type_manager.reserve_network_segment(context, segment) segment[api.SEGMENTATION_ID] = updated_segment[api.SEGMENTATION_ID] elif (event == events.PRECOMMIT_DELETE): self.type_manager.release_network_segment(context, segment) network_db = self._get_network(context, network_id) network_db.mtu = self._get_network_mtu(network_db) network_db.save(session=context.session) try: self._notify_mechanism_driver_for_segment_change(event, context, network_id) except ml2_exc.MechanismDriverError: with excutils.save_and_reraise_exception(): LOG.error("mechanism_manager error occurred when handle event %(event)s for segment '%(segment)s'", {'event': event, 'segment': segment['id']}) def _notify_mechanism_driver_for_segment_change(self, event, context, network_id): network_with_segments = self.get_network(context, network_id) mech_context = driver_context.NetworkContext(self, context, network_with_segments, original_network=network_with_segments) if ((event == events.PRECOMMIT_CREATE) or (event == events.PRECOMMIT_DELETE)): self.mechanism_manager.update_network_precommit(mech_context) elif ((event == events.AFTER_CREATE) or (event == events.AFTER_DELETE)): self.mechanism_manager.update_network_postcommit(mech_context)
from eventlet import greenthread
from neutron_lib.api.definitions import extra_dhcp_opt as edo_ext
from neutron_lib.api.definitions import network as net_def
from neutron_lib.api.definitions import port as port_def
from neutron_lib.api.definitions import port_security as psec
from neutron_lib.api.definitions import portbindings
from neutron_lib.api.definitions import subnet as subnet_def
from neutron_lib.api import validators
from neutron_lib.callbacks import events
from neutron_lib.callbacks import exceptions
from neutron_lib.callbacks import registry
from neutron_lib.callbacks import resources
from neutron_lib import constants as const
from neutron_lib import exceptions as exc
from neutron_lib.exceptions import port_security as psec_exc
from neutron_lib.plugins import constants as plugin_constants
from neutron_lib.plugins import directory
from neutron_lib.plugins.ml2 import api
from oslo_config import cfg
from oslo_db import exception as os_db_exception
from oslo_log import helpers as log_helpers
from oslo_log import log
from oslo_serialization import jsonutils
from oslo_utils import excutils
from oslo_utils import importutils
from oslo_utils import uuidutils
import sqlalchemy
from sqlalchemy.orm import exc as sa_exc
from neutron._i18n import _
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import dvr_rpc
from neutron.api.rpc.handlers import metadata_rpc
from neutron.api.rpc.handlers import resources_rpc
from neutron.api.rpc.handlers import securitygroups_rpc
from neutron.common import constants as n_const
from neutron.common import rpc as n_rpc
from neutron.common import topics
from neutron.common import utils
from neutron.db import _model_query as model_query
from neutron.db import _resource_extend as resource_extend
from neutron.db import _utils as db_utils
from neutron.db import address_scope_db
from neutron.db import agents_db
from neutron.db import agentschedulers_db
from neutron.db import allowedaddresspairs_db as addr_pair_db
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from neutron.db import dvr_mac_db
from neutron.db import external_net_db
from neutron.db import extradhcpopt_db
from neutron.db.models import securitygroup as sg_models
from neutron.db import models_v2
from neutron.db import provisioning_blocks
from neutron.db.quota import driver
from neutron.db import securitygroups_rpc_base as sg_db_rpc
from neutron.db import segments_db
from neutron.db import subnet_service_type_db_models as service_type_db
from neutron.db import vlantransparent_db
from neutron.extensions import allowedaddresspairs as addr_pair
from neutron.extensions import availability_zone as az_ext
from neutron.extensions import netmtu_writable as mtu_ext
from neutron.extensions import providernet as provider
from neutron.extensions import vlantransparent
from neutron.plugins.common import utils as p_utils
from neutron.plugins.ml2.common import exceptions as ml2_exc
from neutron.plugins.ml2 import config
from neutron.plugins.ml2 import db
from neutron.plugins.ml2 import driver_context
from neutron.plugins.ml2.extensions import qos as qos_ext
from neutron.plugins.ml2 import managers
from neutron.plugins.ml2 import models
from neutron.plugins.ml2 import ovo_rpc
from neutron.plugins.ml2 import rpc
from neutron.quota import resource_registry
from neutron.services.qos import qos_consts
from neutron.services.segments import plugin as segments_plugin
LOG = log.getLogger(__name__)
MAX_BIND_TRIES = 10
SERVICE_PLUGINS_REQUIRED_DRIVERS = {'qos': [qos_ext.QOS_EXT_DRIVER_ALIAS]}
def _ml2_port_result_filter_hook(query, filters):
values = (filters and filters.get(portbindings.HOST_ID, []))
if (not values):
return query
bind_criteria = models.PortBinding.host.in_(values)
return query.filter(models_v2.Port.port_binding.has(bind_criteria))
@resource_extend.has_resource_extenders
@registry.has_registry_receivers
class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2, dvr_mac_db.DVRDbMixin, external_net_db.External_net_db_mixin, sg_db_rpc.SecurityGroupServerRpcMixin, agentschedulers_db.AZDhcpAgentSchedulerDbMixin, addr_pair_db.AllowedAddressPairsMixin, vlantransparent_db.Vlantransparent_db_mixin, extradhcpopt_db.ExtraDhcpOptMixin, address_scope_db.AddressScopeDbMixin, service_type_db.SubnetServiceTypeMixin, ):
'Implement the Neutron L2 abstractions using modules.\n\n Ml2Plugin is a Neutron plugin based on separately extensible sets\n of network types and mechanisms for connecting to networks of\n those types. The network types and mechanisms are implemented as\n drivers loaded via Python entry points. Networks can be made up of\n multiple segments (not yet fully implemented).\n '
__native_bulk_support = True
__native_pagination_support = True
__native_sorting_support = True
_supported_extension_aliases = ['provider', 'external-net', 'binding', 'quotas', 'security-group', 'agent', 'dhcp_agent_scheduler', 'multi-provider', 'allowed-address-pairs', 'extra_dhcp_opt', 'subnet_allocation', 'net-mtu', 'net-mtu-writable', 'vlan-transparent', 'address-scope', 'availability_zone', 'network_availability_zone', 'default-subnetpools', 'subnet-service-types']
@property

Xet Storage Details

Size:
66.4 kB
·
Xet hash:
5eb4a64739a94f7b050849285a27ac2a9881565150922669e5793a68e04b663d

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.