def remove_empty_bridges(): try: interface_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error("Parsing physical_interface_mappings failed: %s.", e) sys.exit(1) LOG.info("Interface mappings: %s.", interface_mappings) try: bridge_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.bridge_mappings) except ValueError as e: LOG.error("Parsing bridge_mappings failed: %s.", e) sys.exit(1) LOG.info("Bridge mappings: %s.", bridge_mappings) lb_manager = linuxbridge_neutron_agent.LinuxBridgeManager( bridge_mappings, interface_mappings) bridge_names = lb_manager.get_deletable_bridges() for bridge_name in bridge_names: if lb_manager.get_tap_devices_count(bridge_name): continue try: lb_manager.delete_bridge(bridge_name) LOG.info("Linux bridge %s deleted", bridge_name) except RuntimeError: LOG.exception("Linux bridge %s delete failed", bridge_name) LOG.info("Linux bridge cleanup completed successfully")
def main(): common_config.init(sys.argv[1:]) common_config.setup_logging() agent_config.setup_privsep() try: interface_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error("Parsing physical_interface_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Interface mappings: %s", interface_mappings) try: bridge_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.bridge_mappings) except ValueError as e: LOG.error("Parsing bridge_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Bridge mappings: %s", bridge_mappings) manager = LinuxBridgeManager(bridge_mappings, interface_mappings) linuxbridge_capabilities.register() polling_interval = cfg.CONF.AGENT.polling_interval quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout, constants.AGENT_TYPE_LINUXBRIDGE, LB_AGENT_BINARY) setup_profiler.setup("neutron-linuxbridge-agent", cfg.CONF.host) LOG.info("Agent initialized successfully, now running... ") launcher = service.launch(cfg.CONF, agent, restart_method='mutate') launcher.wait()
def main(): common_config.init(sys.argv[1:]) common_config.setup_logging() try: interface_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error( "Parsing physical_interface_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Interface mappings: %s", interface_mappings) try: bridge_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.bridge_mappings) except ValueError as e: LOG.error("Parsing bridge_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Bridge mappings: %s", bridge_mappings) manager = LinuxBridgeManagerBaGPipe(bridge_mappings, interface_mappings) polling_interval = cfg.CONF.AGENT.polling_interval quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout, n_const.AGENT_TYPE_LINUXBRIDGE, LB_BAGPIPE_AGENT_BINARY) LOG.info("Agent initialized successfully, now running... ") launcher = service.launch(cfg.CONF, agent) launcher.wait()
def main(): common_config.init(sys.argv[1:]) common_config.setup_logging() agent_config.setup_privsep() try: interface_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error(_LE("Parsing physical_interface_mappings failed: %s. " "Agent terminated!"), e) sys.exit(1) LOG.info(_LI("Interface mappings: %s"), interface_mappings) try: bridge_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.bridge_mappings) except ValueError as e: LOG.error(_LE("Parsing bridge_mappings failed: %s. " "Agent terminated!"), e) sys.exit(1) LOG.info(_LI("Bridge mappings: %s"), bridge_mappings) manager = LinuxBridgeManager(bridge_mappings, interface_mappings) linuxbridge_capabilities.register() polling_interval = cfg.CONF.AGENT.polling_interval quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout, constants.AGENT_TYPE_LINUXBRIDGE, LB_AGENT_BINARY) setup_profiler.setup("neutron-linuxbridge-agent", cfg.CONF.host) LOG.info(_LI("Agent initialized successfully, now running... ")) launcher = service.launch(cfg.CONF, agent) launcher.wait()
def test_device_mappings_with_spaces(self): cfg.CONF.set_override('physical_device_mappings', self.DEVICE_MAPPING_WITH_SPACES_LIST, 'SRIOV_NIC') device_mappings = helpers.parse_mappings( cfg.CONF.SRIOV_NIC.physical_device_mappings, unique_keys=False) self.assertEqual(self.DEVICE_MAPPING, device_mappings)
def __init__(self, config): LOG.debug("Get OVS bridge mappings") mappings = helpers.parse_mappings(config.OVS.bridge_mappings) self.bridges = [ ovs_lib.OVSBridge(bridge) for bridge in mappings.values() ] self.int_br = ovs_lib.OVSBridge(config.OVS.integration_bridge)
def min_tx_rate_support(): device_mappings = helpers.parse_mappings( cfg.CONF.SRIOV_NIC.physical_device_mappings, unique_keys=False) devices_to_test = set() for devices_in_physnet in device_mappings.values(): for device in devices_in_physnet: devices_to_test.add(device) # NOTE(ralonsoh): the VF used by default is 0. Each SR-IOV configured # NIC should have configured at least 1 VF. VF_NUM = 0 devices_without_support = set() for device in devices_to_test: try: ip_link = ip_lib.IpLinkCommand(device) # NOTE(ralonsoh): to set min_tx_rate, first is needed to set # max_tx_rate and max_tx_rate >= min_tx_rate. vf_config = {'vf': VF_NUM, 'rate': {'min_tx_rate': int(400), 'max_tx_rate': int(500)}} ip_link.set_vf_feature(vf_config) vf_config = {'vf': VF_NUM, 'rate': {'min_tx_rate': 0, 'max_tx_rate': 0}} ip_link.set_vf_feature(vf_config) except ip_lib.InvalidArgument: devices_without_support.add(device) if devices_without_support: LOG.debug('The following NICs do not support "min_tx_rate": %s', devices_without_support) return False return True
def __init__(self): try: self.physnet_mtus = helpers.parse_mappings( cfg.CONF.ml2.physical_network_mtus, unique_values=False) except Exception as e: LOG.error("Failed to parse physical_network_mtus: %s", e) self.physnet_mtus = []
def main(): register_f5_opts(cfg.CONF) agent_config.register_agent_state_opts_helper(cfg.CONF) common_config.init(sys.argv[1:]) common_config.setup_logging() try: device_mappings = helpers.parse_mappings( cfg.CONF.F5.physical_device_mappings) except ValueError as e: LOG.error( "Parsing physical_device_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Device mappings: %s", device_mappings) polling_interval = cfg.CONF.AGENT.polling_interval quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout f5manager = F5Manager(device_mappings) agent = ca.CommonAgentLoop(f5manager, polling_interval, quitting_rpc_timeout, constants.AGENT_TYPE_F5, constants.AGENT_BINARY) LOG.info('networking-f5-agent initialized, starting up...') if cfg.CONF.F5.prometheus: start_http_server(8000) service.launch(cfg.CONF, agent, restart_method='mutate').wait()
def main(): eventlet.monkey_patch() common_config.init(sys.argv[1:]) kaloom_config.register_kaloomkvs_opts() common_config.setup_logging() agent_config.setup_privsep() try: bridge_mappings = helpers.parse_mappings( cfg.CONF.kaloom_kvs.bridge_mappings) except ValueError as e: LOG.error("Parsing bridge_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Bridge mappings: %s", bridge_mappings) try: vhostuser_socket_dir = cfg.CONF.kaloom_kvs.vhostuser_socket_dir except ValueError as e: LOG.error( "Parsing vhostuser_socket_dir failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("vhostuser_socket_dir: %s", vhostuser_socket_dir) dir_exists = os.path.exists(vhostuser_socket_dir) if dir_exists is False: #creating the dir with right selinux context is not preferred. #the dir should be pre-configured. LOG.error( "vhostuser_socket_dir %s does not exists." "Agent terminated!", vhostuser_socket_dir) sys.exit(1) # is it compliance with permission status, msg = kvs_utils.check_permission(vhostuser_socket_dir) if status is not True: LOG.error("%s. Agent terminated!", msg) sys.exit(1) host = cfg.CONF.host kvs_id = 'kvs-agent-%s' % host manager = KaloomKVSManager(bridge_mappings, kvs_id, vhostuser_socket_dir) kaloomkvs_capabilities.register() polling_interval = cfg.CONF.AGENT.polling_interval quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout LOG.info("polling_interval: %s", polling_interval) LOG.info("quitting_rpc_timeout: %s", quitting_rpc_timeout) agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout, a_const.AGENT_TYPE_KALOOM_KVS, a_const.KVS_AGENT_BINARY) setup_profiler.setup("neutron-kaloom-agent", cfg.CONF.host) LOG.info("Agent initialized successfully, now running... ") launcher = service.launch(cfg.CONF, agent) launcher.wait()
def __init__(self): try: self.physnet_mtus = helpers.parse_mappings( cfg.CONF.ml2.physical_network_mtus, unique_values=False ) except Exception as e: LOG.error(_LE("Failed to parse physical_network_mtus: %s"), e) self.physnet_mtus = []
def parse_interface_mappings(): try: interface_mappings = helpers.parse_mappings(cfg.CONF.macvtap.physical_interface_mappings) LOG.info(_LI("Interface mappings: %s"), interface_mappings) return interface_mappings except ValueError as e: LOG.error(_LE("Parsing physical_interface_mappings failed: %s. " "Agent terminated!"), e) sys.exit(1)
def parse(self): """Parses device_mappings and exclude_devices. Parse and validate the consistency in both mappings """ self.device_mappings = helpers.parse_mappings(cfg.CONF.SRIOV_NIC.physical_device_mappings, unique_keys=False) self.exclude_devices = config.parse_exclude_devices(cfg.CONF.SRIOV_NIC.exclude_devices) self._validate()
def _create_l2_agents(self): for name, host in six.iteritems(self._hosts): iface = self._interfaces[name] mappings = ['%s:%s' % (p, iface['uuid']) for p in iface['providernets'].split(',')] mappings_dict = lib_helpers.parse_mappings(mappings, unique_values=False) self._register_avs_agent( host=name, mappings=mappings_dict)
def parse(self): """Parses device_mappings and exclude_devices. Parse and validate the consistency in both mappings """ self.device_mappings = helpers.parse_mappings( cfg.CONF.SRIOV_NIC.physical_device_mappings, unique_keys=False) self.exclude_devices = config.parse_exclude_devices( cfg.CONF.SRIOV_NIC.exclude_devices) self._validate()
def run(self, event, row, old): host = row.hostname phy_nets = [] if event != self.ROW_DELETE: bridge_mappings = row.external_ids.get('ovn-bridge-mappings', '') mapping_dict = helpers.parse_mappings(bridge_mappings.split(',')) phy_nets = list(mapping_dict) self.driver.update_segment_host_mapping(host, phy_nets) if ovn_config.is_ovn_l3(): self.l3_plugin.schedule_unhosted_gateways()
def parse_interface_mappings(): try: interface_mappings = helpers.parse_mappings( cfg.CONF.macvtap.physical_interface_mappings) LOG.info(_LI("Interface mappings: %s"), interface_mappings) return interface_mappings except ValueError as e: LOG.error( _LE("Parsing physical_interface_mappings failed: %s. " "Agent terminated!"), e) sys.exit(1)
def run(self, event, row, old): host = row.hostname phy_nets = [] if event != self.ROW_DELETE: bridge_mappings = row.external_ids.get('ovn-bridge-mappings', '') mapping_dict = helpers.parse_mappings(bridge_mappings.split(',')) phy_nets = list(mapping_dict) self.driver.update_segment_host_mapping(host, phy_nets) if ovn_config.is_ovn_l3(): self.l3_plugin.schedule_unhosted_routers()
def _parse_hypervisors(cms_options): for cms_option in cms_options: if ovn_const.RP_HYPERVISORS in cms_option: hypervisors = cms_option.split('=')[1] break else: return if hypervisors: return helpers.parse_mappings(hypervisors.split(';'), unique_values=False)
def main(): common_config.register_common_config_options() common_config.init(sys.argv[1:]) common_config.setup_logging() agent_config.setup_privsep() service_conf.register_service_opts(service_conf.RPC_EXTRA_OPTS, cfg.CONF) try: interface_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.physical_interface_mappings) except ValueError as e: LOG.error( "Parsing physical_interface_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Interface mappings: %s", interface_mappings) try: bridge_mappings = helpers.parse_mappings( cfg.CONF.LINUX_BRIDGE.bridge_mappings) except ValueError as e: LOG.error("Parsing bridge_mappings failed: %s. " "Agent terminated!", e) sys.exit(1) LOG.info("Bridge mappings: %s", bridge_mappings) manager = LinuxBridgeManager(bridge_mappings, interface_mappings) linuxbridge_capabilities.register() polling_interval = cfg.CONF.AGENT.polling_interval quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout, constants.AGENT_TYPE_LINUXBRIDGE, constants.AGENT_PROCESS_LINUXBRIDGE) setup_profiler.setup(constants.AGENT_PROCESS_LINUXBRIDGE, cfg.CONF.host) LOG.info("Agent initialized successfully, now running... ") launcher = service.launch(cfg.CONF, agent, restart_method='mutate') launcher.wait()
def parse(self): """Parses device_mappings and exclude_devices. Parse and validate the consistency in both mappings """ self.device_mappings = helpers.parse_mappings( cfg.CONF.SRIOV_NIC.physical_device_mappings, unique_keys=False) self.exclude_devices = config.parse_exclude_devices( cfg.CONF.SRIOV_NIC.exclude_devices) self.rp_bandwidths = place_utils.parse_rp_bandwidths( cfg.CONF.SRIOV_NIC.resource_provider_bandwidths) self.rp_inventory_defaults = place_utils.parse_rp_inventory_defaults( cfg.CONF.SRIOV_NIC.resource_provider_inventory_defaults) self._validate()
def run(self, event, row, old): host = row.hostname phy_nets = [] if event != self.ROW_DELETE: bridge_mappings = row.external_ids.get('ovn-bridge-mappings', '') mapping_dict = helpers.parse_mappings(bridge_mappings.split(','), unique_values=False) phy_nets = list(mapping_dict) self.driver.update_segment_host_mapping(host, phy_nets) if utils.is_ovn_l3(self.l3_plugin): self.l3_plugin.schedule_unhosted_gateways() self.handle_ha_chassis_group_changes(event, row, old)
def parse_interface_mappings(): if not cfg.CONF.macvtap.physical_interface_mappings: LOG.error("No physical_interface_mappings provided, but at least " "one mapping is required. Agent terminated!") sys.exit(1) try: interface_mappings = helpers.parse_mappings( cfg.CONF.macvtap.physical_interface_mappings) LOG.info("Interface mappings: %s", interface_mappings) return interface_mappings except ValueError as e: LOG.error("Parsing physical_interface_mappings failed: %s. " "Agent terminated!", e) sys.exit(1)
def parse_interface_mappings(): if not cfg.CONF.macvtap.physical_interface_mappings: LOG.error(_LE("No physical_interface_mappings provided, but at least " "one mapping is required. Agent terminated!")) sys.exit(1) try: interface_mappings = helpers.parse_mappings( cfg.CONF.macvtap.physical_interface_mappings) LOG.info(_LI("Interface mappings: %s"), interface_mappings) return interface_mappings except ValueError as e: LOG.error(_LE("Parsing physical_interface_mappings failed: %s. " "Agent terminated!"), e) sys.exit(1)
def initialize(self, connection, driver_type): """Perform FDB Agent Extension initialization.""" valid_driver_types = (linux_bridge_constants.EXTENSION_DRIVER_TYPE, ovs_constants.EXTENSION_DRIVER_TYPE) if driver_type not in valid_driver_types: LOG.error(_LE('FDB extension is only supported for OVS and ' 'linux bridge agent, currently uses ' '%(driver_type)s'), {'driver_type': driver_type}) sys.exit(1) self.device_mappings = helpers.parse_mappings( cfg.CONF.FDB.shared_physical_device_mappings, unique_keys=False) devices = self._get_devices() if not devices: LOG.error(_LE('Invalid configuration provided for FDB extension: ' 'no physical devices')) sys.exit(1) self.fdb_tracker = self.FdbTableTracker(devices)
def create_agent_config_map(config): """Create a map of agent config parameters. :param config: an instance of cfg.CONF :returns: a map of agent configuration parameters """ try: bridge_mappings = helpers.parse_mappings( config.ML2_VMWARE.network_maps, unique_values=False) except ValueError as e: raise ValueError(_("Parsing network_maps failed: %s.") % e) kwargs = dict( vsphere_hostname=config.ML2_VMWARE.vsphere_hostname, vsphere_login=config.ML2_VMWARE.vsphere_login, vsphere_password=config.ML2_VMWARE.vsphere_password, bridge_mappings=bridge_mappings, polling_interval=config.DVS_AGENT.polling_interval, ) return kwargs
def run(self, event, row, old): host = row.hostname phy_nets = [] if event != self.ROW_DELETE: bridge_mappings = row.external_ids.get('ovn-bridge-mappings', '') mapping_dict = helpers.parse_mappings(bridge_mappings.split(','), unique_values=False) phy_nets = list(mapping_dict) self.driver.update_segment_host_mapping(host, phy_nets) if utils.is_ovn_l3(self.l3_plugin): # If chassis lost physnet or has been # deleted we can limit the scope and # reschedule only ports from this chassis. # In other cases we need to reschedule all gw ports. kwargs = {'event_from_chassis': None} if event == self.ROW_DELETE: kwargs['event_from_chassis'] = row.name elif event == self.ROW_UPDATE: old_mappings = old.external_ids.get('ovn-bridge-mappings', set()) or set() new_mappings = row.external_ids.get('ovn-bridge-mappings', set()) or set() if old_mappings: old_mappings = set(old_mappings.split(',')) if new_mappings: new_mappings = set(new_mappings.split(',')) mappings_removed = old_mappings - new_mappings mappings_added = new_mappings - old_mappings if mappings_removed and not mappings_added: # Mapping has been only removed. So we can # limit scope of rescheduling only to impacted # gateway chassis. kwargs['event_from_chassis'] = row.name self.l3_plugin.schedule_unhosted_gateways(**kwargs) self.handle_ha_chassis_group_changes(event, row, old)
def initialize(self, host, conf, agent_state): ovs_config = conf.OVS try: bridge_mappings = helpers.parse_mappings( ovs_config.bridge_mappings) except ValueError as e: raise ValueError(_("Parsing bridge_mappings failed: %s.") % e) self.int_br_device_count = 0 self.int_br = ovs_lib.OVSBridge(ovs_config.integration_bridge, ovs_config.datapath_type) self.fabric_br = ovs_lib.OVSBridge(conf.OPFLEX.fabric_bridge, ovs_config.datapath_type) self.local_ip = ovs_config.local_ip self.setup_integration_bridge() agent_state['agent_type'] = ofcst.AGENT_TYPE_OPFLEX_OVS if 'configurations' not in agent_state: agent_state['configurations'] = {} agent_state['configurations']['bridge_mappings'] = bridge_mappings agent_state['configurations']['datapath_type'] = ( ovs_config.datapath_type) agent_state['configurations']['vhostuser_socket_dir'] = ( ovs_config.vhostuser_socket_dir) return self, agent_state
def parse_mappings(mapping_list, unique_values=True, unique_keys=True): return helpers.parse_mappings(mapping_list, unique_values=unique_values, unique_keys=unique_keys)
def _get_existing_device(self): device_mappings = helpers.parse_mappings( cfg.CONF.FDB.shared_physical_device_mappings, unique_keys=False) DEVICES = six.next(six.itervalues(device_mappings)) return DEVICES[0]
def _get_chassis_physnets(self, chassis): bridge_mappings = chassis.external_ids.get('ovn-bridge-mappings', '') mapping_dict = helpers.parse_mappings(bridge_mappings.split(','), unique_values=False) return list(mapping_dict.keys())
def _parse_bridge_mappings(self, bridge_mappings): try: return helpers.parse_mappings(bridge_mappings) except ValueError: LOG.exception("Failed to parse bridge mapping") raise
def _parse_hypervisors(cms_options): hyperv = _parse_placement_option(ovn_const.RP_HYPERVISORS, cms_options) if not hyperv: return {} return helpers.parse_mappings(hyperv.split(';'), unique_values=False)
def _parse_bridge_mappings(chassis): bridge_mappings = chassis.external_ids.get('ovn-bridge-mappings', '') bridge_mappings = helpers.parse_mappings(bridge_mappings.split(','), unique_values=False) return {k: [v] for k, v in bridge_mappings.items()}
def _parse_bridge_mappings(self, bridge_mappings): try: return helpers.parse_mappings(bridge_mappings) except ValueError as e: raise ValueError(_("Parsing bridge_mappings failed: %s.") % e)
def _get_chassis_physnets(self, chassis): bridge_mappings = chassis.external_ids.get('ovn-bridge-mappings', '') mapping_dict = helpers.parse_mappings(bridge_mappings.split(',')) return mapping_dict.keys()