| # 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 ValueError: |
| 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_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 != 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"] |
| |
| 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 += " }" |
| |
| return devices |
| |
| @staticmethod |
| def _apply_buffers(node): |
| """ |
| Apply VPP PCI Device configuration to vpp startup. |
| |
| :param node: Node dictionary with cpuinfo. |
| :type node: dict |
| """ |
| buffers = "" |
| total_mbufs = node["cpu"]["total_mbufs"] |
| |
| # 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 != 0 and total_mbufs > 16384: |
| buffers += " buffers-per-numa {}".format(total_mbufs) |
| |
| return buffers |
| |
| @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 |
| |
| 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 != 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 != 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 tcp 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 buffers |
| devices = self._apply_vpp_devices(node) |
| |
| # Get the CPU config |
| cpu = self._apply_vpp_cpu(node) |
| |
| # Get the buffer configuration |
| buffers = self._apply_buffers(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(cpu=cpu, buffers=buffers, 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 != 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) == 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." |
| ) |
| |
| # Leave 1 for the general system |
| total_cpus -= 1 |
| max_vpp_cpus = min(total_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 |
| |
| total_other_cpus = 0 |
| max_other_cores = total_cpus - total_vpp_cpus |
| if max_other_cores > 0: |
| 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 = total_cpus - total_vpp_cpus - total_other_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 >= 4: |
| 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 != 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 has_interfaces(node): |
| """ |
| Check for interfaces, return tru if there is at least one |
| |
| :returns: boolean |
| """ |
| if "interfaces" in node and len(node["interfaces"]): |
| return True |
| else: |
| return False |
| |
| @staticmethod |
| def min_system_resources(node): |
| """ |
| Check the system for basic minimum resources, return true if |
| there is enough. |
| |
| :returns: boolean |
| """ |
| |
| 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 != {}: |
| 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) |
| ) |