X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=extras%2Fvpp_config%2Fvpplib%2FQemuUtils.py;h=e1da7ae72bf8d87b2ebe662de1251cfc58c0bb05;hb=d9b0c6fbf7aa5bd9af84264105b39c82028a4a29;hp=0b7e08b12d881a68cbd7cd6ac231a9a97e788841;hpb=f90348bcb4afd0af2611cefc43b17ef3042b511c;p=vpp.git diff --git a/extras/vpp_config/vpplib/QemuUtils.py b/extras/vpp_config/vpplib/QemuUtils.py index 0b7e08b12d8..e1da7ae72bf 100644 --- a/extras/vpp_config/vpplib/QemuUtils.py +++ b/extras/vpp_config/vpplib/QemuUtils.py @@ -12,7 +12,7 @@ # limitations under the License. """QEMU utilities library.""" -from __future__ import absolute_import, division +from __future__ import absolute_import, division from time import time, sleep import json @@ -24,12 +24,13 @@ from vpplib.constants import Constants class NodeType(object): """Defines node types used in topology dictionaries.""" + # Device Under Test (this node has VPP running on it) - DUT = 'DUT' + DUT = "DUT" # Traffic Generator (this node has traffic generator on it) - TG = 'TG' + TG = "TG" # Virtual Machine (this node running on DUT node) - VM = 'VM' + VM = "VM" class QemuUtils(object): @@ -39,43 +40,46 @@ class QemuUtils(object): def __init__(self, qemu_id=1): self._qemu_id = qemu_id # Path to QEMU binary - self._qemu_bin = '/usr/bin/qemu-system-x86_64' + self._qemu_bin = "/usr/bin/qemu-system-x86_64" # QEMU Machine Protocol socket - self._qmp_sock = '/tmp/qmp{0}.sock'.format(self._qemu_id) + self._qmp_sock = "/tmp/qmp{0}.sock".format(self._qemu_id) # QEMU Guest Agent socket - self._qga_sock = '/tmp/qga{0}.sock'.format(self._qemu_id) + self._qga_sock = "/tmp/qga{0}.sock".format(self._qemu_id) # QEMU PID file - self._pid_file = '/tmp/qemu{0}.pid'.format(self._qemu_id) + self._pid_file = "/tmp/qemu{0}.pid".format(self._qemu_id) self._qemu_opt = {} # Default 1 CPU. - self._qemu_opt['smp'] = '-smp 1,sockets=1,cores=1,threads=1' + self._qemu_opt["smp"] = "-smp 1,sockets=1,cores=1,threads=1" # Daemonize the QEMU process after initialization. Default one # management interface. - self._qemu_opt['options'] = '-cpu host -daemonize -enable-kvm ' \ - '-machine pc,accel=kvm,usb=off,mem-merge=off ' \ - '-net nic,macaddr=52:54:00:00:{0:02x}:ff -balloon none'\ - .format(self._qemu_id) - self._qemu_opt['ssh_fwd_port'] = 10021 + qemu_id + self._qemu_opt["options"] = ( + "-cpu host -daemonize -enable-kvm " + "-machine pc,accel=kvm,usb=off,mem-merge=off " + "-net nic,macaddr=52:54:00:00:{0:02x}:ff -balloon none".format( + self._qemu_id + ) + ) + self._qemu_opt["ssh_fwd_port"] = 10021 + qemu_id # Default serial console port - self._qemu_opt['serial_port'] = 4555 + qemu_id + self._qemu_opt["serial_port"] = 4555 + qemu_id # Default 512MB virtual RAM - self._qemu_opt['mem_size'] = 512 + self._qemu_opt["mem_size"] = 512 # Default huge page mount point, required for Vhost-user interfaces. - self._qemu_opt['huge_mnt'] = '/mnt/huge' + self._qemu_opt["huge_mnt"] = "/mnt/huge" # Default do not allocate huge pages. - self._qemu_opt['huge_allocate'] = False + self._qemu_opt["huge_allocate"] = False # Default image for CSIT virl setup - self._qemu_opt['disk_image'] = '/var/lib/vm/vhost-nested.img' + self._qemu_opt["disk_image"] = "/var/lib/vm/vhost-nested.img" # VM node info dict self._vm_info = { - 'type': NodeType.VM, - 'port': self._qemu_opt['ssh_fwd_port'], - 'username': 'cisco', - 'password': 'cisco', - 'interfaces': {}, + "type": NodeType.VM, + "port": self._qemu_opt["ssh_fwd_port"], + "username": "cisco", + "password": "cisco", + "interfaces": {}, } # Virtio queue count - self._qemu_opt['queues'] = 1 + self._qemu_opt["queues"] = 1 self._vhost_id = 0 self._ssh = None self._node = None @@ -101,9 +105,9 @@ class QemuUtils(object): :type threads: int :type sockets: int """ - self._qemu_opt['smp'] = \ - '-smp {},cores={},threads={},sockets={}'.format( - cpus, cores, threads, sockets) + self._qemu_opt["smp"] = "-smp {},cores={},threads={},sockets={}".format( + cpus, cores, threads, sockets + ) def qemu_set_ssh_fwd_port(self, fwd_port): """Set host port for guest SSH forwarding. @@ -111,8 +115,8 @@ class QemuUtils(object): :param fwd_port: Port number on host for guest SSH forwarding. :type fwd_port: int """ - self._qemu_opt['ssh_fwd_port'] = fwd_port - self._vm_info['port'] = fwd_port + self._qemu_opt["ssh_fwd_port"] = fwd_port + self._vm_info["port"] = fwd_port def qemu_set_serial_port(self, port): """Set serial console port. @@ -120,7 +124,7 @@ class QemuUtils(object): :param port: Serial console port. :type port: int """ - self._qemu_opt['serial_port'] = port + self._qemu_opt["serial_port"] = port def qemu_set_mem_size(self, mem_size): """Set virtual RAM size. @@ -128,7 +132,7 @@ class QemuUtils(object): :param mem_size: RAM size in Mega Bytes. :type mem_size: int """ - self._qemu_opt['mem_size'] = int(mem_size) + self._qemu_opt["mem_size"] = int(mem_size) def qemu_set_huge_mnt(self, huge_mnt): """Set hugefile mount point. @@ -136,11 +140,11 @@ class QemuUtils(object): :param huge_mnt: System hugefile mount point. :type huge_mnt: int """ - self._qemu_opt['huge_mnt'] = huge_mnt + self._qemu_opt["huge_mnt"] = huge_mnt def qemu_set_huge_allocate(self): """Set flag to allocate more huge pages if needed.""" - self._qemu_opt['huge_allocate'] = True + self._qemu_opt["huge_allocate"] = True def qemu_set_disk_image(self, disk_image): """Set disk image. @@ -148,7 +152,7 @@ class QemuUtils(object): :param disk_image: Path of the disk image. :type disk_image: str """ - self._qemu_opt['disk_image'] = disk_image + self._qemu_opt["disk_image"] = disk_image def qemu_set_affinity(self, *host_cpus): """Set qemu affinity by getting thread PIDs via QMP and taskset to list @@ -157,36 +161,41 @@ class QemuUtils(object): :param host_cpus: List of CPU cores. :type host_cpus: list """ - qemu_cpus = self._qemu_qmp_exec('query-cpus')['return'] + qemu_cpus = self._qemu_qmp_exec("query-cpus")["return"] if len(qemu_cpus) != len(host_cpus): - logging.debug('Host CPU count {0}, Qemu Thread count {1}'.format( - len(host_cpus), len(qemu_cpus))) - raise ValueError('Host CPU count must match Qemu Thread count') + logging.debug( + "Host CPU count {0}, Qemu Thread count {1}".format( + len(host_cpus), len(qemu_cpus) + ) + ) + raise ValueError("Host CPU count must match Qemu Thread count") for qemu_cpu, host_cpu in zip(qemu_cpus, host_cpus): - cmd = 'taskset -pc {0} {1}'.format(host_cpu, qemu_cpu['thread_id']) + cmd = "taskset -pc {0} {1}".format(host_cpu, qemu_cpu["thread_id"]) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd) if int(ret_code) != 0: - logging.debug('Set affinity failed {0}'.format(stderr)) - raise RuntimeError('Set affinity failed on {0}'.format( - self._node['host'])) + logging.debug("Set affinity failed {0}".format(stderr)) + raise RuntimeError( + "Set affinity failed on {0}".format(self._node["host"]) + ) def qemu_set_scheduler_policy(self): """Set scheduler policy to SCHED_RR with priority 1 for all Qemu CPU - processes. + processes. - :raises RuntimeError: Set scheduler policy failed. + :raises RuntimeError: Set scheduler policy failed. """ - qemu_cpus = self._qemu_qmp_exec('query-cpus')['return'] + qemu_cpus = self._qemu_qmp_exec("query-cpus")["return"] for qemu_cpu in qemu_cpus: - cmd = 'chrt -r -p 1 {0}'.format(qemu_cpu['thread_id']) + cmd = "chrt -r -p 1 {0}".format(qemu_cpu["thread_id"]) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd) if int(ret_code) != 0: - logging.debug('Set SCHED_RR failed {0}'.format(stderr)) - raise RuntimeError('Set SCHED_RR failed on {0}'.format( - self._node['host'])) + logging.debug("Set SCHED_RR failed {0}".format(stderr)) + raise RuntimeError( + "Set SCHED_RR failed on {0}".format(self._node["host"]) + ) def qemu_set_node(self, node): """Set node to run QEMU on. @@ -195,7 +204,7 @@ class QemuUtils(object): :type node: dict """ self._node = node - self._vm_info['host'] = node['host'] + self._vm_info["host"] = node["host"] def qemu_add_vhost_user_if(self, socket, server=True, mac=None): """Add Vhost-user interface. @@ -210,31 +219,33 @@ class QemuUtils(object): """ self._vhost_id += 1 # Create unix socket character device. - chardev = ' -chardev socket,id=char{0},path={1}'.format(self._vhost_id, - socket) + chardev = " -chardev socket,id=char{0},path={1}".format(self._vhost_id, socket) if server is True: - chardev += ',server' - self._qemu_opt['options'] += chardev + chardev += ",server" + self._qemu_opt["options"] += chardev # Create Vhost-user network backend. - netdev = (' -netdev vhost-user,id=vhost{0},chardev=char{0},queues={1}' - .format(self._vhost_id, self._qemu_opt['queues'])) - self._qemu_opt['options'] += netdev + netdev = " -netdev vhost-user,id=vhost{0},chardev=char{0},queues={1}".format( + self._vhost_id, self._qemu_opt["queues"] + ) + self._qemu_opt["options"] += netdev # If MAC is not specified use auto-generated MAC address based on # template 52:54:00:00::, e.g. vhost1 MAC of QEMU # with ID 1 is 52:54:00:00:01:01 if mac is None: - mac = '52:54:00:00:{0:02x}:{1:02x}'.\ - format(self._qemu_id, self._vhost_id) - extend_options = 'mq=on,csum=off,gso=off,guest_tso4=off,'\ - 'guest_tso6=off,guest_ecn=off,mrg_rxbuf=off' + mac = "52:54:00:00:{0:02x}:{1:02x}".format(self._qemu_id, self._vhost_id) + extend_options = ( + "mq=on,csum=off,gso=off,guest_tso4=off," + "guest_tso6=off,guest_ecn=off,mrg_rxbuf=off" + ) # Create Virtio network device. - device = ' -device virtio-net-pci,netdev=vhost{0},mac={1},{2}'.format( - self._vhost_id, mac, extend_options) - self._qemu_opt['options'] += device + device = " -device virtio-net-pci,netdev=vhost{0},mac={1},{2}".format( + self._vhost_id, mac, extend_options + ) + self._qemu_opt["options"] += device # Add interface MAC and socket to the node dict - if_data = {'mac_address': mac, 'socket': socket} - if_name = 'vhost{}'.format(self._vhost_id) - self._vm_info['interfaces'][if_name] = if_data + if_data = {"mac_address": mac, "socket": socket} + if_name = "vhost{}".format(self._vhost_id) + self._vm_info["interfaces"][if_name] = if_data # Add socket to the socket list self._socks.append(socket) @@ -250,41 +261,44 @@ class QemuUtils(object): response will contain the "error" keyword instead of "return". """ # To enter command mode, the qmp_capabilities command must be issued. - qmp_cmd = 'echo "{ \\"execute\\": \\"qmp_capabilities\\" }' \ - '{ \\"execute\\": \\"' + cmd + \ - '\\" }" | sudo -S socat - UNIX-CONNECT:' + self._qmp_sock + qmp_cmd = ( + 'echo "{ \\"execute\\": \\"qmp_capabilities\\" }' + '{ \\"execute\\": \\"' + + cmd + + '\\" }" | sudo -S socat - UNIX-CONNECT:' + + self._qmp_sock + ) (ret_code, stdout, stderr) = self._ssh.exec_command(qmp_cmd) if int(ret_code) != 0: - logging.debug('QMP execute failed {0}'.format(stderr)) - raise RuntimeError('QMP execute "{0}"' - ' failed on {1}'.format( - cmd, self._node['host'])) + logging.debug("QMP execute failed {0}".format(stderr)) + raise RuntimeError( + 'QMP execute "{0}"' " failed on {1}".format(cmd, self._node["host"]) + ) logging.debug(stdout) # Skip capabilities negotiation messages. out_list = stdout.splitlines() if len(out_list) < 3: - raise RuntimeError('Invalid QMP output on {0}'.format( - self._node['host'])) + raise RuntimeError("Invalid QMP output on {0}".format(self._node["host"])) return json.loads(out_list[2]) def _qemu_qga_flush(self): - """Flush the QGA parser state - """ - qga_cmd = '(printf "\xFF"; sleep 1) | ' \ - 'sudo -S socat - UNIX-CONNECT:' + \ - self._qga_sock + """Flush the QGA parser state""" + qga_cmd = ( + '(printf "\xFF"; sleep 1) | ' + "sudo -S socat - UNIX-CONNECT:" + self._qga_sock + ) # TODO: probably need something else (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd) if int(ret_code) != 0: - logging.debug('QGA execute failed {0}'.format(stderr)) - raise RuntimeError('QGA execute "{0}" ' - 'failed on {1}'.format(qga_cmd, - self._node['host'])) + logging.debug("QGA execute failed {0}".format(stderr)) + raise RuntimeError( + 'QGA execute "{0}" ' "failed on {1}".format(qga_cmd, self._node["host"]) + ) logging.debug(stdout) if not stdout: return {} - return json.loads(stdout.split('\n', 1)[0]) + return json.loads(stdout.split("\n", 1)[0]) def _qemu_qga_exec(self, cmd): """Execute QGA command. @@ -294,20 +308,22 @@ class QemuUtils(object): :param cmd: QGA command to execute. :type cmd: str """ - qga_cmd = '(echo "{ \\"execute\\": \\"' + \ - cmd + \ - '\\" }"; sleep 1) | sudo -S socat - UNIX-CONNECT:' + \ - self._qga_sock + qga_cmd = ( + '(echo "{ \\"execute\\": \\"' + + cmd + + '\\" }"; sleep 1) | sudo -S socat - UNIX-CONNECT:' + + self._qga_sock + ) (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd) if int(ret_code) != 0: - logging.debug('QGA execute failed {0}'.format(stderr)) - raise RuntimeError('QGA execute "{0}"' - ' failed on {1}'.format( - cmd, self._node['host'])) + logging.debug("QGA execute failed {0}".format(stderr)) + raise RuntimeError( + 'QGA execute "{0}"' " failed on {1}".format(cmd, self._node["host"]) + ) logging.debug(stdout) if not stdout: return {} - return json.loads(stdout.split('\n', 1)[0]) + return json.loads(stdout.split("\n", 1)[0]) def _wait_until_vm_boot(self, timeout=60): """Wait until QEMU VM is booted. @@ -320,65 +336,69 @@ class QemuUtils(object): start = time() while True: if time() - start > timeout: - raise RuntimeError('timeout, VM {0} not booted on {1}'.format( - self._qemu_opt['disk_image'], self._node['host'])) + raise RuntimeError( + "timeout, VM {0} not booted on {1}".format( + self._qemu_opt["disk_image"], self._node["host"] + ) + ) out = None try: self._qemu_qga_flush() - out = self._qemu_qga_exec('guest-ping') + out = self._qemu_qga_exec("guest-ping") except ValueError: - logging.debug( - 'QGA guest-ping unexpected output {}'.format(out)) + logging.debug("QGA guest-ping unexpected output {}".format(out)) # Empty output - VM not booted yet if not out: sleep(5) # Non-error return - VM booted - elif out.get('return') is not None: + elif out.get("return") is not None: break # Skip error and wait - elif out.get('error') is not None: + elif out.get("error") is not None: sleep(5) else: # If there is an unexpected output from QGA guest-info, try # again until timeout. - logging.debug( - 'QGA guest-ping unexpected output {}'.format(out)) + logging.debug("QGA guest-ping unexpected output {}".format(out)) logging.debug( - 'VM {0} booted on {1}'.format(self._qemu_opt['disk_image'], - self._node['host'])) + "VM {0} booted on {1}".format( + self._qemu_opt["disk_image"], self._node["host"] + ) + ) def _update_vm_interfaces(self): """Update interface names in VM node dict.""" # Send guest-network-get-interfaces command via QGA, output example: # {"return": [{"name": "eth0", "hardware-address": "52:54:00:00:04:01"}, # {"name": "eth1", "hardware-address": "52:54:00:00:04:02"}]} - out = self._qemu_qga_exec('guest-network-get-interfaces') - interfaces = out.get('return') + out = self._qemu_qga_exec("guest-network-get-interfaces") + interfaces = out.get("return") mac_name = {} if not interfaces: raise RuntimeError( - 'Get VM {0} interface list failed on {1}'.format( - self._qemu_opt['disk_image'], self._node['host'])) + "Get VM {0} interface list failed on {1}".format( + self._qemu_opt["disk_image"], self._node["host"] + ) + ) # Create MAC-name dict for interface in interfaces: - if 'hardware-address' not in interface: + if "hardware-address" not in interface: continue - mac_name[interface['hardware-address']] = interface['name'] + mac_name[interface["hardware-address"]] = interface["name"] # Match interface by MAC and save interface name - for interface in self._vm_info['interfaces'].values(): - mac = interface.get('mac_address') + for interface in self._vm_info["interfaces"].values(): + mac = interface.get("mac_address") if_name = mac_name.get(mac) if if_name is None: - logging.debug( - 'Interface name for MAC {} not found'.format(mac)) + logging.debug("Interface name for MAC {} not found".format(mac)) else: - interface['name'] = if_name + interface["name"] = if_name def _huge_page_check(self, allocate=False): """Huge page check.""" - huge_mnt = self._qemu_opt.get('huge_mnt') - mem_size = self._qemu_opt.get('mem_size') + huge_mnt = self._qemu_opt.get("huge_mnt") + mem_size = self._qemu_opt.get("mem_size") # Get huge pages information huge_size = self._get_huge_page_size() @@ -391,55 +411,55 @@ class QemuUtils(object): if allocate: mem_needed = abs((huge_free * huge_size) - (mem_size * 1024)) huge_to_allocate = ((mem_needed // huge_size) * 2) + huge_total - max_map_count = huge_to_allocate*4 + max_map_count = huge_to_allocate * 4 # Increase maximum number of memory map areas a # process may have - cmd = \ - 'echo "{0}" | sudo tee /proc/sys/vm/max_map_count'.format( - max_map_count) + cmd = 'echo "{0}" | sudo tee /proc/sys/vm/max_map_count'.format( + max_map_count + ) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd) # Increase hugepage count - cmd = \ - 'echo "{0}" | sudo tee /proc/sys/vm/nr_hugepages'.format( - huge_to_allocate) + cmd = 'echo "{0}" | sudo tee /proc/sys/vm/nr_hugepages'.format( + huge_to_allocate + ) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd) if int(ret_code) != 0: - logging.debug( - 'Mount huge pages failed {0}'.format(stderr)) + logging.debug("Mount huge pages failed {0}".format(stderr)) raise RuntimeError( - 'Mount huge pages failed on {0}'.format( - self._node['host'])) + "Mount huge pages failed on {0}".format(self._node["host"]) + ) # If we do not want to allocate dynamicaly end with error else: raise RuntimeError( - 'Not enough free huge pages: {0}, ' - '{1} MB'.format(huge_free, huge_free * huge_size) + "Not enough free huge pages: {0}, " + "{1} MB".format(huge_free, huge_free * huge_size) ) # Check if huge pages mount point exist has_huge_mnt = False - (_, output, _) = self._ssh.exec_command('cat /proc/mounts') + (_, output, _) = self._ssh.exec_command("cat /proc/mounts") for line in output.splitlines(): # Try to find something like: # none /mnt/huge hugetlbfs rw,relatime,pagesize=2048k 0 0 mount = line.split() - if mount[2] == 'hugetlbfs' and mount[1] == huge_mnt: + if mount[2] == "hugetlbfs" and mount[1] == huge_mnt: has_huge_mnt = True break # If huge page mount point not exist create one if not has_huge_mnt: - cmd = 'mkdir -p {0}'.format(huge_mnt) + cmd = "mkdir -p {0}".format(huge_mnt) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd) if int(ret_code) != 0: - logging.debug('Create mount dir failed: {0}'.format(stderr)) - raise RuntimeError('Create mount dir failed on {0}'.format( - self._node['host'])) - cmd = 'mount -t hugetlbfs -o pagesize=2048k none {0}'.format( - huge_mnt) + logging.debug("Create mount dir failed: {0}".format(stderr)) + raise RuntimeError( + "Create mount dir failed on {0}".format(self._node["host"]) + ) + cmd = "mount -t hugetlbfs -o pagesize=2048k none {0}".format(huge_mnt) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd) if int(ret_code) != 0: - logging.debug('Mount huge pages failed {0}'.format(stderr)) - raise RuntimeError('Mount huge pages failed on {0}'.format( - self._node['host'])) + logging.debug("Mount huge pages failed {0}".format(stderr)) + raise RuntimeError( + "Mount huge pages failed on {0}".format(self._node["host"]) + ) def _get_huge_page_size(self): """Get default size of huge pages in system. @@ -456,11 +476,11 @@ class QemuUtils(object): try: huge_size = int(out) except ValueError: - logging.debug('Reading huge page size information failed') + logging.debug("Reading huge page size information failed") else: break else: - raise RuntimeError('Getting huge page size information failed.') + raise RuntimeError("Getting huge page size information failed.") return huge_size def _get_huge_page_free(self, huge_size): @@ -474,20 +494,21 @@ class QemuUtils(object): """ # TODO: add numa aware option # TODO: remove to dedicated library - cmd_huge_free = 'cat /sys/kernel/mm/hugepages/hugepages-{0}kB/'\ - 'free_hugepages'.format(huge_size) + cmd_huge_free = ( + "cat /sys/kernel/mm/hugepages/hugepages-{0}kB/" + "free_hugepages".format(huge_size) + ) for _ in range(3): (ret, out, _) = self._ssh.exec_command_sudo(cmd_huge_free) if ret == 0: try: huge_free = int(out) except ValueError: - logging.debug( - 'Reading free huge pages information failed') + logging.debug("Reading free huge pages information failed") else: break else: - raise RuntimeError('Getting free huge pages information failed.') + raise RuntimeError("Getting free huge pages information failed.") return huge_free def _get_huge_page_total(self, huge_size): @@ -501,20 +522,21 @@ class QemuUtils(object): """ # TODO: add numa aware option # TODO: remove to dedicated library - cmd_huge_total = 'cat /sys/kernel/mm/hugepages/hugepages-{0}kB/'\ - 'nr_hugepages'.format(huge_size) + cmd_huge_total = ( + "cat /sys/kernel/mm/hugepages/hugepages-{0}kB/" + "nr_hugepages".format(huge_size) + ) for _ in range(3): (ret, out, _) = self._ssh.exec_command_sudo(cmd_huge_total) if ret == 0: try: huge_total = int(out) except ValueError: - logging.debug( - 'Reading total huge pages information failed') + logging.debug("Reading total huge pages information failed") else: break else: - raise RuntimeError('Getting total huge pages information failed.') + raise RuntimeError("Getting total huge pages information failed.") return huge_total def qemu_start(self): @@ -526,45 +548,63 @@ class QemuUtils(object): .. warning:: Starts only one VM on the node. """ # SSH forwarding - ssh_fwd = '-net user,hostfwd=tcp::{0}-:22'.format( - self._qemu_opt.get('ssh_fwd_port')) + ssh_fwd = "-net user,hostfwd=tcp::{0}-:22".format( + self._qemu_opt.get("ssh_fwd_port") + ) # Memory and huge pages - mem = '-object memory-backend-file,id=mem,size={0}M,mem-path={1},' \ - 'share=on -m {0} -numa node,memdev=mem'.format( - self._qemu_opt.get('mem_size'), self._qemu_opt.get('huge_mnt')) + mem = ( + "-object memory-backend-file,id=mem,size={0}M,mem-path={1}," + "share=on -m {0} -numa node,memdev=mem".format( + self._qemu_opt.get("mem_size"), self._qemu_opt.get("huge_mnt") + ) + ) # By default check only if hugepages are available. # If 'huge_allocate' is set to true try to allocate as well. - self._huge_page_check(allocate=self._qemu_opt.get('huge_allocate')) + self._huge_page_check(allocate=self._qemu_opt.get("huge_allocate")) # Disk option - drive = '-drive file={0},format=raw,cache=none,if=virtio'.format( - self._qemu_opt.get('disk_image')) + drive = "-drive file={0},format=raw,cache=none,if=virtio".format( + self._qemu_opt.get("disk_image") + ) # Setup QMP via unix socket - qmp = '-qmp unix:{0},server,nowait'.format(self._qmp_sock) + qmp = "-qmp unix:{0},server,nowait".format(self._qmp_sock) # Setup serial console - serial = '-chardev socket,host=127.0.0.1,port={0},id=gnc0,server,' \ - 'nowait -device isa-serial,chardev=gnc0'.format( - self._qemu_opt.get('serial_port')) + serial = ( + "-chardev socket,host=127.0.0.1,port={0},id=gnc0,server," + "nowait -device isa-serial,chardev=gnc0".format( + self._qemu_opt.get("serial_port") + ) + ) # Setup QGA via chardev (unix socket) and isa-serial channel - qga = '-chardev socket,path={0},server,nowait,id=qga0 ' \ - '-device isa-serial,chardev=qga0'.format(self._qga_sock) + qga = ( + "-chardev socket,path={0},server,nowait,id=qga0 " + "-device isa-serial,chardev=qga0".format(self._qga_sock) + ) # Graphic setup - graphic = '-monitor none -display none -vga none' + graphic = "-monitor none -display none -vga none" # PID file - pid = '-pidfile {}'.format(self._pid_file) + pid = "-pidfile {}".format(self._pid_file) # Run QEMU - cmd = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10}'.format( - self._qemu_bin, self._qemu_opt.get('smp'), mem, ssh_fwd, - self._qemu_opt.get('options'), - drive, qmp, serial, qga, graphic, pid) + cmd = "{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10}".format( + self._qemu_bin, + self._qemu_opt.get("smp"), + mem, + ssh_fwd, + self._qemu_opt.get("options"), + drive, + qmp, + serial, + qga, + graphic, + pid, + ) (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd, timeout=300) if int(ret_code) != 0: - logging.debug('QEMU start failed {0}'.format(stderr)) - raise RuntimeError('QEMU start failed on {0}'.format( - self._node['host'])) - logging.debug('QEMU running') + logging.debug("QEMU start failed {0}".format(stderr)) + raise RuntimeError("QEMU start failed on {0}".format(self._node["host"])) + logging.debug("QEMU running") # Wait until VM boot try: self._wait_until_vm_boot() @@ -579,40 +619,43 @@ class QemuUtils(object): def qemu_quit(self): """Quit the QEMU emulator.""" - out = self._qemu_qmp_exec('quit') - err = out.get('error') + out = self._qemu_qmp_exec("quit") + err = out.get("error") if err is not None: - raise RuntimeError('QEMU quit failed on {0}, error: {1}'.format( - self._node['host'], json.dumps(err))) + raise RuntimeError( + "QEMU quit failed on {0}, error: {1}".format( + self._node["host"], json.dumps(err) + ) + ) def qemu_system_powerdown(self): """Power down the system (if supported).""" - out = self._qemu_qmp_exec('system_powerdown') - err = out.get('error') + out = self._qemu_qmp_exec("system_powerdown") + err = out.get("error") if err is not None: raise RuntimeError( - 'QEMU system powerdown failed on {0}, ' - 'error: {1}'.format(self._node['host'], json.dumps(err)) + "QEMU system powerdown failed on {0}, " + "error: {1}".format(self._node["host"], json.dumps(err)) ) def qemu_system_reset(self): """Reset the system.""" - out = self._qemu_qmp_exec('system_reset') - err = out.get('error') + out = self._qemu_qmp_exec("system_reset") + err = out.get("error") if err is not None: raise RuntimeError( - 'QEMU system reset failed on {0}, ' - 'error: {1}'.format(self._node['host'], json.dumps(err))) + "QEMU system reset failed on {0}, " + "error: {1}".format(self._node["host"], json.dumps(err)) + ) def qemu_kill(self): """Kill qemu process.""" # Note: in QEMU start phase there are 3 QEMU processes because we # daemonize QEMU - self._ssh.exec_command_sudo('chmod +r {}'.format(self._pid_file)) - self._ssh.exec_command_sudo('kill -SIGKILL $(cat {})' - .format(self._pid_file)) + self._ssh.exec_command_sudo("chmod +r {}".format(self._pid_file)) + self._ssh.exec_command_sudo("kill -SIGKILL $(cat {})".format(self._pid_file)) # Delete PID file - cmd = 'rm -f {}'.format(self._pid_file) + cmd = "rm -f {}".format(self._pid_file) self._ssh.exec_command_sudo(cmd) def qemu_kill_all(self, node=None): @@ -623,16 +666,16 @@ class QemuUtils(object): """ if node: self.qemu_set_node(node) - self._ssh.exec_command_sudo('pkill -SIGKILL qemu') + self._ssh.exec_command_sudo("pkill -SIGKILL qemu") def qemu_clear_socks(self): """Remove all sockets created by QEMU.""" # If serial console port still open kill process - cmd = 'fuser -k {}/tcp'.format(self._qemu_opt.get('serial_port')) + cmd = "fuser -k {}/tcp".format(self._qemu_opt.get("serial_port")) self._ssh.exec_command_sudo(cmd) # Delete all created sockets for sock in self._socks: - cmd = 'rm -f {}'.format(sock) + cmd = "rm -f {}".format(sock) self._ssh.exec_command_sudo(cmd) def qemu_system_status(self): @@ -659,15 +702,16 @@ class QemuUtils(object): :return: VM status. :rtype: str """ - out = self._qemu_qmp_exec('query-status') - ret = out.get('return') + out = self._qemu_qmp_exec("query-status") + ret = out.get("return") if ret is not None: - return ret.get('status') + return ret.get("status") else: - err = out.get('error') + err = out.get("error") raise RuntimeError( - 'QEMU query-status failed on {0}, ' - 'error: {1}'.format(self._node['host'], json.dumps(err))) + "QEMU query-status failed on {0}, " + "error: {1}".format(self._node["host"], json.dumps(err)) + ) @staticmethod def build_qemu(node, force_install=False, apply_patch=False): @@ -682,17 +726,23 @@ class QemuUtils(object): :raises: RuntimeError if building QEMU failed. """ - directory = ' --directory={0}'.format(Constants.QEMU_INSTALL_DIR) - version = ' --version={0}'.format(Constants.QEMU_INSTALL_VERSION) - force = ' --force' if force_install else '' - patch = ' --patch' if apply_patch else '' - - (ret_code, stdout, stderr) = VPPUtil. \ - exec_command( - "sudo -E sh -c '{0}/{1}/qemu_build.sh{2}{3}{4}{5}'". - format(Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH, - version, directory, force, patch), 1000) + directory = " --directory={0}".format(Constants.QEMU_INSTALL_DIR) + version = " --version={0}".format(Constants.QEMU_INSTALL_VERSION) + force = " --force" if force_install else "" + patch = " --patch" if apply_patch else "" + + (ret_code, stdout, stderr) = VPPUtil.exec_command( + "sudo -E sh -c '{0}/{1}/qemu_build.sh{2}{3}{4}{5}'".format( + Constants.REMOTE_FW_DIR, + Constants.RESOURCES_LIB_SH, + version, + directory, + force, + patch, + ), + 1000, + ) if int(ret_code) != 0: - logging.debug('QEMU build failed {0}'.format(stdout + stderr)) - raise RuntimeError('QEMU build failed on {0}'.format(node['host'])) + logging.debug("QEMU build failed {0}".format(stdout + stderr)) + raise RuntimeError("QEMU build failed on {0}".format(node["host"]))