def _connect(self, params): """Connect to rabbit. Re-establish any queues that may have been declared before if we are reconnecting. Exceptions should be handled by the caller. """ if self.connection: LOG.info(_LI("Reconnecting to AMQP server on " "%(hostname)s:%(port)d") % params) try: self.connection.release() except self.connection_errors: pass # Setting this in case the next statement fails, though # it shouldn't be doing any network operations, yet. self.connection = None self.connection = kombu.connection.BrokerConnection(**params) self.connection_errors = self.connection.connection_errors if self.memory_transport: # Kludge to speed up tests. self.connection.transport.polling_interval = 0.0 self.consumer_num = itertools.count(1) self.connection.connect() self.channel = self.connection.channel() # work around 'memory' transport bug in 1.1.3 if self.memory_transport: self.channel._new_queue('ae.undeliver') for consumer in self.consumers: consumer.reconnect(self.channel) LOG.info(_LI('Connected to AMQP server on %(hostname)s:%(port)d') % params)
def sync_state(self, networks=None): """Sync the local DHCP state with Neutron. If no networks are passed, or 'None' is one of the networks, sync all of the networks. """ only_nets = set([] if (not networks or None in networks) else networks) LOG.info(_LI('Synchronizing state')) pool = eventlet.GreenPool(cfg.CONF.num_sync_threads) known_network_ids = set(self.cache.get_network_ids()) try: active_networks = self.plugin_rpc.get_active_networks_info() active_network_ids = set(network.id for network in active_networks) for deleted_id in known_network_ids - active_network_ids: try: self.disable_dhcp_helper(deleted_id) except Exception as e: self.schedule_resync(e, deleted_id) LOG.exception(_LE('Unable to sync network state on ' 'deleted network %s'), deleted_id) for network in active_networks: if (not only_nets or # specifically resync all network.id not in known_network_ids or # missing net network.id in only_nets): # specific network to sync pool.spawn(self.safe_configure_dhcp_for_network, network) pool.waitall() LOG.info(_LI('Synchronizing state complete')) except Exception as e: self.schedule_resync(e) LOG.exception(_LE('Unable to sync network state.'))
def _run_openstack_l3_cmds(self, commands, server): """Execute/sends a CAPI (Command API) command to EOS. In this method, list of commands is appended with prefix and postfix commands - to make is understandble by EOS. :param commands : List of command to be executed on EOS. :param server: Server endpoint on the Arista switch to be configured """ command_start = ['enable', 'configure'] command_end = ['exit'] full_command = command_start + commands + command_end LOG.info(_LI('Executing command on Arista EOS: %s'), full_command) try: # this returns array of return values for every command in # full_command list ret = server.runCmds(version=1, cmds=full_command) LOG.info(_LI('Results of execution on Arista EOS: %s'), ret) except Exception: msg = (_('Error occured while trying to execute ' 'commands %(cmd)s on EOS %(host)s') % {'cmd': full_command, 'host': server}) LOG.exception(msg) raise arista_exc.AristaServicePluginRpcError(msg=msg)
def _wait_child(self): try: # Don't block if no child processes have exited pid, status = os.waitpid(0, os.WNOHANG) if not pid: return None except OSError as exc: if exc.errno not in (errno.EINTR, errno.ECHILD): raise return None if os.WIFSIGNALED(status): sig = os.WTERMSIG(status) LOG.info(_LI('Child %(pid)d killed by signal %(sig)d'), dict(pid=pid, sig=sig)) else: code = os.WEXITSTATUS(status) LOG.info(_LI('Child %(pid)s exited with status %(code)d'), dict(pid=pid, code=code)) if pid not in self.children: LOG.warning(_LW('pid %d not in child list'), pid) return None wrap = self.children.pop(pid) wrap.children.remove(pid) return wrap
def _start_child(self, wrap): if len(wrap.forktimes) > wrap.workers: # Limit ourselves to one process a second (over the period of # number of workers * 1 second). This will allow workers to # start up quickly but ensure we don't fork off children that # die instantly too quickly. if time.time() - wrap.forktimes[0] < wrap.workers: LOG.info(_LI('Forking too fast, sleeping')) time.sleep(1) wrap.forktimes.pop(0) wrap.forktimes.append(time.time()) pid = os.fork() if pid == 0: launcher = self._child_process(wrap.service) while True: self._child_process_handle_signal() status, signo = self._child_wait_for_exit_or_signal(launcher) if not _is_sighup_and_daemon(signo): break launcher.restart() os._exit(status) LOG.info(_LI('Started child %d'), pid) wrap.children.add(pid) self.children[pid] = wrap return pid
def wait(self): """Loop waiting on children to die and respawning as necessary.""" LOG.debug('Full set of CONF:') CONF.log_opt_values(LOG, std_logging.DEBUG) try: while True: self.handle_signal() self._respawn_children() if self.sigcaught: signame = _signo_to_signame(self.sigcaught) LOG.info(_LI('Caught %s, stopping children'), signame) if not _is_sighup_and_daemon(self.sigcaught): break for pid in self.children: os.kill(pid, signal.SIGHUP) self.running = True self.sigcaught = None except eventlet.greenlet.GreenletExit: LOG.info(_LI("Wait called after thread killed. Cleaning up.")) for pid in self.children: try: os.kill(pid, signal.SIGTERM) except OSError as exc: if exc.errno != errno.ESRCH: raise # Wait for children to die if self.children: LOG.info(_LI('Waiting on %d children to exit'), len(self.children)) while self.children: self._wait_child()
def refresh_firewall(self, device_ids=None): LOG.info(_LI("Refresh firewall rules")) if not device_ids: device_ids = self.firewall.ports.keys() if not device_ids: LOG.info(_LI("No ports here to refresh firewall")) return if self.use_enhanced_rpc: devices_info = self.plugin_rpc.security_group_info_for_devices( self.context, device_ids) devices = devices_info['devices'] security_groups = devices_info['security_groups'] security_group_member_ips = devices_info['sg_member_ips'] else: devices = self.plugin_rpc.security_group_rules_for_devices( self.context, device_ids) with self.firewall.defer_apply(): for device in devices.values(): LOG.debug(_("Update port filter for %s"), device['device']) self.firewall.update_port_filter(device) if self.use_enhanced_rpc: LOG.debug("Update security group information for ports %s", devices.keys()) self._update_security_group_info( security_groups, security_group_member_ips)
def main(): """Main method for cleaning up OVS bridges. The utility cleans up the integration bridges used by Neutron. """ conf = setup_conf() conf() config.setup_logging() configuration_bridges = set([conf.ovs_integration_bridge, conf.external_network_bridge]) ovs_bridges = set(ovs_lib.get_bridges(conf.AGENT.root_helper)) available_configuration_bridges = configuration_bridges & ovs_bridges if conf.ovs_all_ports: bridges = ovs_bridges else: bridges = available_configuration_bridges # Collect existing ports created by Neutron on configuration bridges. # After deleting ports from OVS bridges, we cannot determine which # ports were created by Neutron, so port information is collected now. ports = collect_neutron_ports(available_configuration_bridges, conf.AGENT.root_helper) for bridge in bridges: LOG.info(_LI("Cleaning bridge: %s"), bridge) ovs = ovs_lib.OVSBridge(bridge, conf.AGENT.root_helper) ovs.delete_ports(all_ports=conf.ovs_all_ports) # Remove remaining ports created by Neutron (usually veth pair) delete_neutron_ports(ports, conf.AGENT.root_helper) LOG.info(_LI("OVS cleanup completed successfully"))
def check_foreign_keys(metadata): # This methods checks foreign keys that tables contain in models with # foreign keys that are in db. added_fks = [] dropped_fks = [] bind = op.get_bind() insp = sqlalchemy.engine.reflection.Inspector.from_engine(bind) # Get all tables from db db_tables = insp.get_table_names() # Get all tables from models model_tables = metadata.tables for table in db_tables: if table not in model_tables: continue # Get all necessary information about key of current table from db fk_db = dict((_get_fk_info_db(i), i['name']) for i in insp.get_foreign_keys(table)) fk_db_set = set(fk_db.keys()) # Get all necessary information about key of current table from models fk_models = dict((_get_fk_info_from_model(fk), fk) for fk in model_tables[table].foreign_keys) fk_models_set = set(fk_models.keys()) for key in (fk_db_set - fk_models_set): dropped_fks.append(('drop_key', fk_db[key], table)) LOG.info(_LI("Detected removed foreign key %(fk)r on " "table %(table)r"), {'fk': fk_db[key], 'table': table}) for key in (fk_models_set - fk_db_set): added_fks.append(('add_key', fk_models[key])) LOG.info(_LI("Detected added foreign key for column %(fk)r on " "table %(table)r"), {'fk': fk_models[key].column.name, 'table': table}) return (added_fks, dropped_fks)
def wait(self): """Loop waiting on children to die and respawning as necessary.""" systemd.notify_once() LOG.debug('Full set of CONF:') CONF.log_opt_values(LOG, std_logging.DEBUG) try: while True: self.handle_signal() self._respawn_children() # No signal means that stop was called. Don't clean up here. if not self.sigcaught: return signame = _signo_to_signame(self.sigcaught) LOG.info(_LI('Caught %s, stopping children'), signame) if not _is_sighup_and_daemon(self.sigcaught): break for pid in self.children: os.kill(pid, signal.SIGHUP) self.running = True self.sigcaught = None except eventlet.greenlet.GreenletExit: LOG.info(_LI("Wait called after thread killed. Cleaning up.")) self.stop()
def packet_in_handler(self, ev): """Check a packet-in message. Build and output an arp reply if a packet-in message is an arp packet. """ msg = ev.msg LOG.debug("packet-in msg %s", msg) datapath = msg.datapath if self.br is None: LOG.info(_LI("No bridge is set")) return if self.br.datapath.id != datapath.id: LOG.info(_LI("Unknown bridge %(dpid)s ours %(ours)s"), {"dpid": datapath.id, "ours": self.br.datapath.id}) return ofp = datapath.ofproto port = msg.match['in_port'] metadata = msg.match.get('metadata') # NOTE(yamamoto): Ryu packet library can raise various exceptions # on a corrupted packet. try: pkt = packet.Packet(msg.data) except Exception as e: LOG.debug("Unparsable packet: got exception %s", e) return LOG.debug("packet-in dpid %(dpid)s in_port %(port)s pkt %(pkt)s", {'dpid': dpid_lib.dpid_to_str(datapath.id), 'port': port, 'pkt': pkt}) if metadata is None: LOG.info(_LI("drop non tenant packet")) return network = metadata & meta.NETWORK_MASK pkt_ethernet = pkt.get_protocol(ethernet.ethernet) if not pkt_ethernet: LOG.debug("drop non-ethernet packet") return pkt_vlan = pkt.get_protocol(vlan.vlan) pkt_arp = pkt.get_protocol(arp.arp) if not pkt_arp: LOG.debug("drop non-arp packet") return arptbl = self._arp_tbl.get(network) if arptbl: if self._respond_arp(datapath, port, arptbl, pkt_ethernet, pkt_vlan, pkt_arp): return else: LOG.info(_LI("unknown network %s"), network) # add a flow to skip a packet-in to a controller. self.br.arp_passthrough(network=network, tpa=pkt_arp.dst_ip) # send an unknown arp packet to the table. self._send_unknown_packet(msg, port, ofp.OFPP_TABLE)
def delete_l2domains(self, resources): for l2dom_id in resources['l2domain']['delete']: try: self.get_subnet(self.context, l2dom_id) LOG.info(_LI("L2Domain %s found in neutron, so will not " "be deleted"), l2dom_id) except n_exc.SubnetNotFound: LOG.info(_LI("L2Domain %s not found in neutron, so " "will be deleted"), l2dom_id) self.nuageclient.delete_l2domain(l2dom_id)
def delete_security_groups(self, resources): for secgrp_id in resources['security']['secgroup']['delete']: try: self._get_security_group(self.context, secgrp_id) LOG.info(_LI("Secgrp %s found in neutron, so will not be " "deleted"), secgrp_id) except ext_sg.SecurityGroupNotFound: LOG.info(_LI("Secgrp %s not found in neutron, so will be " "deleted"), secgrp_id) self.nuageclient.delete_security_group(secgrp_id)
def delete_fips(self, resources): for fip_id in resources['fip']['delete']: try: self.get_floatingip(self.context, fip_id) LOG.info(_LI("FloatingIP %s found in neutron, so will not be " "deleted"), fip_id) except l3.FloatingIPNotFound: LOG.info(_LI("FloatingIP %s not found in neutron, so will " "be deleted"), fip_id) self.nuageclient.delete_fip(fip_id)
def delete_domainsubnets(self, resources): for domsubn_id in resources['domainsubnet']['add']: try: self.get_subnet(self.context, domsubn_id) LOG.info(_LI("Domain-Subnet %s found in neutron, so will not " "be deleted"), domsubn_id) except n_exc.SubnetNotFound: LOG.info(_LI("Domain-Subnet %s not found in neutron, so " "will be deleted"), domsubn_id) self.nuageclient.delete_domainsubnet(domsubn_id)
def delete_domains(self, resources): for domain_id in resources['domain']['delete']: try: self.get_router(self.context, domain_id) LOG.info(_LI("Domain %s found in neutron, so will not be " "deleted"), domain_id) except l3.RouterNotFound: LOG.info(_LI("Domain %s not found in neutron, so will be " "deleted"), domain_id) self.nuageclient.delete_domain(domain_id)
def delete_security_group_rules(self, resources): for secrule_id, secrules in resources['security']['secgrouprule'][ 'delete'].iteritems(): try: self._get_security_group_rule(self.context, secrule_id) LOG.info(_LI("Secrule %s found in neutron, so will not be " "deleted"), secrule_id) except ext_sg.SecurityGroupRuleNotFound: LOG.info(_LI("Secrule %s not found in neutron, so will be " "deleted"), secrule_id) self.nuageclient.delete_security_group_rule(secrules)
def _parse_networks(self, entries): self.flat_networks = entries if '*' in self.flat_networks: LOG.info(_LI("Arbitrary flat physical_network names allowed")) self.flat_networks = None elif not all(self.flat_networks): msg = _("physical network name is empty") raise exc.InvalidInput(error_message=msg) else: LOG.info(_LI("Allowable flat physical_network names: %s"), self.flat_networks)
def _create_snatport_for_subnet_if_not_exists(self, context, tenant_id, subnet_id, network_info): port = self._get_snatport_for_subnet(context, tenant_id, subnet_id) if not port: LOG.info(_LI("No SNAT port found for subnet %s. Creating one..."), subnet_id) port = self._create_snatport_for_subnet(context, tenant_id, subnet_id, ip_address=None) network_info['port_id'] = port['id'] network_info['snat_ip'] = port['fixed_ips'][0]['ip_address'] LOG.info(_LI("SNAT port: %r"), port)
def agent_updated(self, context, payload): """Handle the agent_updated notification event.""" if payload['admin_state_up'] != self.admin_state_up: self.admin_state_up = payload['admin_state_up'] if self.admin_state_up: self.needs_resync = True else: for pool_id in self.instance_mapping.keys(): LOG.info(_LI("Destroying pool %s due to agent disabling"), pool_id) self._destroy_pool(pool_id) LOG.info(_LI("Agent_updated by server side %s!"), payload)
def __init__(self): # Mapping from type name to DriverManager self.drivers = {} LOG.info(_LI("Configured type driver names: %s"), cfg.CONF.ml2.type_drivers) super(TypeManager, self).__init__('neutron.ml2.type_drivers', cfg.CONF.ml2.type_drivers, invoke_on_load=True) LOG.info(_LI("Loaded type driver names: %s"), self.names()) self._register_types() self._check_tenant_network_types(cfg.CONF.ml2.tenant_network_types)
def _check_valid_services(self, service): service_type = service.get("service_type").get("servicetype") if service_type not in s_constants.SUPPORT_SERVICE_TYPE: LOG.info(_LI("Service Type %(service_type)s is not support"), {"service_type": service_type}) return False device = service["device_dict"] if not self._dev_status.is_device_reachable(device): LOG.info(_LI("Service: %(id)s is on an unreachable " "hosting device. "), {"id": device["id"]}) return False return True
def __init__(self): # Ordered list of extension drivers, defining # the order in which the drivers are called. self.ordered_ext_drivers = [] LOG.info(_LI("Configured extension driver names: %s"), cfg.CONF.ml2.extension_drivers) super(ExtensionManager, self).__init__('neutron.ml2.extension_drivers', cfg.CONF.ml2.extension_drivers, invoke_on_load=True, name_order=True) LOG.info(_LI("Loaded extension driver names: %s"), self.names()) self._register_drivers()
def create_ipsec_site_connection(self, context, conn_info): """Creates an IPSec site-to-site connection on CSR. Create the PSK, IKE policy, IPSec policy, connection, static route, and (future) DPD. """ # Get all the IDs conn_id = conn_info['id'] psk_id = conn_id site_conn_id = conn_info['cisco']['site_conn_id'] ike_policy_id = conn_info['cisco']['ike_policy_id'] ipsec_policy_id = conn_info['cisco']['ipsec_policy_id'] LOG.debug('Creating IPSec connection %s', conn_id) # Get all the attributes needed to create try: psk_info = self.create_psk_info(psk_id, conn_info) ike_policy_info = self.create_ike_policy_info(ike_policy_id, conn_info) ipsec_policy_info = self.create_ipsec_policy_info(ipsec_policy_id, conn_info) connection_info = self.create_site_connection_info(site_conn_id, ipsec_policy_id, conn_info) routes_info = self.create_routes_info(site_conn_id, conn_info) except (CsrUnknownMappingError, CsrDriverMismatchError) as e: LOG.exception(e) return try: self.do_create_action('pre_shared_key', psk_info, conn_id, 'Pre-Shared Key') self.do_create_action('ike_policy', ike_policy_info, ike_policy_id, 'IKE Policy') self.do_create_action('ipsec_policy', ipsec_policy_info, ipsec_policy_id, 'IPSec Policy') self.do_create_action('ipsec_connection', connection_info, site_conn_id, 'IPSec Connection') # TODO(pcm): FUTURE - Do DPD for v1 and handle if >1 connection # and different DPD settings for route_id, route_info in routes_info: self.do_create_action('static_route', route_info, route_id, 'Static Route') except CsrResourceCreateFailure: self.do_rollback() LOG.info(_LI("FAILED: Create of IPSec site-to-site connection %s"), conn_id) else: LOG.info(_LI("SUCCESS: Created IPSec site-to-site connection %s"), conn_id)
def check_backlogged_hosting_devices(self): """"Checks the status of backlogged hosting devices. Skips newly spun up instances during their booting time as specified in the boot time parameter. :return A dict of the format: {'reachable': [<hd_id>,..], 'dead': [<hd_id>,..]} """ response_dict = {'reachable': [], 'dead': []} LOG.debug("Current Backlogged hosting devices: %s", self.backlog_hosting_devices.keys()) for hd_id in self.backlog_hosting_devices.keys(): hd = self.backlog_hosting_devices[hd_id]['hd'] if not timeutils.is_older_than(hd['created_at'], hd['booting_time']): LOG.info(_LI("Hosting device: %(hd_id)s @ %(ip)s hasn't " "passed minimum boot time. Skipping it. "), {'hd_id': hd_id, 'ip': hd['management_ip_address']}) continue LOG.info(_LI("Checking hosting device: %(hd_id)s @ %(ip)s for " "reachability."), {'hd_id': hd_id, 'ip': hd['management_ip_address']}) if _is_pingable(hd['management_ip_address']): hd.pop('backlog_insertion_ts', None) del self.backlog_hosting_devices[hd_id] response_dict['reachable'].append(hd_id) LOG.info(_LI("Hosting device: %(hd_id)s @ %(ip)s is now " "reachable. Adding it to response"), {'hd_id': hd_id, 'ip': hd['management_ip_address']}) else: LOG.info(_LI("Hosting device: %(hd_id)s @ %(ip)s still not " "reachable "), {'hd_id': hd_id, 'ip': hd['management_ip_address']}) if timeutils.is_older_than( hd['backlog_insertion_ts'], cfg.CONF.cfg_agent.hosting_device_dead_timeout): LOG.debug("Hosting device: %(hd_id)s @ %(ip)s hasn't " "been reachable for the last %(time)d seconds. " "Marking it dead.", {'hd_id': hd_id, 'ip': hd['management_ip_address'], 'time': cfg.CONF.cfg_agent. hosting_device_dead_timeout}) response_dict['dead'].append(hd_id) hd.pop('backlog_insertion_ts', None) del self.backlog_hosting_devices[hd_id] LOG.debug("Response: %s", response_dict) return response_dict
def treat_devices_added_or_updated(self, devices): resync = False all_ports = dict((p.normalized_port_name(), p) for p in self._get_ports(self.int_br) if p.is_neutron_port()) for device in devices: LOG.debug("Processing port %s", device) if device not in all_ports: # The port has disappeared and should not be processed # There is no need to put the port DOWN in the plugin as # it never went up in the first place LOG.info(_LI("Port %s was not found on the integration bridge " "and will therefore not be processed"), device) continue port = all_ports[device] try: details = self.plugin_rpc.get_device_details(self.context, device, self.agent_id) except Exception as e: LOG.debug("Unable to get port details for %(device)s: %(e)s", {'device': device, 'e': e}) resync = True continue if 'port_id' in details: LOG.info(_LI("Port %(device)s updated. Details: %(details)s"), {'device': device, 'details': details}) port.vif_mac = details.get('mac_address') self.treat_vif_port(port, details['port_id'], details['network_id'], details['network_type'], details['physical_network'], details['segmentation_id'], details['admin_state_up']) # update plugin about port status if details.get('admin_state_up'): LOG.debug("Setting status for %s to UP", device) self.plugin_rpc.update_device_up( self.context, device, self.agent_id, cfg.CONF.host) else: LOG.debug("Setting status for %s to DOWN", device) self.plugin_rpc.update_device_down( self.context, device, self.agent_id, cfg.CONF.host) LOG.info(_LI("Configuration for device %s completed."), device) else: LOG.warn(_LW("Device %s not defined on plugin"), device) if (port and port.ofport != -1): self.port_dead(port) return resync
def __init__(self): # Registered mechanism drivers, keyed by name. self.mech_drivers = {} # Ordered list of mechanism drivers, defining # the order in which the drivers are called. self.ordered_mech_drivers = [] LOG.info(_LI("Configured mechanism driver names: %s"), cfg.CONF.ml2.mechanism_drivers) super(MechanismManager, self).__init__('neutron.ml2.mechanism_drivers', cfg.CONF.ml2.mechanism_drivers, invoke_on_load=True, name_order=True) LOG.info(_LI("Loaded mechanism driver names: %s"), self.names()) self._register_mechanisms()
def synchronize(self, fipquota): LOG.info(_LI("Starting the sync between Neutron and VSD")) try: # Get all data to determine the resources to sync data = self._get_all_data() resources = self.nuageclient.get_resources_to_sync(data) # Sync all resources self._sync(resources, fipquota) except Exception as e: LOG.error(_LE("Cannot complete the sync between Neutron and VSD " "because of error:%s"), str(e)) return LOG.info(_LI("Sync between Neutron and VSD completed successfully"))
def delete_network_postcommit(self, mech_context): """Delete network which translates to removng portprofile from the switch. """ LOG.debug("delete_network_postcommit: called") network = mech_context.current network_id = network['id'] vlan_id = network['provider:segmentation_id'] tenant_id = network['tenant_id'] try: self._driver.delete_network(self._switch['address'], self._switch['username'], self._switch['password'], vlan_id) except Exception: LOG.exception(_LE("Brocade NOS driver: failed to delete network")) raise Exception( _("Brocade switch exception, " "delete_network_postcommit failed")) LOG.info(_LI("delete network (postcommit): %(network_id)s" " with vlan = %(vlan_id)s" " for tenant %(tenant_id)s"), {'network_id': network_id, 'vlan_id': vlan_id, 'tenant_id': tenant_id})
def delete_network_precommit(self, mech_context): """Delete Network from the plugin specific database table.""" LOG.debug("delete_network_precommit: called") network = mech_context.current network_id = network['id'] vlan_id = network['provider:segmentation_id'] tenant_id = network['tenant_id'] context = mech_context._plugin_context try: brocade_db.delete_network(context, network_id) except Exception: LOG.exception( _LE("Brocade Mechanism: failed to delete network in db")) raise Exception( _("Brocade Mechanism: delete_network_precommit failed")) LOG.info(_LI("delete network (precommit): %(network_id)s" " with vlan = %(vlan_id)s" " for tenant %(tenant_id)s"), {'network_id': network_id, 'vlan_id': vlan_id, 'tenant_id': tenant_id})
def security_groups_member_updated(self, security_groups): LOG.info(_LI("Security group " "member updated %r"), security_groups) self._security_group_updated(security_groups, 'security_group_source_groups')
def x(id): eventlet.greenthread.sleep(random.random()) LOG.info(_LI('spawned: %d'), id)
def launch_service(self, service, workers=1): wrap = ServiceWrapper(service, workers) LOG.info(_LI('Starting %d workers'), wrap.workers) while self.running and len(wrap.children) < wrap.workers: self._start_child(wrap)
def initialize(self): self._sync_vlan_allocations() LOG.info(_LI("VlanTypeDriver initialization complete"))
def _process_routers(self, routers, removed_routers, device_id=None, all_routers=False): """Process the set of routers. Iterating on the set of routers received and comparing it with the set of routers already in the routing service helper, new routers which are added are identified. Before processing check the reachability (via ping) of hosting device where the router is hosted. If device is not reachable it is backlogged. For routers which are only updated, call `_process_router()` on them. When all_routers is set to True (because of a full sync), this will result in the detection and deletion of routers which have been removed. Whether the router can only be assigned to a particular hosting device is decided and enforced by the plugin. No checks are done here. :param routers: The set of routers to be processed :param removed_routers: the set of routers which where removed :param device_id: Id of the hosting device :param all_routers: Flag for specifying a partial list of routers :return: None """ try: if all_routers: prev_router_ids = set(self.router_info) else: prev_router_ids = set(self.router_info) & set( [router['id'] for router in routers]) cur_router_ids = set() for r in routers: try: if not r['admin_state_up']: continue cur_router_ids.add(r['id']) hd = r['hosting_device'] if not self._dev_status.is_hosting_device_reachable(hd): LOG.info(_LI("Router: %(id)s is on an unreachable " "hosting device. "), {'id': r['id']}) continue if r['id'] not in self.router_info: self._router_added(r['id'], r) ri = self.router_info[r['id']] ri.router = r self._process_router(ri) except KeyError as e: LOG.exception(_LE("Key Error, missing key: %s"), e) self.updated_routers.add(r['id']) continue except cfg_exceptions.DriverException as e: LOG.exception(_LE("Driver Exception on router:%(id)s. " "Error is %(e)s"), {'id': r['id'], 'e': e}) self.updated_routers.update(r['id']) continue # identify and remove routers that no longer exist for router_id in prev_router_ids - cur_router_ids: self._router_removed(router_id) if removed_routers: for router in removed_routers: self._router_removed(router['id']) except Exception: LOG.exception(_LE("Exception in processing routers on device:%s"), device_id) self.sync_devices.add(device_id)
def check_backlogged_hosting_devices(self): """"Checks the status of backlogged hosting devices. Skips newly spun up instances during their booting time as specified in the boot time parameter. :return A dict of the format: {'reachable': [<hd_id>,..], 'dead': [<hd_id>,..]} """ response_dict = {'reachable': [], 'dead': []} LOG.debug("Current Backlogged hosting devices: %s", self.backlog_hosting_devices.keys()) for hd_id in self.backlog_hosting_devices.keys(): hd = self.backlog_hosting_devices[hd_id]['hd'] if not timeutils.is_older_than(hd['created_at'], hd['booting_time']): LOG.info( _LI("Hosting device: %(hd_id)s @ %(ip)s hasn't " "passed minimum boot time. Skipping it. "), { 'hd_id': hd_id, 'ip': hd['management_ip_address'] }) continue LOG.info( _LI("Checking hosting device: %(hd_id)s @ %(ip)s for " "reachability."), { 'hd_id': hd_id, 'ip': hd['management_ip_address'] }) if _is_pingable(hd['management_ip_address']): hd.pop('backlog_insertion_ts', None) del self.backlog_hosting_devices[hd_id] response_dict['reachable'].append(hd_id) LOG.info( _LI("Hosting device: %(hd_id)s @ %(ip)s is now " "reachable. Adding it to response"), { 'hd_id': hd_id, 'ip': hd['management_ip_address'] }) else: LOG.info( _LI("Hosting device: %(hd_id)s @ %(ip)s still not " "reachable "), { 'hd_id': hd_id, 'ip': hd['management_ip_address'] }) if timeutils.is_older_than( hd['backlog_insertion_ts'], cfg.CONF.cfg_agent.hosting_device_dead_timeout): LOG.debug( "Hosting device: %(hd_id)s @ %(ip)s hasn't " "been reachable for the last %(time)d seconds. " "Marking it dead.", { 'hd_id': hd_id, 'ip': hd['management_ip_address'], 'time': cfg.CONF.cfg_agent.hosting_device_dead_timeout }) response_dict['dead'].append(hd_id) hd.pop('backlog_insertion_ts', None) del self.backlog_hosting_devices[hd_id] LOG.debug("Response: %s", response_dict) return response_dict
def security_groups_rule_updated(self, security_groups): LOG.info(_LI("Security group " "rule updated %r"), security_groups) self._security_group_updated(security_groups, 'security_groups')
def _remove_snatport_for_subnet(self, context, tenant_id, subnet_id): port = self._get_snatport_for_subnet(context, tenant_id, subnet_id) if port: self.plugin._core_plugin.delete_port(context, port['id']) LOG.info(_LI("Removed SNAT port: %r"), port)
def disable_security_group_extension_by_config(aliases): if not is_firewall_enabled(): LOG.info(_LI('Disabled security-group extension.')) _disable_extension('security-group', aliases) LOG.info(_LI('Disabled allowed-address-pairs extension.')) _disable_extension('allowed-address-pairs', aliases)