d9b0c6fbf7
Drop pycodestyle for code style checking in favor of black. Black is much faster, stable PEP8 compliant code style checker offering also automatic formatting. It aims to be very stable and produce smallest diffs. It's used by many small and big projects. Running checkstyle with black takes a few seconds with a terse output. Thus, test-checkstyle-diff is no longer necessary. Expand scope of checkstyle to all python files in the repo, replacing test-checkstyle with checkstyle-python. Also, fixstyle-python is now available for automatic style formatting. Note: python virtualenv has been consolidated in test/Makefile, test/requirements*.txt which will eventually be moved to a central location. This is required to simply the automated generation of docker executor images in the CI. Type: improvement Change-Id: I022a326603485f58585e879ac0f697fceefbc9c8 Signed-off-by: Klement Sekera <klement.sekera@gmail.com> Signed-off-by: Dave Wallace <dwallacelf@gmail.com>
2093 lines
71 KiB
Python
2093 lines
71 KiB
Python
# 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)
|
|
)
|