vpp - Vector Packet Processing

Age	Commit message (Expand)	Author	Files	Lines
2018-11-22	Add RFC5424 syslog protocol support (VPP-1139)	Matus Fabian	1	-0/+1
2018-10-17	Update to doxygen documentation for release 18.10	Marco Varlese	1	-0/+2
2018-08-03	API: Remove legacy vlibsocket code.	Ole Troan	1	-1/+0
2018-04-30	Add reference to 18.04 test framework documentation	Chris Luke	1	-1/+3
2018-04-04	Doc updates prior to branch	Chris Luke	2	-5/+9
2018-02-02	Add link to 18.01 test framework documentation.	Dave Wallace	1	-0/+1
2018-01-30	VPP-899: Run VPP under SELinux	Billy McFall	2	-1/+2
2018-01-24	docs: Clean up TOC	Dave Wallace	1	-0/+2
2017-12-15	apps: refactor uri and update build infra	Florin Coras	1	-1/+0
2017-11-03	Add C++ files to Doxygen	Chris Luke	1	-1/+1
2017-09-28	General documentation updates	Chris Luke	6	-5/+23
2017-09-25	Add binary API documentation	Dave Barach	1	-0/+1
2017-06-22	NAT64: documentation	Matus Fabian	1	-0/+1
2017-06-09	Sample plugin: Add sample plugin documentation	Ray Kinsella	2	-2/+2
2017-05-30	Flowprobe: Stateful flows and IPv6, L4 recording	Ole Troan	1	-1/+1
2017-05-10	doxygen: Fix some paths	Chris Luke	1	-1/+3
2017-05-05	First commit SR MPLS	Pablo Camarillo	1	-0/+1
2017-03-29	Bugfixing and documentation for SRv6	Pablo Camarillo	2	-9/+10
2017-02-22	Add ref to test framework docs in doxygen output.	Dave Wallace	2	-5/+8
2017-02-02	Added support for openSUSE	Marco Varlese	1	-1/+4
2017-01-11	Remove vcgn plugin	Damjan Marion	1	-2/+1
2017-01-10	Revert "vppctl: bash completion for vppctl commands"	Damjan Marion	1	-8/+17
2017-01-09	vppctl: bash completion for vppctl commands	Padraig Connolly	1	-17/+8
2017-01-01	Move java,lua api and remaining plugins to src/	Damjan Marion	1	-4/+3
2016-12-28	Repair Doxygen build infrastructure	Chris Luke	2	-11/+29
2016-11-28	Add support for using documentation siphons in multiple ways	Chris Luke	19	-32/+199
2016-11-28	dpdk: add ipsec cryptodev support	Sergio Gonzalez Monroy	1	-0/+1
2016-10-27	Per-packet IPFIX record generation plugin	Dave Barach	1	-0/+1
2016-10-04	Minor tweaks to hqos doc	Chris Luke	1	-3/+4
2016-09-27	Fix missing output in generated CLI/config	Chris Luke	3	-7/+8
2016-09-23	Enable doc building on MacOS	Chris Luke	1	-1/+25
2016-09-21	Refactor pre-Doxy siphon scripts; VPP-396	Chris Luke	24	-657/+1486
2016-09-21	Move doxytags file to html output directory	Chris Luke	1	-1/+1
2016-09-21	Copy the 16.09 release notes to master	Chris Luke	1	-0/+1
2016-09-20	Add structure to some of the documentation; VPP-223	Chris Luke	2	-1/+15
2016-09-09	Check for zero-sized Graphvix config file on Ubuntu; VPP-396	Chris Luke	1	-1/+2
2016-09-09	On Ubuntu check for graphviz system config	Chris Luke	1	-0/+3
2016-09-07	VPP-346 Improve Doxygen include path mechanism	Chris Luke	2	-23/+55
2016-09-06	VPP-346 More VPP doc fixes	Chris Luke	3	-15/+48
2016-09-02	VPP-221 Improve doxygen dependency check	Chris Luke	1	-1/+5
2016-09-01	VPP-346 A swathe of doc fixes	Chris Luke	4	-16/+94
2016-08-31	VPP-221 Loosen Doxygen CLI command struct parser	Chris Luke	2	-1/+2
2016-08-31	VPP-221 CLI auto-documentation infrastructure	Chris Luke	6	-5/+793
2016-08-06	Add DPDK definition to DOXYGEN	Keith Burns (alagalah)	1	-2/+3
2016-07-26	Fix missing include dirs in doxygen	Chris Luke	1	-1/+1
2016-07-07	Add some doxygen tags	Dave Barach	1	-0/+1
2016-05-16	VPP-57 Add missing license headers in doc files	Chris Luke	1	-0/+22
2016-05-15	VPP-62 Add a doxy filter to enable vpe.api doc	Chris Luke	3	-5/+67
2016-05-13	VPP-57 Add Doxygen to VPP	Chris Luke	6	-0/+2717

# Copyright (c) 2016 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Library that supports Auto Configuration.""" from __future__ import absolute_import, division, print_function import logging import os import re from ipaddress import ip_address import yaml from vpplib.VPPUtil import VPPUtil from vpplib.VppPCIUtil import VppPCIUtil from vpplib.VppHugePageUtil import VppHugePageUtil from vpplib.CpuUtils import CpuUtils from vpplib.VppGrubUtil import VppGrubUtil from vpplib.QemuUtils import QemuUtils # Python2/3 compatible try: input = raw_input # noqa except NameError: pass __all__ = ["AutoConfig"] # Constants MIN_SYSTEM_CPUS = 2 MIN_TOTAL_HUGE_PAGES = 1024 MAX_PERCENT_FOR_HUGE_PAGES = 70 IPERFVM_XML = 'configs/iperf-vm.xml' IPERFVM_IMAGE = 'images/xenial-mod.img' IPERFVM_ISO = 'configs/cloud-config.iso' class AutoConfig(object): """Auto Configuration Tools""" def __init__(self, rootdir, filename, clean=False): """ The Auto Configure class. :param rootdir: The root directory for all the auto configuration files :param filename: The autoconfiguration file :param clean: When set initialize the nodes from the auto-config file :type rootdir: str :type filename: str :type clean: bool """ self._autoconfig_filename = rootdir + filename self._rootdir = rootdir self._metadata = {} self._nodes = {} self._vpp_devices_node = {} self._hugepage_config = "" self._clean = clean self._loadconfig() self._sockfilename = "" def get_nodes(self): """ Returns the nodes dictionary. :returns: The nodes :rtype: dictionary """ return self._nodes @staticmethod def _autoconfig_backup_file(filename): """ Create a backup file. :param filename: The file to backup :type filename: str """ # Does a copy of the file exist, if not create one ofile = filename + '.orig' (ret, stdout, stderr) = VPPUtil.exec_command('ls {}'.format(ofile)) if ret != 0: logging.debug(stderr) if stdout.strip('\n') != ofile: cmd = 'sudo cp {} {}'.format(filename, ofile) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) # noinspection PyBroadException @staticmethod def _ask_user_ipv4(): """ Asks the user for a number within a range. default is returned if return is entered. :returns: IP address with cidr :rtype: str """ while True: answer = input("Please enter the IPv4 Address [n.n.n.n/n]: ") try: ipinput = answer.split('/') ipaddr = ip_address(ipinput[0]) if len(ipinput) > 1: plen = answer.split('/')[1] else: answer = input("Please enter the netmask [n.n.n.n]: ") plen = ip_address(answer).netmask_bits() return '{}/{}'.format(ipaddr, plen) except None: print("Please enter a valid IPv4 address.") @staticmethod def _ask_user_range(question, first, last, default): """ Asks the user for a number within a range. default is returned if return is entered. :param question: Text of a question. :param first: First number in the range :param last: Last number in the range :param default: The value returned when return is entered :type question: string :type first: int :type last: int :type default: int :returns: The answer to the question :rtype: int """ while True: answer = input(question) if answer == '': answer = default break if re.findall(r'[0-9+]', answer): if int(answer) in range(first, last + 1): break else: print("Please a value between {} and {} or Return.". format(first, last)) else: print("Please a number between {} and {} or Return.". format(first, last)) return int(answer) @staticmethod def _ask_user_yn(question, default): """ Asks the user for a yes or no question. :param question: Text of a question. :param default: The value returned when return is entered :type question: string :type default: string :returns: The answer to the question :rtype: string """ input_valid = False default = default.lower() answer = '' while not input_valid: answer = input(question) if answer == '': answer = default if re.findall(r'[YyNn]', answer): input_valid = True answer = answer[0].lower() else: print("Please answer Y, N or Return.") return answer def _loadconfig(self): """ Load the testbed configuration, given the auto configuration file. """ # Get the Topology, from the topology layout file topo = {} with open(self._autoconfig_filename, 'r') as stream: try: topo = yaml.load(stream) if 'metadata' in topo: self._metadata = topo['metadata'] except yaml.YAMLError as exc: raise RuntimeError( "Couldn't read the Auto config file {}.".format( self._autoconfig_filename, exc)) systemfile = self._rootdir + self._metadata['system_config_file'] if self._clean is False and os.path.isfile(systemfile): with open(systemfile, 'r') as sysstream: try: systopo = yaml.load(sysstream) if 'nodes' in systopo: self._nodes = systopo['nodes'] except yaml.YAMLError as sysexc: raise RuntimeError( "Couldn't read the System config file {}.".format( systemfile, sysexc)) else: # Get the nodes from Auto Config if 'nodes' in topo: self._nodes = topo['nodes'] # Set the root directory in all the nodes for i in self._nodes.items(): node = i[1] node['rootdir'] = self._rootdir def updateconfig(self): """ Update the testbed configuration, given the auto configuration file. We will write the system configuration file with the current node information """ # Initialize the yaml data ydata = {'metadata': self._metadata, 'nodes': self._nodes} # Write the system config file filename = self._rootdir + self._metadata['system_config_file'] with open(filename, 'w') as yamlfile: yaml.dump(ydata, yamlfile) def _update_auto_config(self): """ Write the auto configuration file with the new configuration data, input from the user. """ # Initialize the yaml data nodes = {} with open(self._autoconfig_filename, 'r') as stream: try: ydata = yaml.load(stream) if 'nodes' in ydata: nodes = ydata['nodes'] except yaml.YAMLError as exc: print(exc) return for i in nodes.items(): key = i[0] node = i[1] # Interfaces node['interfaces'] = {} for item in self._nodes[key]['interfaces'].items(): port = item[0] interface = item[1] node['interfaces'][port] = {} addr = '{}'.format(interface['pci_address']) node['interfaces'][port]['pci_address'] = addr if 'mac_address' in interface: node['interfaces'][port]['mac_address'] = \ interface['mac_address'] if 'total_other_cpus' in self._nodes[key]['cpu']: node['cpu']['total_other_cpus'] = \ self._nodes[key]['cpu']['total_other_cpus'] if 'total_vpp_cpus' in self._nodes[key]['cpu']: node['cpu']['total_vpp_cpus'] = \ self._nodes[key]['cpu']['total_vpp_cpus'] if 'reserve_vpp_main_core' in self._nodes[key]['cpu']: node['cpu']['reserve_vpp_main_core'] = \ self._nodes[key]['cpu']['reserve_vpp_main_core'] # TCP if 'active_open_sessions' in self._nodes[key]['tcp']: node['tcp']['active_open_sessions'] = \ self._nodes[key]['tcp']['active_open_sessions'] if 'passive_open_sessions' in self._nodes[key]['tcp']: node['tcp']['passive_open_sessions'] = \ self._nodes[key]['tcp']['passive_open_sessions'] # Huge pages node['hugepages']['total'] = self._nodes[key]['hugepages']['total'] # Write the auto config config file with open(self._autoconfig_filename, 'w') as yamlfile: yaml.dump(ydata, yamlfile) def apply_huge_pages(self): """ Apply the huge page config """ for i in self._nodes.items(): node = i[1] hpg = VppHugePageUtil(node) hpg.hugepages_dryrun_apply() @staticmethod def _apply_vpp_unix(node): """ Apply the VPP Unix config :param node: Node dictionary with cpuinfo. :type node: dict """ unix = ' nodaemon\n' if 'unix' not in node['vpp']: return '' unixv = node['vpp']['unix'] if 'interactive' in unixv: interactive = unixv['interactive'] if interactive is True: unix = ' interactive\n' return unix.rstrip('\n') @staticmethod def _apply_vpp_cpu(node): """ Apply the VPP cpu config :param node: Node dictionary with cpuinfo. :type node: dict """ # Get main core cpu = '\n' if 'vpp_main_core' in node['cpu']: vpp_main_core = node['cpu']['vpp_main_core'] else: vpp_main_core = 0 if vpp_main_core is not 0: cpu += ' main-core {}\n'.format(vpp_main_core) # Get workers vpp_workers = node['cpu']['vpp_workers'] vpp_worker_len = len(vpp_workers) if vpp_worker_len > 0: vpp_worker_str = '' for i, worker in enumerate(vpp_workers): if i > 0: vpp_worker_str += ',' if worker[0] == worker[1]: vpp_worker_str += "{}".format(worker[0]) else: vpp_worker_str += "{}-{}".format(worker[0], worker[1]) cpu += ' corelist-workers {}\n'.format(vpp_worker_str) return cpu @staticmethod def _apply_vpp_devices(node): """ Apply VPP PCI Device configuration to vpp startup. :param node: Node dictionary with cpuinfo. :type node: dict """ devices = '' ports_per_numa = node['cpu']['ports_per_numa'] total_mbufs = node['cpu']['total_mbufs'] for item in ports_per_numa.items(): value = item[1] interfaces = value['interfaces'] # if 0 was specified for the number of vpp workers, use 1 queue num_rx_queues = None num_tx_queues = None if 'rx_queues' in value: num_rx_queues = value['rx_queues'] if 'tx_queues' in value: num_tx_queues = value['tx_queues'] num_rx_desc = None num_tx_desc = None # Create the devices string for interface in interfaces: pci_address = interface['pci_address'] pci_address = pci_address.lstrip("'").rstrip("'") devices += '\n' devices += ' dev {} {{ \n'.format(pci_address) if num_rx_queues: devices += ' num-rx-queues {}\n'.format(num_rx_queues) else: devices += ' num-rx-queues {}\n'.format(1) if num_tx_queues: devices += ' num-tx-queues {}\n'.format(num_tx_queues) if num_rx_desc: devices += ' num-rx-desc {}\n'.format(num_rx_desc) if num_tx_desc: devices += ' num-tx-desc {}\n'.format(num_tx_desc) devices += ' }' # If the total mbufs is not 0 or less than the default, set num-bufs logging.debug("Total mbufs: {}".format(total_mbufs)) if total_mbufs is not 0 and total_mbufs > 16384: devices += '\n num-mbufs {}'.format(total_mbufs) return devices @staticmethod def _calc_vpp_workers(node, vpp_workers, numa_node, other_cpus_end, total_vpp_workers, reserve_vpp_main_core): """ Calculate the VPP worker information :param node: Node dictionary :param vpp_workers: List of VPP workers :param numa_node: Numa node :param other_cpus_end: The end of the cpus allocated for cores other than vpp :param total_vpp_workers: The number of vpp workers needed :param reserve_vpp_main_core: Is there a core needed for the vpp main core :type node: dict :type numa_node: int :type other_cpus_end: int :type total_vpp_workers: int :type reserve_vpp_main_core: bool :returns: Is a core still needed for the vpp main core :rtype: bool """ # Can we fit the workers in one of these slices cpus = node['cpu']['cpus_per_node'][numa_node] for cpu in cpus: start = cpu[0] end = cpu[1] if start <= other_cpus_end: start = other_cpus_end + 1 if reserve_vpp_main_core: start += 1 workers_end = start + total_vpp_workers - 1 if workers_end <= end: if reserve_vpp_main_core: node['cpu']['vpp_main_core'] = start - 1 reserve_vpp_main_core = False if total_vpp_workers: vpp_workers.append((start, workers_end)) break # We still need to reserve the main core if reserve_vpp_main_core: node['cpu']['vpp_main_core'] = other_cpus_end + 1 return reserve_vpp_main_core @staticmethod def _calc_desc_and_queues(total_numa_nodes, total_ports_per_numa, total_rx_queues, ports_per_numa_value): """ Calculate the number of descriptors and queues :param total_numa_nodes: The total number of numa nodes :param total_ports_per_numa: The total number of ports for this numa node :param total_rx_queues: The total number of rx queues / port :param ports_per_numa_value: The value from the ports_per_numa dictionary :type total_numa_nodes: int :type total_ports_per_numa: int :type total_rx_queues: int :type ports_per_numa_value: dict :returns The total number of message buffers :rtype: int """ # Get the number of rx queues rx_queues = max(1, total_rx_queues) tx_queues = rx_queues * total_numa_nodes + 1 # Get the descriptor entries desc_entries = 1024 ports_per_numa_value['rx_queues'] = rx_queues total_mbufs = (((rx_queues * desc_entries) + (tx_queues * desc_entries)) * total_ports_per_numa) total_mbufs = total_mbufs return total_mbufs @staticmethod def _create_ports_per_numa(node, interfaces): """ Create a dictionary or ports per numa node :param node: Node dictionary :param interfaces: All the interfaces to be used by vpp :type node: dict :type interfaces: dict :returns: The ports per numa dictionary :rtype: dict """ # Make a list of ports by numa node ports_per_numa = {} for item in interfaces.items(): i = item[1] if i['numa_node'] not in ports_per_numa: ports_per_numa[i['numa_node']] = {'interfaces': []} ports_per_numa[i['numa_node']]['interfaces'].append(i) else: ports_per_numa[i['numa_node']]['interfaces'].append(i) node['cpu']['ports_per_numa'] = ports_per_numa return ports_per_numa def calculate_cpu_parameters(self): """ Calculate the cpu configuration. """ # Calculate the cpu parameters, needed for the # vpp_startup and grub configuration for i in self._nodes.items(): node = i[1] # get total number of nic ports interfaces = node['interfaces'] # Make a list of ports by numa node ports_per_numa = self._create_ports_per_numa(node, interfaces) # Get the number of cpus to skip, we never use the first cpu other_cpus_start = 1 other_cpus_end = other_cpus_start + \ node['cpu']['total_other_cpus'] - 1 other_workers = None if other_cpus_end is not 0: other_workers = (other_cpus_start, other_cpus_end) node['cpu']['other_workers'] = other_workers # Allocate the VPP main core and workers vpp_workers = [] reserve_vpp_main_core = node['cpu']['reserve_vpp_main_core'] total_vpp_cpus = node['cpu']['total_vpp_cpus'] total_rx_queues = node['cpu']['total_rx_queues'] # If total_vpp_cpus is 0 or is less than the numa nodes with ports # then we shouldn't get workers total_workers_node = 0 if len(ports_per_numa): total_workers_node = total_vpp_cpus / len(ports_per_numa) total_main = 0 if reserve_vpp_main_core: total_main = 1 total_mbufs = 0 if total_main + total_workers_node is not 0: for item in ports_per_numa.items(): numa_node = item[0] value = item[1] # Get the number of descriptors and queues mbufs = self._calc_desc_and_queues( len(ports_per_numa), len(value['interfaces']), total_rx_queues, value) total_mbufs += mbufs # Get the VPP workers reserve_vpp_main_core = self._calc_vpp_workers( node, vpp_workers, numa_node, other_cpus_end, total_workers_node, reserve_vpp_main_core) total_mbufs *= 2.5 total_mbufs = int(total_mbufs) else: total_mbufs = 0 # Save the info node['cpu']['vpp_workers'] = vpp_workers node['cpu']['total_mbufs'] = total_mbufs # Write the config self.updateconfig() @staticmethod def _apply_vpp_tcp(node): """ Apply the VPP Unix config :param node: Node dictionary with cpuinfo. :type node: dict """ active_open_sessions = node['tcp']['active_open_sessions'] aos = int(active_open_sessions) passive_open_sessions = node['tcp']['passive_open_sessions'] pos = int(passive_open_sessions) # Generate the api-segment gid vpp sheit in any case if (aos + pos) == 0: tcp = '\n'.join([ "api-segment {", " gid vpp", "}" ]) return tcp.rstrip('\n') tcp = '\n'.join([ "# TCP stack-related configuration parameters", "# expecting {:d} client sessions, {:d} server sessions\n".format( aos, pos), "heapsize 4g\n", "api-segment {", " global-size 2000M", " api-size 1G", "}\n", "session {", " event-queue-length {:d}".format(aos + pos), " preallocated-sessions {:d}".format(aos + pos), " v4-session-table-buckets {:d}".format((aos + pos) // 4), " v4-session-table-memory 3g\n" ]) if aos > 0: tcp = tcp + " v4-halfopen-table-buckets {:d}".format( (aos + pos) // 4) + "\n" tcp = tcp + " v4-halfopen-table-memory 3g\n" tcp = tcp + " local-endpoints-table-buckets {:d}".format( (aos + pos) // 4) + "\n" tcp = tcp + " local-endpoints-table-memory 3g\n" tcp = tcp + "}\n\n" tcp = tcp + "tcp {\n" tcp = tcp + " preallocated-connections {:d}".format(aos + pos) + "\n" if aos > 0: tcp = tcp + " preallocated-half-open-connections {:d}".format( aos) + "\n" tcp = tcp + "}\n\n" return tcp.rstrip('\n') def apply_vpp_startup(self): """ Apply the vpp startup configration """ # Apply the VPP startup configruation for i in self._nodes.items(): node = i[1] # Get the startup file rootdir = node['rootdir'] sfile = rootdir + node['vpp']['startup_config_file'] # Get the devices devices = self._apply_vpp_devices(node) # Get the CPU config cpu = self._apply_vpp_cpu(node) # Get the unix config unix = self._apply_vpp_unix(node) # Get the TCP configuration, if any tcp = self._apply_vpp_tcp(node) # Make a backup if needed self._autoconfig_backup_file(sfile) # Get the template tfile = sfile + '.template' (ret, stdout, stderr) = \ VPPUtil.exec_command('cat {}'.format(tfile)) if ret != 0: raise RuntimeError('Executing cat command failed to node {}'. format(node['host'])) startup = stdout.format(unix=unix, cpu=cpu, devices=devices, tcp=tcp) (ret, stdout, stderr) = \ VPPUtil.exec_command('rm {}'.format(sfile)) if ret != 0: logging.debug(stderr) cmd = "sudo cat > {0} << EOF\n{1}\n".format(sfile, startup) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: raise RuntimeError('Writing config failed node {}'. format(node['host'])) def apply_grub_cmdline(self): """ Apply the grub cmdline """ for i in self._nodes.items(): node = i[1] # Get the isolated CPUs other_workers = node['cpu']['other_workers'] vpp_workers = node['cpu']['vpp_workers'] if 'vpp_main_core' in node['cpu']: vpp_main_core = node['cpu']['vpp_main_core'] else: vpp_main_core = 0 all_workers = [] if other_workers is not None: all_workers = [other_workers] if vpp_main_core is not 0: all_workers += [(vpp_main_core, vpp_main_core)] all_workers += vpp_workers isolated_cpus = '' for idx, worker in enumerate(all_workers): if worker is None: continue if idx > 0: isolated_cpus += ',' if worker[0] == worker[1]: isolated_cpus += "{}".format(worker[0]) else: isolated_cpus += "{}-{}".format(worker[0], worker[1]) vppgrb = VppGrubUtil(node) current_cmdline = vppgrb.get_current_cmdline() if 'grub' not in node: node['grub'] = {} node['grub']['current_cmdline'] = current_cmdline node['grub']['default_cmdline'] = \ vppgrb.apply_cmdline(node, isolated_cpus) self.updateconfig() def get_hugepages(self): """ Get the hugepage configuration """ for i in self._nodes.items(): node = i[1] hpg = VppHugePageUtil(node) max_map_count, shmmax = hpg.get_huge_page_config() node['hugepages']['max_map_count'] = max_map_count node['hugepages']['shmax'] = shmmax total, free, size, memtotal, memfree = hpg.get_actual_huge_pages() node['hugepages']['actual_total'] = total node['hugepages']['free'] = free node['hugepages']['size'] = size node['hugepages']['memtotal'] = memtotal node['hugepages']['memfree'] = memfree self.updateconfig() def get_grub(self): """ Get the grub configuration """ for i in self._nodes.items(): node = i[1] vppgrb = VppGrubUtil(node) current_cmdline = vppgrb.get_current_cmdline() default_cmdline = vppgrb.get_default_cmdline() # Get the total number of isolated CPUs current_iso_cpus = 0 iso_cpur = re.findall(r'isolcpus=[\w+\-,]+', current_cmdline) iso_cpurl = len(iso_cpur) if iso_cpurl > 0: iso_cpu_str = iso_cpur[0] iso_cpu_str = iso_cpu_str.split('=')[1] iso_cpul = iso_cpu_str.split(',') for iso_cpu in iso_cpul: isocpuspl = iso_cpu.split('-') if len(isocpuspl) is 1: current_iso_cpus += 1 else: first = int(isocpuspl[0]) second = int(isocpuspl[1]) if first == second: current_iso_cpus += 1 else: current_iso_cpus += second - first if 'grub' not in node: node['grub'] = {} node['grub']['current_cmdline'] = current_cmdline node['grub']['default_cmdline'] = default_cmdline node['grub']['current_iso_cpus'] = current_iso_cpus self.updateconfig() @staticmethod def _get_device(node): """ Get the device configuration for a single node :param node: Node dictionary with cpuinfo. :type node: dict """ vpp = VppPCIUtil(node) vpp.get_all_devices() # Save the device information node['devices'] = {} node['devices']['dpdk_devices'] = vpp.get_dpdk_devices() node['devices']['kernel_devices'] = vpp.get_kernel_devices() node['devices']['other_devices'] = vpp.get_other_devices() node['devices']['linkup_devices'] = vpp.get_link_up_devices() def get_devices_per_node(self): """ Get the device configuration for all the nodes """ for i in self._nodes.items(): node = i[1] # Update the interface data self._get_device(node) self.updateconfig() @staticmethod def get_cpu_layout(node): """ Get the cpu layout using lscpu -p get the cpu layout. Returns a list with each item representing a single cpu. :param node: Node dictionary. :type node: dict :returns: The cpu layout :rtype: list """ cmd = 'lscpu -p' (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: raise RuntimeError('{} failed on node {} {}'. format(cmd, node['host'], stderr)) pcpus = [] lines = stdout.split('\n') for line in lines: if line == '' or line[0] == '#': continue linesplit = line.split(',') layout = {'cpu': linesplit[0], 'core': linesplit[1], 'socket': linesplit[2], 'node': linesplit[3]} # cpu, core, socket, node pcpus.append(layout) return pcpus def get_cpu(self): """ Get the cpu configuration """ # Get the CPU layout CpuUtils.get_cpu_layout_from_all_nodes(self._nodes) for i in self._nodes.items(): node = i[1] # Get the cpu layout layout = self.get_cpu_layout(node) node['cpu']['layout'] = layout cpuinfo = node['cpuinfo'] smt_enabled = CpuUtils.is_smt_enabled(cpuinfo) node['cpu']['smt_enabled'] = smt_enabled # We don't want to write the cpuinfo node['cpuinfo'] = "" # Write the config self.updateconfig() def discover(self): """ Get the current system configuration. """ # Get the Huge Page configuration self.get_hugepages() # Get the device configuration self.get_devices_per_node() # Get the CPU configuration self.get_cpu() # Get the current grub cmdline self.get_grub() def _modify_cpu_questions(self, node, total_cpus, numa_nodes): """ Ask the user questions related to the cpu configuration. :param node: Node dictionary :param total_cpus: The total number of cpus in the system :param numa_nodes: The list of numa nodes in the system :type node: dict :type total_cpus: int :type numa_nodes: list """ print("\nYour system has {} core(s) and {} Numa Nodes.". format(total_cpus, len(numa_nodes))) print("To begin, we suggest not reserving any cores for " "VPP or other processes.") print("Then to improve performance start reserving cores and " "adding queues as needed.") max_vpp_cpus = 4 total_vpp_cpus = 0 if max_vpp_cpus > 0: question = "\nHow many core(s) shall we reserve for " \ "VPP [0-{}][0]? ".format(max_vpp_cpus) total_vpp_cpus = self._ask_user_range(question, 0, max_vpp_cpus, 0) node['cpu']['total_vpp_cpus'] = total_vpp_cpus max_other_cores = (total_cpus - total_vpp_cpus) / 2 question = 'How many core(s) do you want to reserve for ' \ 'processes other than VPP? [0-{}][0]? '. \ format(str(max_other_cores)) total_other_cpus = self._ask_user_range( question, 0, max_other_cores, 0) node['cpu']['total_other_cpus'] = total_other_cpus max_main_cpus = max_vpp_cpus + 1 - total_vpp_cpus reserve_vpp_main_core = False if max_main_cpus > 0: question = "Should we reserve 1 core for the VPP Main thread? " question += "[y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'y': reserve_vpp_main_core = True node['cpu']['reserve_vpp_main_core'] = reserve_vpp_main_core node['cpu']['vpp_main_core'] = 0 question = "How many RX queues per port shall we use for " \ "VPP [1-4][1]? ".format(max_vpp_cpus) total_rx_queues = self._ask_user_range(question, 1, 4, 1) node['cpu']['total_rx_queues'] = total_rx_queues def modify_cpu(self, ask_questions=True): """ Modify the cpu configuration, asking for the user for the values. :param ask_questions: When true ask the user for config parameters """ # Get the CPU layout CpuUtils.get_cpu_layout_from_all_nodes(self._nodes) for i in self._nodes.items(): node = i[1] total_cpus = 0 total_cpus_per_slice = 0 cpus_per_node = {} numa_nodes = [] cores = [] cpu_layout = self.get_cpu_layout(node) # Assume the number of cpus per slice is always the same as the # first slice first_node = '0' for cpu in cpu_layout: if cpu['node'] != first_node: break total_cpus_per_slice += 1 # Get the total number of cpus, cores, and numa nodes from the # cpu layout for cpul in cpu_layout: numa_node = cpul['node'] core = cpul['core'] cpu = cpul['cpu'] total_cpus += 1 if numa_node not in cpus_per_node: cpus_per_node[numa_node] = [] cpuperslice = int(cpu) % total_cpus_per_slice if cpuperslice == 0: cpus_per_node[numa_node].append((int(cpu), int(cpu) + total_cpus_per_slice - 1)) if numa_node not in numa_nodes: numa_nodes.append(numa_node) if core not in cores: cores.append(core) node['cpu']['cpus_per_node'] = cpus_per_node # Ask the user some questions if ask_questions and total_cpus >= 8: self._modify_cpu_questions(node, total_cpus, numa_nodes) # Populate the interfaces with the numa node if 'interfaces' in node: ikeys = node['interfaces'].keys() VPPUtil.get_interfaces_numa_node(node, *tuple(ikeys)) # We don't want to write the cpuinfo node['cpuinfo'] = "" # Write the configs self._update_auto_config() self.updateconfig() def _modify_other_devices(self, node, other_devices, kernel_devices, dpdk_devices): """ Modify the devices configuration, asking for the user for the values. """ odevices_len = len(other_devices) if odevices_len > 0: print("\nThese device(s) are currently NOT being used " "by VPP or the OS.\n") VppPCIUtil.show_vpp_devices(other_devices, show_interfaces=False) question = "\nWould you like to give any of these devices" question += " back to the OS [Y/n]? " answer = self._ask_user_yn(question, 'Y') if answer == 'y': vppd = {} for dit in other_devices.items(): dvid = dit[0] device = dit[1] question = "Would you like to use device {} for". \ format(dvid) question += " the OS [y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'y': if 'unused' in device and len( device['unused']) != 0 and \ device['unused'][0] != '': driver = device['unused'][0] ret = VppPCIUtil.bind_vpp_device( node, driver, dvid) if ret: logging.debug( 'Could not bind device {}'.format(dvid)) else: vppd[dvid] = device for dit in vppd.items(): dvid = dit[0] device = dit[1] kernel_devices[dvid] = device del other_devices[dvid] odevices_len = len(other_devices) if odevices_len > 0: print("\nThese device(s) are still NOT being used " "by VPP or the OS.\n") VppPCIUtil.show_vpp_devices(other_devices, show_interfaces=False) question = "\nWould you like use any of these for VPP [y/N]? " answer = self._ask_user_yn(question, 'N') if answer == 'y': vppd = {} for dit in other_devices.items(): dvid = dit[0] device = dit[1] question = "Would you like to use device {} ".format(dvid) question += "for VPP [y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'y': vppd[dvid] = device for dit in vppd.items(): dvid = dit[0] device = dit[1] if 'unused' in device and len(device['unused']) != 0 and \ device['unused'][0] != '': driver = device['unused'][0] logging.debug( 'Binding device {} to driver {}'.format(dvid, driver)) ret = VppPCIUtil.bind_vpp_device(node, driver, dvid) if ret: logging.debug( 'Could not bind device {}'.format(dvid)) else: dpdk_devices[dvid] = device del other_devices[dvid] def update_interfaces_config(self): """ Modify the interfaces directly from the config file. """ for i in self._nodes.items(): node = i[1] devices = node['devices'] all_devices = devices['other_devices'] all_devices.update(devices['dpdk_devices']) all_devices.update(devices['kernel_devices']) current_ifcs = {} interfaces = {} if 'interfaces' in node: current_ifcs = node['interfaces'] if current_ifcs: for ifc in current_ifcs.values(): dvid = ifc['pci_address'] if dvid in all_devices: VppPCIUtil.vpp_create_interface(interfaces, dvid, all_devices[dvid]) node['interfaces'] = interfaces self.updateconfig() def modify_devices(self): """ Modify the devices configuration, asking for the user for the values. """ for i in self._nodes.items(): node = i[1] devices = node['devices'] other_devices = devices['other_devices'] kernel_devices = devices['kernel_devices'] dpdk_devices = devices['dpdk_devices'] if other_devices: self._modify_other_devices(node, other_devices, kernel_devices, dpdk_devices) # Get the devices again for this node self._get_device(node) devices = node['devices'] kernel_devices = devices['kernel_devices'] dpdk_devices = devices['dpdk_devices'] klen = len(kernel_devices) if klen > 0: print("\nThese devices are safe to be used with VPP.\n") VppPCIUtil.show_vpp_devices(kernel_devices) question = "\nWould you like to use any of these " \ "device(s) for VPP [y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'y': vppd = {} for dit in kernel_devices.items(): dvid = dit[0] device = dit[1] question = "Would you like to use device {} ".format(dvid) question += "for VPP [y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'y': vppd[dvid] = device for dit in vppd.items(): dvid = dit[0] device = dit[1] if 'unused' in device and len( device['unused']) != 0 and device['unused'][ 0] != '': driver = device['unused'][0] question = "Would you like to bind the driver {} for {} [y/N]? ".format(driver, dvid) answer = self._ask_user_yn(question, 'n') if answer == 'y': logging.debug('Binding device {} to driver {}'.format(dvid, driver)) ret = VppPCIUtil.bind_vpp_device(node, driver, dvid) if ret: logging.debug('Could not bind device {}'.format(dvid)) dpdk_devices[dvid] = device del kernel_devices[dvid] dlen = len(dpdk_devices) if dlen > 0: print("\nThese device(s) are already using DPDK.\n") VppPCIUtil.show_vpp_devices(dpdk_devices, show_interfaces=False) question = "\nWould you like to remove any of " question += "these device(s) [y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'y': vppdl = {} for dit in dpdk_devices.items(): dvid = dit[0] device = dit[1] question = "Would you like to remove {} [y/N]? ". \ format(dvid) answer = self._ask_user_yn(question, 'n') if answer == 'y': vppdl[dvid] = device for dit in vppdl.items(): dvid = dit[0] device = dit[1] if 'unused' in device and len( device['unused']) != 0 and device['unused'][ 0] != '': driver = device['unused'][0] logging.debug( 'Binding device {} to driver {}'.format( dvid, driver)) ret = VppPCIUtil.bind_vpp_device(node, driver, dvid) if ret: logging.debug( 'Could not bind device {}'.format(dvid)) else: kernel_devices[dvid] = device del dpdk_devices[dvid] interfaces = {} for dit in dpdk_devices.items(): dvid = dit[0] device = dit[1] VppPCIUtil.vpp_create_interface(interfaces, dvid, device) node['interfaces'] = interfaces self._update_auto_config() self.updateconfig() def modify_huge_pages(self): """ Modify the huge page configuration, asking for the user for the values. """ for i in self._nodes.items(): node = i[1] total = node['hugepages']['actual_total'] free = node['hugepages']['free'] size = node['hugepages']['size'] memfree = node['hugepages']['memfree'].split(' ')[0] hugesize = int(size.split(' ')[0]) # The max number of huge pages should be no more than # 70% of total free memory maxpages = (int(memfree) * MAX_PERCENT_FOR_HUGE_PAGES // 100) // \ hugesize print("\nThere currently {} {} huge pages free.".format( free, size)) question = "Do you want to reconfigure the number of " \ "huge pages [y/N]? " answer = self._ask_user_yn(question, 'n') if answer == 'n': node['hugepages']['total'] = total continue print("\nThere currently a total of {} huge pages.". format(total)) question = "How many huge pages do you want [{} - {}][{}]? ". \ format(MIN_TOTAL_HUGE_PAGES, maxpages, MIN_TOTAL_HUGE_PAGES) answer = self._ask_user_range(question, 1024, maxpages, 1024) node['hugepages']['total'] = str(answer) # Update auto-config.yaml self._update_auto_config() # Rediscover just the hugepages self.get_hugepages() def get_tcp_params(self): """ Get the tcp configuration """ # maybe nothing to do here? self.updateconfig() def acquire_tcp_params(self): """ Ask the user for TCP stack configuration parameters """ for i in self._nodes.items(): node = i[1] question = "\nHow many active-open / tcp client sessions are " \ "expected [0-10000000][0]? " answer = self._ask_user_range(question, 0, 10000000, 0) # Less than 10K is equivalent to 0 if int(answer) < 10000: answer = 0 node['tcp']['active_open_sessions'] = answer question = "How many passive-open / tcp server sessions are " \ "expected [0-10000000][0]? " answer = self._ask_user_range(question, 0, 10000000, 0) # Less than 10K is equivalent to 0 if int(answer) < 10000: answer = 0 node['tcp']['passive_open_sessions'] = answer # Update auto-config.yaml self._update_auto_config() # Rediscover tcp parameters self.get_tcp_params() @staticmethod def patch_qemu(node): """ Patch qemu with the correct patches. :param node: Node dictionary :type node: dict """ print('\nWe are patching the node "{}":\n'.format(node['host'])) QemuUtils.build_qemu(node, force_install=True, apply_patch=True) @staticmethod def cpu_info(node): """ print the CPU information """ cpu = CpuUtils.get_cpu_info_per_node(node) item = 'Model name' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) item = 'CPU(s)' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) item = 'Thread(s) per core' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) item = 'Core(s) per socket' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) item = 'Socket(s)' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) item = 'NUMA node(s)' numa_nodes = 0 if item in cpu: numa_nodes = int(cpu[item]) for i in range(0, numa_nodes): item = "NUMA node{} CPU(s)".format(i) print("{:>20}: {}".format(item, cpu[item])) item = 'CPU max MHz' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) item = 'CPU min MHz' if item in cpu: print("{:>20}: {}".format(item, cpu[item])) if node['cpu']['smt_enabled']: smt = 'Enabled' else: smt = 'Disabled' print("{:>20}: {}".format('SMT', smt)) # VPP Threads print("\nVPP Threads: (Name: Cpu Number)") vpp_processes = cpu['vpp_processes'] for i in vpp_processes.items(): print(" {:10}: {:4}".format(i[0], i[1])) @staticmethod def device_info(node): """ Show the device information. """ if 'cpu' in node and 'total_mbufs' in node['cpu']: total_mbufs = node['cpu']['total_mbufs'] if total_mbufs is not 0: print("Total Number of Buffers: {}".format(total_mbufs)) vpp = VppPCIUtil(node) vpp.get_all_devices() linkup_devs = vpp.get_link_up_devices() if len(linkup_devs): print("\nDevices with link up (can not be used with VPP):") vpp.show_vpp_devices(linkup_devs, show_header=False) # for dev in linkup_devs: # print (" " + dev) kernel_devs = vpp.get_kernel_devices() if len(kernel_devs): print("\nDevices bound to kernel drivers:") vpp.show_vpp_devices(kernel_devs, show_header=False) else: print("\nNo devices bound to kernel drivers") dpdk_devs = vpp.get_dpdk_devices() if len(dpdk_devs): print("\nDevices bound to DPDK drivers:") vpp.show_vpp_devices(dpdk_devs, show_interfaces=True, show_header=False) else: print("\nNo devices bound to DPDK drivers") other_devs = vpp.get_other_devices() if len(other_devs): print("\nDevices not bound to Kernel or DPDK drivers:") vpp.show_vpp_devices(other_devs, show_interfaces=True, show_header=False) else: print("\nNo devices not bound to Kernel or DPDK drivers") vpputl = VPPUtil() interfaces = vpputl.get_hardware(node) if interfaces == {}: return print("\nDevices in use by VPP:") if len(interfaces.items()) < 2: print("None") return print("{:30} {:4} {:4} {:7} {:4} {:7}". format('Name', 'Numa', 'RXQs', 'RXDescs', 'TXQs', 'TXDescs')) for intf in sorted(interfaces.items()): name = intf[0] value = intf[1] if name == 'local0': continue numa = rx_qs = rx_ds = tx_qs = tx_ds = '' if 'numa' in value: numa = int(value['numa']) if 'rx queues' in value: rx_qs = int(value['rx queues']) if 'rx descs' in value: rx_ds = int(value['rx descs']) if 'tx queues' in value: tx_qs = int(value['tx queues']) if 'tx descs' in value: tx_ds = int(value['tx descs']) print("{:30} {:>4} {:>4} {:>7} {:>4} {:>7}". format(name, numa, rx_qs, rx_ds, tx_qs, tx_ds)) @staticmethod def hugepage_info(node): """ Show the huge page information. """ hpg = VppHugePageUtil(node) hpg.show_huge_pages() @staticmethod def min_system_resources(node): """ Check the system for basic minimum resources, return true if there is enough. :returns: boolean :rtype: dict """ min_sys_res = True # CPUs if 'layout' in node['cpu']: total_cpus = len(node['cpu']['layout']) if total_cpus < 2: print("\nThere is only {} CPU(s) available on this system. " "This is not enough to run VPP.".format(total_cpus)) min_sys_res = False # System Memory if 'free' in node['hugepages'] and \ 'memfree' in node['hugepages'] and \ 'size' in node['hugepages']: free = node['hugepages']['free'] memfree = float(node['hugepages']['memfree'].split(' ')[0]) hugesize = float(node['hugepages']['size'].split(' ')[0]) memhugepages = MIN_TOTAL_HUGE_PAGES * hugesize percentmemhugepages = (memhugepages / memfree) * 100 if free is '0' and \ percentmemhugepages > MAX_PERCENT_FOR_HUGE_PAGES: print( "\nThe System has only {} of free memory. You will not " "be able to allocate enough Huge Pages for VPP.".format( int( memfree)) ) min_sys_res = False return min_sys_res def sys_info(self): """ Print the system information """ for i in self._nodes.items(): print("\n==============================") name = i[0] node = i[1] print("NODE: {}\n".format(name)) # CPU print("CPU:") self.cpu_info(node) # Grub print("\nGrub Command Line:") if 'grub' in node: print(" Current: {}".format( node['grub']['current_cmdline'])) print(" Configured: {}".format( node['grub']['default_cmdline'])) # Huge Pages print("\nHuge Pages:") self.hugepage_info(node) # Devices print("\nDevices:") self.device_info(node) # Status print("\nVPP Service Status:") state, errors = VPPUtil.status(node) print(" {}".format(state)) for e in errors: print(" {}".format(e)) # Minimum system resources self.min_system_resources(node) print("\n==============================") def _ipv4_interface_setup_questions(self, node): """ Ask the user some questions and get a list of interfaces and IPv4 addresses associated with those interfaces :param node: Node dictionary. :type node: dict :returns: A list or interfaces with ip addresses :rtype: dict """ vpputl = VPPUtil() interfaces = vpputl.get_hardware(node) if interfaces == {}: return interfaces_with_ip = [] for intf in sorted(interfaces.items()): name = intf[0] if name == 'local0': continue question = "Would you like add address to " \ "interface {} [Y/n]? ".format(name) answer = self._ask_user_yn(question, 'y') if answer == 'y': address = {} addr = self._ask_user_ipv4() address['name'] = name address['addr'] = addr interfaces_with_ip.append(address) return interfaces_with_ip def ipv4_interface_setup(self): """ After asking the user some questions, get a list of interfaces and IPv4 addresses associated with those interfaces """ for i in self._nodes.items(): node = i[1] # Show the current interfaces with IP addresses current_ints = VPPUtil.get_int_ip(node) if current_ints is not {}: print("\nThese are the current interfaces with IP addresses:") for items in sorted(current_ints.items()): name = items[0] value = items[1] if 'address' not in value: address = 'Not Set' else: address = value['address'] print("{:30} {:20} {:10}".format(name, address, value['state'])) question = "\nWould you like to keep this configuration " \ "[Y/n]? " answer = self._ask_user_yn(question, 'y') if answer == 'y': continue else: print("\nThere are currently no interfaces with IP " "addresses.") # Create a script that add the ip addresses to the interfaces # and brings the interfaces up ints_with_addrs = self._ipv4_interface_setup_questions(node) content = '' for ints in ints_with_addrs: name = ints['name'] addr = ints['addr'] setipstr = 'set int ip address {} {}\n'.format(name, addr) setintupstr = 'set int state {} up\n'.format(name) content += setipstr + setintupstr # Write the content to the script rootdir = node['rootdir'] filename = rootdir + '/vpp/vpp-config/scripts/set_int_ipv4_and_up' with open(filename, 'w+') as sfile: sfile.write(content) # Execute the script cmd = 'vppctl exec {}'.format(filename) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) print("\nA script as been created at {}".format(filename)) print("This script can be run using the following:") print("vppctl exec {}\n".format(filename)) def _create_vints_questions(self, node): """ Ask the user some questions and get a list of interfaces and IPv4 addresses associated with those interfaces :param node: Node dictionary. :type node: dict :returns: A list or interfaces with ip addresses :rtype: list """ vpputl = VPPUtil() interfaces = vpputl.get_hardware(node) if interfaces == {}: return [] # First delete all the Virtual interfaces for intf in sorted(interfaces.items()): name = intf[0] if name[:7] == 'Virtual': cmd = 'vppctl delete vhost-user {}'.format(name) (ret, stdout, stderr) = vpputl.exec_command(cmd) if ret != 0: logging.debug('{} failed on node {} {}'.format( cmd, node['host'], stderr)) # Create a virtual interface, for each interface the user wants to use interfaces = vpputl.get_hardware(node) if interfaces == {}: return [] interfaces_with_virtual_interfaces = [] inum = 1 for intf in sorted(interfaces.items()): name = intf[0] if name == 'local0': continue question = "Would you like connect this interface {} to " \ "the VM [Y/n]? ".format(name) answer = self._ask_user_yn(question, 'y') if answer == 'y': sockfilename = '/var/run/vpp/{}.sock'.format( name.replace('/', '_')) if os.path.exists(sockfilename): os.remove(sockfilename) cmd = 'vppctl create vhost-user socket {} server'.format( sockfilename) (ret, stdout, stderr) = vpputl.exec_command(cmd) if ret != 0: raise RuntimeError( "Couldn't execute the command {}, {}.".format(cmd, stderr)) vintname = stdout.rstrip('\r\n') cmd = 'chmod 777 {}'.format(sockfilename) (ret, stdout, stderr) = vpputl.exec_command(cmd) if ret != 0: raise RuntimeError( "Couldn't execute the command {}, {}.".format(cmd, stderr)) interface = {'name': name, 'virtualinterface': '{}'.format(vintname), 'bridge': '{}'.format(inum)} inum += 1 interfaces_with_virtual_interfaces.append(interface) return interfaces_with_virtual_interfaces def create_and_bridge_virtual_interfaces(self): """ After asking the user some questions, create a VM and connect the interfaces to VPP interfaces """ for i in self._nodes.items(): node = i[1] # Show the current bridge and interface configuration print("\nThis the current bridge configuration:") VPPUtil.show_bridge(node) question = "\nWould you like to keep this configuration [Y/n]? " answer = self._ask_user_yn(question, 'y') if answer == 'y': continue # Create a script that builds a bridge configuration with # physical interfaces and virtual interfaces ints_with_vints = self._create_vints_questions(node) content = '' for intf in ints_with_vints: vhoststr = '\n'.join([ 'comment { The following command creates the socket }', 'comment { and returns a virtual interface }', 'comment {{ create vhost-user socket ' '/var/run/vpp/sock{}.sock server }}\n'.format( intf['bridge']) ]) setintdnstr = 'set interface state {} down\n'.format( intf['name']) setintbrstr = 'set interface l2 bridge {} {}\n'.format( intf['name'], intf['bridge']) setvintbrstr = 'set interface l2 bridge {} {}\n'.format( intf['virtualinterface'], intf['bridge']) # set interface state VirtualEthernet/0/0/0 up setintvststr = 'set interface state {} up\n'.format( intf['virtualinterface']) # set interface state VirtualEthernet/0/0/0 down setintupstr = 'set interface state {} up\n'.format( intf['name']) content += vhoststr + setintdnstr + setintbrstr + \ setvintbrstr + setintvststr + setintupstr # Write the content to the script rootdir = node['rootdir'] filename = rootdir + \ '/vpp/vpp-config/scripts/create_vms_and_connect_to_vpp' with open(filename, 'w+') as sfile: sfile.write(content) # Execute the script cmd = 'vppctl exec {}'.format(filename) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) print("\nA script as been created at {}".format(filename)) print("This script can be run using the following:") print("vppctl exec {}\n".format(filename)) def _iperf_vm_questions(self, node): """ Ask the user some questions and get a list of interfaces and IPv4 addresses associated with those interfaces :param node: Node dictionary. :type node: dict :returns: A list or interfaces with ip addresses :rtype: list """ vpputl = VPPUtil() interfaces = vpputl.get_hardware(node) if interfaces == {}: return [] # First delete all the Virtual interfaces for intf in sorted(interfaces.items()): name = intf[0] if name[:7] == 'Virtual': cmd = 'vppctl delete vhost-user {}'.format(name) (ret, stdout, stderr) = vpputl.exec_command(cmd) if ret != 0: logging.debug('{} failed on node {} {}'.format( cmd, node['host'], stderr)) # Create a virtual interface, for each interface the user wants to use interfaces = vpputl.get_hardware(node) if interfaces == {}: return [] interfaces_with_virtual_interfaces = [] inum = 1 while True: print('\nPlease pick one interface to connect to the iperf VM.') for intf in sorted(interfaces.items()): name = intf[0] if name == 'local0': continue question = "Would you like connect this interface {} to " \ "the VM [y/N]? ".format(name) answer = self._ask_user_yn(question, 'n') if answer == 'y': self._sockfilename = '/var/run/vpp/{}.sock'.format( name.replace('/', '_')) if os.path.exists(self._sockfilename): os.remove(self._sockfilename) cmd = 'vppctl create vhost-user socket {} server'.format( self._sockfilename) (ret, stdout, stderr) = vpputl.exec_command(cmd) if ret != 0: raise RuntimeError( "Couldn't execute the command {}, {}.".format( cmd, stderr)) vintname = stdout.rstrip('\r\n') cmd = 'chmod 777 {}'.format(self._sockfilename) (ret, stdout, stderr) = vpputl.exec_command(cmd) if ret != 0: raise RuntimeError( "Couldn't execute the command {}, {}.".format( cmd, stderr)) interface = {'name': name, 'virtualinterface': '{}'.format(vintname), 'bridge': '{}'.format(inum)} inum += 1 interfaces_with_virtual_interfaces.append(interface) return interfaces_with_virtual_interfaces def create_and_bridge_iperf_virtual_interface(self): """ After asking the user some questions, and create and bridge a virtual interface to be used with iperf VM """ for i in self._nodes.items(): node = i[1] # Show the current bridge and interface configuration print("\nThis the current bridge configuration:") ifaces = VPPUtil.show_bridge(node) question = "\nWould you like to keep this configuration [Y/n]? " answer = self._ask_user_yn(question, 'y') if answer == 'y': self._sockfilename = '/var/run/vpp/{}.sock'.format( ifaces[0]['name'].replace('/', '_')) if os.path.exists(self._sockfilename): continue # Create a script that builds a bridge configuration with # physical interfaces and virtual interfaces ints_with_vints = self._iperf_vm_questions(node) content = '' for intf in ints_with_vints: vhoststr = '\n'.join([ 'comment { The following command creates the socket }', 'comment { and returns a virtual interface }', 'comment {{ create vhost-user socket ' '/var/run/vpp/sock{}.sock server }}\n'.format( intf['bridge']) ]) setintdnstr = 'set interface state {} down\n'.format( intf['name']) setintbrstr = 'set interface l2 bridge {} {}\n'.format( intf['name'], intf['bridge']) setvintbrstr = 'set interface l2 bridge {} {}\n'.format( intf['virtualinterface'], intf['bridge']) # set interface state VirtualEthernet/0/0/0 up setintvststr = 'set interface state {} up\n'.format( intf['virtualinterface']) # set interface state VirtualEthernet/0/0/0 down setintupstr = 'set interface state {} up\n'.format( intf['name']) content += vhoststr + setintdnstr + setintbrstr + \ setvintbrstr + setintvststr + setintupstr # Write the content to the script rootdir = node['rootdir'] filename = rootdir + '/vpp/vpp-config/scripts/create_iperf_vm' with open(filename, 'w+') as sfile: sfile.write(content) # Execute the script cmd = 'vppctl exec {}'.format(filename) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) print("\nA script as been created at {}".format(filename)) print("This script can be run using the following:") print("vppctl exec {}\n".format(filename)) @staticmethod def destroy_iperf_vm(name): """ After asking the user some questions, create a VM and connect the interfaces to VPP interfaces :param name: The name of the VM to be be destroyed :type name: str """ cmd = 'virsh list' (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) raise RuntimeError( "Couldn't execute the command {} : {}".format(cmd, stderr)) if re.findall(name, stdout): cmd = 'virsh destroy {}'.format(name) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) raise RuntimeError( "Couldn't execute the command {} : {}".format( cmd, stderr)) def create_iperf_vm(self, vmname): """ After asking the user some questions, create a VM and connect the interfaces to VPP interfaces """ # Read the iperf VM template file distro = VPPUtil.get_linux_distro() if distro[0] == 'Ubuntu': tfilename = \ '{}/vpp/vpp-config/configs/iperf-ubuntu.xml.template'.format( self._rootdir) else: tfilename = \ '{}/vpp/vpp-config/configs/iperf-centos.xml.template'.format( self._rootdir) with open(tfilename, 'r') as tfile: tcontents = tfile.read() tfile.close() # Add the variables imagename = '{}/vpp/vpp-config/{}'.format( self._rootdir, IPERFVM_IMAGE) isoname = '{}/vpp/vpp-config/{}'.format(self._rootdir, IPERFVM_ISO) tcontents = tcontents.format(vmname=vmname, imagename=imagename, isoname=isoname, vhostsocketname=self._sockfilename) # Write the xml ifilename = '{}/vpp/vpp-config/{}'.format(self._rootdir, IPERFVM_XML) with open(ifilename, 'w+') as ifile: ifile.write(tcontents) ifile.close() cmd = 'virsh create {}'.format(ifilename) (ret, stdout, stderr) = VPPUtil.exec_command(cmd) if ret != 0: logging.debug(stderr) raise RuntimeError( "Couldn't execute the command {} : {}".format(cmd, stderr))