Buckets:
| import random, binascii, threading, os, time | |
| def pycc_corrupt_string(string): | |
| if string: | |
| if (random.randint(0, 1) == 0): | |
| hexstring = binascii.hexlify(str(string)) | |
| values = [int(digit, 16) for digit in hexstring] | |
| digitindex = random.randint(0, len(values)) | |
| bitindex = random.randint(0, 3) | |
| values[(digitindex - 1)] ^= (1 << bitindex) | |
| result = ''.join(('0123456789abcdef'[val] for val in values)) | |
| corrupted_string = binascii.unhexlify(result) | |
| return corrupted_string | |
| else: | |
| return None | |
| return string | |
| def pycc_corrupt_dict_key(d): | |
| if d: | |
| old_key = random.choice(d.keys()) | |
| corrupted_key = pycc_corrupt(old_key) | |
| d[corrupted_key] = d.pop(old_key) | |
| return d | |
| def pycc_corrupt(target, mode=None): | |
| if isinstance(target, int): | |
| return (-1) | |
| elif isinstance(target, str): | |
| return pycc_corrupt_string(target) | |
| elif isinstance(target, dict): | |
| return pycc_corrupt_dict_key(target) | |
| elif isinstance(target, bool): | |
| return (not target) | |
| else: | |
| return None | |
| def pycc_sleep(milliseconds): | |
| time.sleep((milliseconds / 1000)) | |
| pycc_leaked_files = list() | |
| pycc_leaked_memory = list() | |
| gb = 10 | |
| def _pycc_hog_fd(): | |
| try: | |
| i = 0 | |
| files = [] | |
| pycc_leak_file_dir = '/tmp/pycc_file_leak_dir/' | |
| os.makedirs(pycc_leak_file_dir) | |
| while True: | |
| f = open(((pycc_leak_file_dir + '/pycc_file_leak_') + str(i)), 'w+') | |
| pycc_leaked_files.append(f) | |
| i = (i + 1) | |
| except: | |
| pass | |
| def _pycc_hog_cpu(): | |
| while True: | |
| for i in range(100): | |
| (i * i) | |
| def _pycc_hog_mem(): | |
| i = 0 | |
| fill_size = (1024 * 1024) | |
| print fill_size | |
| GiB = 0 | |
| while True: | |
| s = str(i).zfill(fill_size) | |
| pycc_leaked_memory.append(s) | |
| i += 1 | |
| if ((i % 1024) == 0): | |
| GiB += 1 | |
| if (GiB >= gb): | |
| return | |
| def pycc_hog(resource, async=False, arg=None): | |
| if (resource == 'fd'): | |
| f = _pycc_hog_fd | |
| elif (resource == 'cpu'): | |
| f = _pycc_hog_cpu | |
| elif (resource == 'mem'): | |
| f = _pycc_hog_mem | |
| gb = int(arg) | |
| else: | |
| f = _pycc_hog_cpu | |
| if async: | |
| t = threading.Thread(target=f) | |
| t.start() | |
| else: | |
| f() | |
| import collections | |
| from neutron_lib.api.definitions import portbindings | |
| 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 n_exc | |
| from neutron_lib.plugins import constants as plugin_constants | |
| from neutron_lib.plugins import directory | |
| from oslo_config import cfg | |
| from oslo_log import helpers as log_helper | |
| from oslo_log import log as logging | |
| from oslo_utils import excutils | |
| import six | |
| from neutron._i18n import _ | |
| from neutron.common import constants as l3_const | |
| from neutron.common import utils as n_utils | |
| from neutron.db import api as db_api | |
| from neutron.db import l3_attrs_db | |
| from neutron.db import l3_db | |
| from neutron.db.models import allowed_address_pair as aap_models | |
| from neutron.db.models import l3 as l3_models | |
| from neutron.db import models_v2 | |
| from neutron.extensions import l3 | |
| from neutron.ipam import utils as ipam_utils | |
| from neutron.objects import agent as ag_obj | |
| from neutron.objects import l3agent as rb_obj | |
| from neutron.objects import router as l3_obj | |
| from neutron.plugins.common import utils as p_utils | |
| LOG = logging.getLogger(__name__) | |
| router_distributed_opts = [cfg.BoolOpt('router_distributed', default=False, help=_('System-wide flag to determine the type of router that tenants can create. Only admin can override.')), cfg.BoolOpt('enable_dvr', default=True, help=_('Determine if setup is configured for DVR. If False, DVR API extension will be disabled.'))] | |
| cfg.CONF.register_opts(router_distributed_opts) | |
| class DVRResourceOperationHandler(object, ): | |
| 'Contains callbacks for DVR operations.\n\n This can be implemented as a mixin or can be intantiated as a stand-alone\n object. Either way, it will subscribe itself to the relevant L3 events and\n use the plugin directory to find the L3 plugin to make calls to it as\n necessary.\n ' | |
| def l3plugin(self): | |
| return directory.get_plugin(plugin_constants.L3) | |
| def _set_distributed_flag(self, resource, event, trigger, context, router, router_db, **kwargs): | |
| 'Event handler to set distributed flag on creation.' | |
| dist = is_distributed_router(router) | |
| router['distributed'] = dist | |
| self.l3plugin.set_extra_attr_value(context, router_db, 'distributed', dist) | |
| def _validate_router_migration(self, context, router_db, router_res): | |
| 'Allow transition only when admin_state_up=False' | |
| original_distributed_state = router_db.extra_attributes.distributed | |
| requested_distributed_state = router_res.get('distributed', None) | |
| distributed_changed = ((requested_distributed_state is not None) and (requested_distributed_state != original_distributed_state)) | |
| if (not distributed_changed): | |
| return False | |
| if router_db.admin_state_up: | |
| msg = _("Cannot change the 'distributed' attribute of active routers. Please set router admin_state_up to False prior to upgrade") | |
| raise n_exc.BadRequest(resource='router', msg=msg) | |
| try: | |
| kwargs = {'context': context, 'router': router_db} | |
| registry.notify(resources.ROUTER, events.BEFORE_UPDATE, self, **kwargs) | |
| except exceptions.CallbackFailure as e: | |
| if (len(e.errors) == 1): | |
| raise e.errors[0].error | |
| raise l3.RouterInUse(router_id=router_db['id'], reason=e) | |
| return True | |
| def _handle_distributed_migration(self, resource, event, trigger, context, router_id, router, router_db, old_router, **kwargs): | |
| 'Event handler for router update migration to distributed.' | |
| if (not self._validate_router_migration(context, router_db, router)): | |
| return | |
| migrating_to_distributed = ((not router_db.extra_attributes.distributed) and (router.get('distributed') is True)) | |
| if migrating_to_distributed: | |
| if old_router['ha']: | |
| old_owner = const.DEVICE_OWNER_HA_REPLICATED_INT | |
| else: | |
| old_owner = const.DEVICE_OWNER_ROUTER_INTF | |
| self.l3plugin._migrate_router_ports(context, router_db, old_owner=old_owner, new_owner=const.DEVICE_OWNER_DVR_INTERFACE) | |
| self.l3plugin.set_extra_attr_value(context, router_db, 'distributed', True) | |
| else: | |
| if router.get('ha'): | |
| new_owner = const.DEVICE_OWNER_HA_REPLICATED_INT | |
| else: | |
| new_owner = const.DEVICE_OWNER_ROUTER_INTF | |
| self.l3plugin._migrate_router_ports(context, router_db, old_owner=const.DEVICE_OWNER_DVR_INTERFACE, new_owner=new_owner) | |
| self.l3plugin.set_extra_attr_value(context, router_db, 'distributed', False) | |
| cur_agents = self.l3plugin.list_l3_agents_hosting_router(context, router_db['id'])['agents'] | |
| for agent in cur_agents: | |
| self.l3plugin._unbind_router(context, router_db['id'], agent['id']) | |
| def _delete_snat_interfaces_after_change(self, resource, event, trigger, context, router_id, router, request_attrs, router_db, **kwargs): | |
| if (router.get(l3.EXTERNAL_GW_INFO) and (not router['distributed'])): | |
| old_router = kwargs['old_router'] | |
| if (old_router and old_router['distributed']): | |
| self.delete_csnat_router_interface_ports(context.elevated(), router_db) | |
| def _create_snat_interfaces_after_change(self, resource, event, trigger, context, router_id, router, request_attrs, router_db, **kwargs): | |
| if ((not router.get(l3.EXTERNAL_GW_INFO)) or (not router['distributed'])): | |
| return | |
| if (event == events.AFTER_UPDATE): | |
| old_router = kwargs['old_router'] | |
| do_create = ((not old_router['distributed']) or (not old_router.get(l3.EXTERNAL_GW_INFO))) | |
| if (not do_create): | |
| return | |
| if (not self._create_snat_intf_ports_if_not_exists(context.elevated(), router_db)): | |
| LOG.debug('SNAT interface ports not created: %s', router_db['id']) | |
| return router_db | |
| def _get_snat_interface_ports_for_router(self, context, router_id): | |
| 'Return all existing snat_router_interface ports.' | |
| objs = l3_obj.RouterPort.get_objects(context, router_id=router_id, port_type=const.DEVICE_OWNER_ROUTER_SNAT) | |
| ports = [self.l3plugin._core_plugin._make_port_dict(rp.db_obj.port) for rp in objs] | |
| return ports | |
| def _add_csnat_router_interface_port(self, context, router, network_id, subnet_id, do_pop=True): | |
| 'Add SNAT interface to the specified router and subnet.' | |
| port_data = {'tenant_id': '', 'network_id': network_id, 'fixed_ips': [{'subnet_id': subnet_id}], 'device_id': router.id, 'device_owner': const.DEVICE_OWNER_ROUTER_SNAT, 'admin_state_up': True, 'name': ''} | |
| snat_port = p_utils.create_port(self._core_plugin, context, {'port': port_data}) | |
| if (not snat_port): | |
| msg = _('Unable to create the SNAT Interface Port') | |
| raise n_exc.BadRequest(resource='router', msg=msg) | |
| with p_utils.delete_port_on_error(self.l3plugin._core_plugin, context.elevated(), snat_port['id']): | |
| l3_obj.RouterPort(context, port_id=snat_port['id'], router_id=router.id, port_type=const.DEVICE_OWNER_ROUTER_SNAT).create() | |
| if do_pop: | |
| return self.l3plugin._populate_mtu_and_subnets_for_ports(context, [snat_port]) | |
| return snat_port | |
| def _create_snat_intf_ports_if_not_exists(self, context, router): | |
| 'Function to return the snat interface port list.\n\n This function will return the snat interface port list\n if it exists. If the port does not exist it will create\n new ports and then return the list.\n ' | |
| port_list = self._get_snat_interface_ports_for_router(context, router.id) | |
| if port_list: | |
| self._populate_mtu_and_subnets_for_ports(context, port_list) | |
| return port_list | |
| port_list = [] | |
| int_ports = (rp.port for rp in router.attached_ports.filter_by(port_type=const.DEVICE_OWNER_DVR_INTERFACE)) | |
| LOG.info('SNAT interface port list does not exist, so create one: %s', port_list) | |
| for intf in int_ports: | |
| if intf.fixed_ips: | |
| snat_port = self._add_csnat_router_interface_port(context, router, intf['network_id'], intf['fixed_ips'][0]['subnet_id'], do_pop=False) | |
| port_list.append(snat_port) | |
| if port_list: | |
| self.l3plugin._populate_mtu_and_subnets_for_ports(context, port_list) | |
| return port_list | |
| def _delete_dvr_internal_ports(self, event, trigger, resource, context, router, network_id, new_network_id, **kwargs): | |
| '\n GW port AFTER_DELETE event handler to cleanup DVR ports.\n\n This event is emitted when a router gateway port is being deleted,\n so go ahead and delete the csnat ports and the floatingip\n agent gateway port associated with the dvr router.\n ' | |
| if (not is_distributed_router(router)): | |
| return | |
| if (not new_network_id): | |
| self.delete_csnat_router_interface_ports(context.elevated(), router) | |
| filters = {'network_id': [network_id], 'device_owner': [const.DEVICE_OWNER_ROUTER_GW]} | |
| ext_net_gw_ports = self._core_plugin.get_ports(context.elevated(), filters) | |
| if (not ext_net_gw_ports): | |
| self.delete_floatingip_agent_gateway_port(context.elevated(), None, network_id) | |
| self.l3plugin.l3_rpc_notifier.delete_fipnamespace_for_ext_net(context, network_id) | |
| def delete_floatingip_agent_gateway_port(self, context, host_id, ext_net_id): | |
| 'Function to delete FIP gateway port with given ext_net_id.' | |
| device_filter = {'device_owner': [const.DEVICE_OWNER_AGENT_GW], 'network_id': [ext_net_id]} | |
| ports = self._core_plugin.get_ports(context, filters=device_filter) | |
| for p in ports: | |
| if ((not host_id) or (p[portbindings.HOST_ID] == host_id)): | |
| self._core_plugin.ipam.delete_port(context, p['id']) | |
| if host_id: | |
| return | |
| def _get_ports_for_allowed_address_pair_ip(self, context, network_id, fixed_ip): | |
| 'Return all active ports associated with the allowed_addr_pair ip.' | |
| query = context.session.query(models_v2.Port).filter((models_v2.Port.id == aap_models.AllowedAddressPair.port_id), (aap_models.AllowedAddressPair.ip_address == fixed_ip), (models_v2.Port.network_id == network_id), (models_v2.Port.admin_state_up == True)) | |
| return query.all() | |
| def _create_dvr_floating_gw_port(self, resource, event, trigger, context, router_id, fixed_port_id, floating_ip_id, floating_network_id, fixed_ip_address, **kwargs): | |
| 'Create floating agent gw port for DVR.\n\n Floating IP Agent gateway port will be created when a\n floatingIP association happens.\n ' | |
| associate_fip = (fixed_port_id and floating_ip_id) | |
| if (associate_fip and router_id): | |
| admin_ctx = context.elevated() | |
| router_dict = self.get_router(admin_ctx, router_id) | |
| if router_dict.get('distributed'): | |
| hostid = self._get_dvr_service_port_hostid(context, fixed_port_id) | |
| if hostid: | |
| fip_agent_port = self.create_fip_agent_gw_port_if_not_exists(admin_ctx, floating_network_id, hostid) | |
| LOG.debug('FIP Agent gateway port: %s', fip_agent_port) | |
| else: | |
| port = self._core_plugin.get_port(admin_ctx, fixed_port_id) | |
| allowed_device_owners = n_utils.get_dvr_allowed_address_pair_device_owners() | |
| if ((port['device_owner'] == '') or (port['device_owner'] in allowed_device_owners)): | |
| addr_pair_active_service_port_list = self._get_ports_for_allowed_address_pair_ip(admin_ctx, port['network_id'], fixed_ip_address) | |
| if (not addr_pair_active_service_port_list): | |
| return | |
| self._inherit_service_port_and_arp_update(context, addr_pair_active_service_port_list[0], port) | |
| def _inherit_service_port_and_arp_update(self, context, service_port, allowed_address_port): | |
| 'Function inherits port host bindings for allowed_address_pair.' | |
| service_port_dict = self.l3plugin._core_plugin._make_port_dict(service_port) | |
| address_pair_list = service_port_dict.get('allowed_address_pairs') | |
| for address_pair in address_pair_list: | |
| self.update_arp_entry_for_dvr_service_port(context, service_port_dict) | |
| def _add_csnat_on_interface_create(self, resource, event, trigger, context, router_db, port, **kwargs): | |
| 'Event handler to for csnat port creation on interface creation.' | |
| if ((not router_db.extra_attributes.distributed) or (not router_db.gw_port)): | |
| return | |
| admin_context = context.elevated() | |
| self._add_csnat_router_interface_port(admin_context, router_db, port['network_id'], port['fixed_ips'][(-1)]['subnet_id']) | |
| def _update_snat_v6_addrs_after_intf_update(self, resource, event, triger, context, subnets, port, router_id, new_interface, **kwargs): | |
| if new_interface: | |
| return | |
| subnet = subnets[0] | |
| if ((not subnet) or (subnet['ip_version'] != 6)): | |
| return | |
| admin_ctx = context.elevated() | |
| router = self.l3plugin._get_router(admin_ctx, router_id) | |
| cs_port = self._find_v6_router_port_by_network_and_device_owner(router, subnet['network_id'], const.DEVICE_OWNER_ROUTER_SNAT) | |
| if (not cs_port): | |
| return | |
| new_fixed_ip = {'subnet_id': subnet['id']} | |
| fixed_ips = list(cs_port['fixed_ips']) | |
| fixed_ips.append(new_fixed_ip) | |
| try: | |
| updated_port = self._core_plugin.update_port(admin_ctx, cs_port['id'], {'port': {'fixed_ips': fixed_ips}}) | |
| except Exception: | |
| with excutils.save_and_reraise_exception(): | |
| def revert(): | |
| p = self._core_plugin.get_port(admin_ctx, port['id']) | |
| rollback_fixed_ips = [ip for ip in p['fixed_ips'] if (ip['subnet_id'] != subnet['id'])] | |
| upd = {'port': {'fixed_ips': rollback_fixed_ips}} | |
| self._core_plugin.update_port(admin_ctx, port['id'], upd) | |
| try: | |
| revert() | |
| except Exception: | |
| LOG.exception('Failed to revert change to router port %s.', port['id']) | |
| LOG.debug('CSNAT port updated for IPv6 subnet: %s', updated_port) | |
| def _find_v6_router_port_by_network_and_device_owner(self, router, net_id, device_owner): | |
| for port in router.attached_ports: | |
| p = port['port'] | |
| if ((p['network_id'] == net_id) and (p['device_owner'] == device_owner) and self.l3plugin._port_has_ipv6_address(p)): | |
| return self.l3plugin._core_plugin._make_port_dict(p) | |
| def _check_for_multiprefix_csnat_port_and_update(self, context, router, network_id, subnet_id): | |
| "Checks if the csnat port contains multiple ipv6 prefixes.\n\n If the csnat port contains multiple ipv6 prefixes for the given\n network when a router interface is deleted, make sure we don't\n delete the port when a single subnet is deleted and just update\n it with the right fixed_ip.\n This function returns true if it is a multiprefix port.\n " | |
| if router.gw_port: | |
| cs_port = self._find_v6_router_port_by_network_and_device_owner(router, network_id, const.DEVICE_OWNER_ROUTER_SNAT) | |
| if cs_port: | |
| fixed_ips = [fixedip for fixedip in cs_port['fixed_ips'] if (fixedip['subnet_id'] != subnet_id)] | |
| if (len(fixed_ips) == len(cs_port['fixed_ips'])): | |
| return False | |
| if fixed_ips: | |
| self.l3plugin._core_plugin.update_port(context.elevated(), cs_port['id'], {'port': {'fixed_ips': fixed_ips}}) | |
| return True | |
| return False | |
| def _cleanup_after_interface_removal(self, resource, event, trigger, context, port, interface_info, router_id, **kwargs): | |
| 'Handler to cleanup distributed resources after intf removal.' | |
| router = self.l3plugin._get_router(context, router_id) | |
| if (not router.extra_attributes.distributed): | |
| return | |
| plugin = directory.get_plugin(plugin_constants.L3) | |
| router_hosts_for_removed = plugin._get_dvr_hosts_for_subnets(context, subnet_ids={ip['subnet_id'] for ip in port['fixed_ips']}) | |
| router_hosts_after = plugin._get_dvr_hosts_for_router(context, router_id) | |
| removed_hosts = (set(router_hosts_for_removed) - set(router_hosts_after)) | |
| if removed_hosts: | |
| agents = plugin.get_l3_agents(context, filters={'host': removed_hosts}) | |
| bindings = rb_obj.RouterL3AgentBinding.get_objects(context, router_id=router_id) | |
| snat_binding = (bindings.pop() if bindings else None) | |
| for agent in agents: | |
| is_this_snat_agent = (snat_binding and (snat_binding.l3_agent_id == agent['id'])) | |
| if (not is_this_snat_agent): | |
| self.l3plugin.l3_rpc_notifier.router_removed_from_agent(context, router_id, agent['host']) | |
| sub_id = (interface_info.get('subnet_id') or port['fixed_ips'][0]['subnet_id']) | |
| is_multiple_prefix_csport = self._check_for_multiprefix_csnat_port_and_update(context, router, port['network_id'], sub_id) | |
| if (not is_multiple_prefix_csport): | |
| self.delete_csnat_router_interface_ports(context.elevated(), router, subnet_id=sub_id) | |
| def delete_csnat_router_interface_ports(self, context, router, subnet_id=None): | |
| filters = {'device_owner': [const.DEVICE_OWNER_ROUTER_SNAT], 'device_id': [router.id]} | |
| c_snat_ports = self.l3plugin._core_plugin.get_ports(context, filters=filters) | |
| for p in c_snat_ports: | |
| if ((subnet_id is None) or (not p['fixed_ips'])): | |
| if (not p['fixed_ips']): | |
| LOG.info('CSNAT port has no IPs: %s', p) | |
| self.l3plugin._core_plugin.delete_port(context, p['id'], l3_port_check=False) | |
| elif (p['fixed_ips'][0]['subnet_id'] == subnet_id): | |
| LOG.debug('Subnet matches: %s', subnet_id) | |
| self.l3plugin._core_plugin.delete_port(context, p['id'], l3_port_check=False) | |
| class _DVRAgentInterfaceMixin(object, ): | |
| 'Contains calls made by the DVR scheduler and RPC interface.\n\n Must be instantiated as a mixin with the L3 plugin.\n ' | |
| def _get_snat_sync_interfaces(self, context, router_ids): | |
| 'Query router interfaces that relate to list of router_ids.' | |
| if (not router_ids): | |
| return [] | |
| objs = l3_obj.RouterPort.get_objects(context, router_id=router_ids, port_type=const.DEVICE_OWNER_ROUTER_SNAT) | |
| interfaces = collections.defaultdict(list) | |
| for rp in objs: | |
| interfaces[rp.router_id].append(self._core_plugin._make_port_dict(rp.db_obj.port)) | |
| LOG.debug('Return the SNAT ports: %s', interfaces) | |
| return interfaces | |
| def _build_routers_list(self, context, routers, gw_ports): | |
| routers = super(_DVRAgentInterfaceMixin, self)._build_routers_list(context, routers, gw_ports) | |
| if (not routers): | |
| return [] | |
| router_ids = [r['id'] for r in routers] | |
| binding_objs = rb_obj.RouterL3AgentBinding.get_objects(context, router_id=router_ids) | |
| bindings = dict(((b.router_id, b) for b in binding_objs)) | |
| for rtr in routers: | |
| gw_port_id = rtr['gw_port_id'] | |
| if (gw_port_id and gw_ports.get(gw_port_id)): | |
| binding = bindings.get(rtr['id']) | |
| if (not binding): | |
| rtr['gw_port_host'] = None | |
| LOG.debug('No snat is bound to router %s', rtr['id']) | |
| continue | |
| l3_agent = ag_obj.Agent.get_object(context, id=binding.l3_agent_id) | |
| rtr['gw_port_host'] = l3_agent.host | |
| return routers | |
| def _process_routers(self, context, routers, agent): | |
| routers_dict = {} | |
| snat_intfs_by_router_id = self._get_snat_sync_interfaces(context, [r['id'] for r in routers]) | |
| fip_agent_gw_ports = None | |
| LOG.debug('FIP Agent: %s ', agent.id) | |
| for router in routers: | |
| routers_dict[router['id']] = router | |
| if router['gw_port_id']: | |
| snat_router_intfs = snat_intfs_by_router_id[router['id']] | |
| LOG.debug('SNAT ports returned: %s ', snat_router_intfs) | |
| router[l3_const.SNAT_ROUTER_INTF_KEY] = snat_router_intfs | |
| if (not fip_agent_gw_ports): | |
| fip_agent_gw_ports = self._get_fip_agent_gw_ports(context, agent.id) | |
| LOG.debug('FIP Agent ports: %s', fip_agent_gw_ports) | |
| router[l3_const.FLOATINGIP_AGENT_INTF_KEY] = fip_agent_gw_ports | |
| return routers_dict | |
| def _get_floating_ip_host(floating_ip): | |
| 'Function to return floating IP host binding state\n\n By default, floating IPs are not bound to any host. Instead\n of using the empty string to denote this use a constant.\n ' | |
| return floating_ip.get('host', l3_const.FLOATING_IP_HOST_UNBOUND) | |
| def _process_floating_ips_dvr(self, context, routers_dict, floating_ips, host, agent): | |
| LOG.debug('FIP Agent : %s ', agent.id) | |
| for floating_ip in floating_ips: | |
| router = routers_dict.get(floating_ip['router_id']) | |
| if router: | |
| if router['distributed']: | |
| if self._skip_floating_ip_for_mismatched_agent_or_host(floating_ip, agent, host): | |
| continue | |
| router_floatingips = router.get(const.FLOATINGIP_KEY, []) | |
| router_floatingips.append(floating_ip) | |
| router[const.FLOATINGIP_KEY] = router_floatingips | |
| def _skip_floating_ip_for_mismatched_agent_or_host(self, floating_ip, agent, host): | |
| 'Function to check if floating IP processing can be skipped.' | |
| fip_host = self._get_floating_ip_host(floating_ip) | |
| if (fip_host == l3_const.FLOATING_IP_HOST_UNBOUND): | |
| return True | |
| agent_mode = self._get_agent_mode(agent) | |
| if ((agent_mode in [const.L3_AGENT_MODE_LEGACY, const.L3_AGENT_MODE_DVR]) and floating_ip.get(l3_const.DVR_SNAT_BOUND)): | |
| return True | |
| fip_dest_host = floating_ip.get('dest_host') | |
| if ((fip_host != l3_const.FLOATING_IP_HOST_NEEDS_BINDING) and (fip_host != host) and (fip_dest_host is None)): | |
| return True | |
| LOG.debug('Floating IP host: %s', fip_host) | |
| return False | |
| def _get_fip_agent_gw_ports(self, context, fip_agent_id): | |
| 'Return list of floating agent gateway ports for the agent.' | |
| if (not fip_agent_id): | |
| return [] | |
| filters = {'device_id': [fip_agent_id], 'device_owner': [const.DEVICE_OWNER_AGENT_GW]} | |
| ports = self._core_plugin.get_ports(context.elevated(), filters) | |
| LOG.debug('Return the FIP ports: %s ', ports) | |
| return ports | |
| def _get_dvr_sync_data(self, context, host, agent, router_ids=None, active=None): | |
| (routers, interfaces, floating_ips) = self._get_router_info_list(context, router_ids=router_ids, active=active, device_owners=const.ROUTER_INTERFACE_OWNERS) | |
| dvr_router_ids = set((router['id'] for router in routers if is_distributed_router(router))) | |
| floating_ip_port_ids = [fip['port_id'] for fip in floating_ips if (fip['router_id'] in dvr_router_ids)] | |
| if floating_ip_port_ids: | |
| port_filter = {'id': floating_ip_port_ids} | |
| ports = self._core_plugin.get_ports(context, port_filter) | |
| port_dict = {} | |
| for port in ports: | |
| port_profile = port.get(portbindings.PROFILE) | |
| port_in_migration = (port_profile and (port_profile.get('migrating_to') == host)) | |
| if (port_in_migration or self._is_unbound_port(port)): | |
| port_dict.update({port['id']: port}) | |
| continue | |
| port_host = port[portbindings.HOST_ID] | |
| if port_host: | |
| l3_agent_on_host = self.get_l3_agents(context, filters={'host': [port_host]}) | |
| l3_agent_mode = '' | |
| if len(l3_agent_on_host): | |
| l3_agent_mode = self._get_agent_mode(l3_agent_on_host[0]) | |
| requesting_agent_mode = self._get_agent_mode(agent) | |
| if (port_host == host): | |
| if ((l3_agent_mode == l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL) and (requesting_agent_mode == l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL)): | |
| port['agent'] = l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL | |
| port_dict.update({port['id']: port}) | |
| elif ((l3_agent_mode == l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL) and (requesting_agent_mode == const.L3_AGENT_MODE_DVR_SNAT)): | |
| port['agent'] = l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL | |
| port_dict.update({port['id']: port}) | |
| for fip in floating_ips: | |
| fip['host'] = l3_const.FLOATING_IP_HOST_UNBOUND | |
| vm_port = port_dict.get(fip['port_id'], None) | |
| if vm_port: | |
| fip['host'] = l3_const.FLOATING_IP_HOST_NEEDS_BINDING | |
| port_host = vm_port[portbindings.HOST_ID] | |
| if port_host: | |
| fip['dest_host'] = self._get_dvr_migrating_service_port_hostid(context, fip['port_id'], port=vm_port) | |
| vm_port_agent_mode = vm_port.get('agent', None) | |
| if (vm_port_agent_mode != l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL): | |
| fip['host'] = port_host | |
| if (fip['host'] == l3_const.FLOATING_IP_HOST_NEEDS_BINDING): | |
| fip[l3_const.DVR_SNAT_BOUND] = True | |
| routers_dict = self._process_routers(context, routers, agent) | |
| self._process_floating_ips_dvr(context, routers_dict, floating_ips, host, agent) | |
| ports_to_populate = [] | |
| for router in routers_dict.values(): | |
| if router.get('gw_port'): | |
| ports_to_populate.append(router['gw_port']) | |
| if router.get(l3_const.FLOATINGIP_AGENT_INTF_KEY): | |
| ports_to_populate += router[l3_const.FLOATINGIP_AGENT_INTF_KEY] | |
| if router.get(l3_const.SNAT_ROUTER_INTF_KEY): | |
| ports_to_populate += router[l3_const.SNAT_ROUTER_INTF_KEY] | |
| ports_to_populate += interfaces | |
| self._populate_mtu_and_subnets_for_ports(context, ports_to_populate) | |
| self._process_interfaces(routers_dict, interfaces) | |
| return list(routers_dict.values()) | |
| def _is_unbound_port(self, port): | |
| 'Check for port-bindings irrespective of device_owner.' | |
| return (not port[portbindings.HOST_ID]) | |
| def _get_dvr_service_port_hostid(self, context, port_id, port=None): | |
| 'Returns the portbinding host_id for dvr service port.' | |
| port_db = (port or self._core_plugin.get_port(context, port_id)) | |
| return (port_db[portbindings.HOST_ID] or None) | |
| def _get_dvr_migrating_service_port_hostid(self, context, port_id, port=None): | |
| 'Returns the migrating host_id from the migrating profile.' | |
| port_db = (port or self._core_plugin.get_port(context, port_id)) | |
| port_profile = port_db.get(portbindings.PROFILE) | |
| port_dest_host = None | |
| if port_profile: | |
| port_dest_host = port_profile.get('migrating_to') | |
| return port_dest_host | |
| def _get_agent_gw_ports_exist_for_network(self, context, network_id, host, agent_id): | |
| 'Return agent gw port if exist, or None otherwise.' | |
| if (not network_id): | |
| LOG.debug('Network not specified') | |
| return | |
| filters = {'network_id': [network_id], 'device_id': [agent_id], 'device_owner': [const.DEVICE_OWNER_AGENT_GW]} | |
| ports = self._core_plugin.get_ports(context, filters) | |
| if ports: | |
| return pycc_corrupt(ports[0]) | |
| def check_for_fip_and_create_agent_gw_port_on_host_if_not_exists(self, context, port, host): | |
| 'Create fip agent_gw_port on host if not exists' | |
| fips = self._get_floatingips_by_port_id(context, port['id']) | |
| if (not fips): | |
| return | |
| fip = fips[0] | |
| network_id = fip.get('floating_network_id') | |
| agent_gw_port = self.create_fip_agent_gw_port_if_not_exists(context.elevated(), network_id, host) | |
| LOG.debug('Port-in-Migration: Floatingip Agent Gateway port %(gw)s created for the future host: %(dest_host)s', {'gw': agent_gw_port, 'dest_host': host}) | |
| def create_fip_agent_gw_port_if_not_exists(self, context, network_id, host): | |
| 'Function to return the FIP Agent GW port.\n\n This function will create a FIP Agent GW port\n if required. If the port already exists, it\n will return the existing port and will not\n create a new one.\n ' | |
| l3_agent_db = self._get_agent_by_type_and_host(context, const.AGENT_TYPE_L3, host) | |
| l3_agent_mode = self._get_agent_mode(l3_agent_db) | |
| if (l3_agent_mode == l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL): | |
| return | |
| if l3_agent_db: | |
| LOG.debug('Agent ID exists: %s', l3_agent_db['id']) | |
| f_port = self._get_agent_gw_ports_exist_for_network(context, network_id, host, l3_agent_db['id']) | |
| if (not f_port): | |
| LOG.info('Agent Gateway port does not exist, so create one: %s', f_port) | |
| port_data = {'tenant_id': '', 'network_id': network_id, 'device_id': l3_agent_db['id'], 'device_owner': const.DEVICE_OWNER_AGENT_GW, portbindings.HOST_ID: host, 'admin_state_up': True, 'name': ''} | |
| agent_port = p_utils.create_port(self._core_plugin, context, {'port': port_data}) | |
| if agent_port: | |
| self._populate_mtu_and_subnets_for_ports(context, [agent_port]) | |
| return agent_port | |
| msg = _('Unable to create the Agent Gateway Port') | |
| raise n_exc.BadRequest(resource='router', msg=msg) | |
| else: | |
| self._populate_mtu_and_subnets_for_ports(context, [f_port]) | |
| return f_port | |
| def _generate_arp_table_and_notify_agent(self, context, fixed_ip, mac_address, notifier, nud_state='permanent'): | |
| 'Generates the arp table entry and notifies the l3 agent.' | |
| ip_address = fixed_ip['ip_address'] | |
| subnet = fixed_ip['subnet_id'] | |
| filters = {'fixed_ips': {'subnet_id': [subnet]}, 'device_owner': [const.DEVICE_OWNER_DVR_INTERFACE]} | |
| ports = self._core_plugin.get_ports(context, filters=filters) | |
| router_id = next((port['device_id'] for port in ports), None) | |
| if (not router_id): | |
| return | |
| arp_table = {'ip_address': ip_address, 'mac_address': mac_address, 'subnet_id': subnet, 'nud_state': nud_state} | |
| notifier(context, router_id, arp_table) | |
| def _get_subnet_id_for_given_fixed_ip(self, context, fixed_ip, port_dict): | |
| 'Returns the subnet_id that matches the fixedip on a network.' | |
| filters = {'network_id': [port_dict['network_id']]} | |
| subnets = self._core_plugin.get_subnets(context, filters) | |
| for subnet in subnets: | |
| if ipam_utils.check_subnet_ip(subnet['cidr'], fixed_ip): | |
| return subnet['id'] | |
| def _get_allowed_address_pair_fixed_ips(self, context, port_dict): | |
| 'Returns all fixed_ips associated with the allowed_address_pair.' | |
| aa_pair_fixed_ips = [] | |
| if port_dict.get('allowed_address_pairs'): | |
| for address_pair in port_dict['allowed_address_pairs']: | |
| aap_ip_cidr = address_pair['ip_address'].split('/') | |
| if ((len(aap_ip_cidr) == 1) or (int(aap_ip_cidr[1]) == 32)): | |
| subnet_id = self._get_subnet_id_for_given_fixed_ip(context, aap_ip_cidr[0], port_dict) | |
| if (subnet_id is not None): | |
| fixed_ip = {'subnet_id': subnet_id, 'ip_address': aap_ip_cidr[0]} | |
| aa_pair_fixed_ips.append(fixed_ip) | |
| else: | |
| LOG.debug('Subnet does not match for the given fixed_ip %s for arp update', aap_ip_cidr[0]) | |
| return aa_pair_fixed_ips | |
| def update_arp_entry_for_dvr_service_port(self, context, port_dict): | |
| "Notify L3 agents of ARP table entry for dvr service port.\n\n When a dvr service port goes up, look for the DVR router on\n the port's subnet, and send the ARP details to all\n L3 agents hosting the router to add it.\n If there are any allowed_address_pairs associated with the port\n those fixed_ips should also be updated in the ARP table.\n " | |
| fixed_ips = port_dict['fixed_ips'] | |
| if (not fixed_ips): | |
| return | |
| allowed_address_pair_fixed_ips = self._get_allowed_address_pair_fixed_ips(context, port_dict) | |
| for fixed_ip in fixed_ips: | |
| self._generate_arp_table_and_notify_agent(context, fixed_ip, port_dict['mac_address'], self.l3_rpc_notifier.add_arp_entry) | |
| for fixed_ip in allowed_address_pair_fixed_ips: | |
| self._generate_arp_table_and_notify_agent(context, fixed_ip, port_dict['mac_address'], self.l3_rpc_notifier.add_arp_entry, nud_state='reachable') | |
| def delete_arp_entry_for_dvr_service_port(self, context, port_dict, fixed_ips_to_delete=None): | |
| "Notify L3 agents of ARP table entry for dvr service port.\n\n When a dvr service port goes down, look for the DVR\n router on the port's subnet, and send the ARP details to all\n L3 agents hosting the router to delete it.\n If there are any allowed_address_pairs associated with the\n port, those fixed_ips should be removed from the ARP table.\n " | |
| fixed_ips = port_dict['fixed_ips'] | |
| if (not fixed_ips): | |
| return | |
| if (not fixed_ips_to_delete): | |
| allowed_address_pair_fixed_ips = self._get_allowed_address_pair_fixed_ips(context, port_dict) | |
| fixed_ips_to_delete = (fixed_ips + allowed_address_pair_fixed_ips) | |
| for fixed_ip in fixed_ips_to_delete: | |
| self._generate_arp_table_and_notify_agent(context, fixed_ip, port_dict['mac_address'], self.l3_rpc_notifier.del_arp_entry) | |
| def _get_address_pair_active_port_with_fip(self, context, port_dict, port_addr_pair_ip): | |
| port_valid_state = (port_dict['admin_state_up'] or (port_dict['status'] == const.PORT_STATUS_ACTIVE)) | |
| if (not port_valid_state): | |
| return | |
| query = context.session.query(l3_models.FloatingIP).filter((l3_models.FloatingIP.fixed_ip_address == port_addr_pair_ip)) | |
| fip = query.first() | |
| return (self._core_plugin.get_port(context, fip.fixed_port_id) if fip else None) | |
| class L3_NAT_with_dvr_db_mixin(_DVRAgentInterfaceMixin, DVRResourceOperationHandler, l3_attrs_db.ExtraAttributesMixin, l3_db.L3_NAT_db_mixin, ): | |
| 'Mixin class to enable DVR support.' | |
| router_device_owners = (l3_db.L3_NAT_db_mixin.router_device_owners + (const.DEVICE_OWNER_DVR_INTERFACE, const.DEVICE_OWNER_ROUTER_SNAT, const.DEVICE_OWNER_AGENT_GW)) | |
| def _get_device_owner(self, context, router=None): | |
| 'Get device_owner for the specified router.' | |
| router_is_uuid = isinstance(router, six.string_types) | |
| if router_is_uuid: | |
| router = self._get_router(context, router) | |
| if is_distributed_router(router): | |
| return const.DEVICE_OWNER_DVR_INTERFACE | |
| return super(L3_NAT_with_dvr_db_mixin, self)._get_device_owner(context, router) | |
| def create_floatingip(self, context, floatingip, initial_status=const.FLOATINGIP_STATUS_ACTIVE): | |
| floating_ip = self._create_floatingip(context, floatingip, initial_status) | |
| self._notify_floating_ip_change(context, floating_ip) | |
| return floating_ip | |
| def get_dvr_agent_on_host(self, context, fip_host): | |
| agent_filters = {'host': [fip_host]} | |
| return self.get_l3_agents(context, filters=agent_filters) | |
| def _notify_floating_ip_change(self, context, floating_ip): | |
| router_id = floating_ip['router_id'] | |
| fixed_port_id = floating_ip['port_id'] | |
| if ((not router_id) or (not fixed_port_id)): | |
| return | |
| try: | |
| router = self._get_router(context.elevated(), router_id) | |
| except l3.RouterNotFound: | |
| LOG.warning('Router %s was not found. Skipping agent notification.', router_id) | |
| return | |
| if is_distributed_router(router): | |
| host = self._get_dvr_service_port_hostid(context, fixed_port_id) | |
| dest_host = self._get_dvr_migrating_service_port_hostid(context, fixed_port_id) | |
| if (host is not None): | |
| l3_agent_on_host = self.get_dvr_agent_on_host(context, host) | |
| agent_mode = self._get_agent_mode(l3_agent_on_host[0]) | |
| if (agent_mode == l3_const.L3_AGENT_MODE_DVR_NO_EXTERNAL): | |
| host = None | |
| if (host is not None): | |
| self.l3_rpc_notifier.routers_updated_on_host(context, [router_id], host) | |
| if (dest_host and (dest_host != host)): | |
| self.l3_rpc_notifier.routers_updated_on_host(context, [router_id], dest_host) | |
| else: | |
| centralized_agent_list = self.list_l3_agents_hosting_router(context, router_id)['agents'] | |
| for agent in centralized_agent_list: | |
| self.l3_rpc_notifier.routers_updated_on_host(context, [router_id], agent['host']) | |
| else: | |
| self.notify_router_updated(context, router_id) | |
| def update_floatingip(self, context, id, floatingip): | |
| (old_floatingip, floatingip) = self._update_floatingip(context, id, floatingip) | |
| self._notify_floating_ip_change(context, old_floatingip) | |
| if ((floatingip['router_id'] != old_floatingip['router_id']) or (floatingip['port_id'] != old_floatingip['port_id'])): | |
| self._notify_floating_ip_change(context, floatingip) | |
| return floatingip | |
| def delete_floatingip(self, context, id): | |
| floating_ip = self._delete_floatingip(context, id) | |
| self._notify_floating_ip_change(context, floating_ip) | |
| def is_distributed_router(router): | |
| 'Return True if router to be handled is distributed.' | |
| try: | |
| requested_router_type = router.extra_attributes.distributed | |
| except AttributeError: | |
| requested_router_type = router.get('distributed') | |
| if validators.is_attr_set(requested_router_type): | |
| return requested_router_type | |
| return cfg.CONF.router_distributed | |
Xet Storage Details
- Size:
- 42.4 kB
- Xet hash:
- 474b4b003195d803c26eae6c9b55116d7920ae6ea2ccae8d925c4b1b4ad48b0d
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.