tests: replace pycodestyle with black

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>

1 files changed, 267 insertions, 217 deletions

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:<qemu_id>:<vhost_id>, 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"]))