# 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.

"""QEMU utilities library."""
from __future__ import absolute_import, division

from time import time, sleep
import json
import logging

from vpplib.VPPUtil import VPPUtil
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"
    # Traffic Generator (this node has traffic generator on it)
    TG = "TG"
    # Virtual Machine (this node running on DUT node)
    VM = "VM"


class QemuUtils(object):
    """QEMU utilities."""

    # noinspection PyDictCreation
    def __init__(self, qemu_id=1):
        self._qemu_id = qemu_id
        # Path to QEMU binary
        self._qemu_bin = "/usr/bin/qemu-system-x86_64"
        # QEMU Machine Protocol socket
        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)
        # QEMU PID file
        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"
        # 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
        # Default serial console port
        self._qemu_opt["serial_port"] = 4555 + qemu_id
        # Default 512MB virtual RAM
        self._qemu_opt["mem_size"] = 512
        # Default huge page mount point, required for Vhost-user interfaces.
        self._qemu_opt["huge_mnt"] = "/mnt/huge"
        # Default do not allocate huge pages.
        self._qemu_opt["huge_allocate"] = False
        # Default image for CSIT virl setup
        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": {},
        }
        # Virtio queue count
        self._qemu_opt["queues"] = 1
        self._vhost_id = 0
        self._ssh = None
        self._node = None
        self._socks = [self._qmp_sock, self._qga_sock]

    def qemu_set_bin(self, path):
        """Set binary path for QEMU.

        :param path: Absolute path in filesystem.
        :type path: str
        """
        self._qemu_bin = path

    def qemu_set_smp(self, cpus, cores, threads, sockets):
        """Set SMP option for QEMU.

        :param cpus: Number of CPUs.
        :param cores: Number of CPU cores on one socket.
        :param threads: Number of threads on one CPU core.
        :param sockets: Number of discrete sockets in the system.
        :type cpus: int
        :type cores: int
        :type threads: int
        :type sockets: int
        """
        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.

        :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

    def qemu_set_serial_port(self, port):
        """Set serial console port.

        :param port: Serial console port.
        :type port: int
        """
        self._qemu_opt["serial_port"] = port

    def qemu_set_mem_size(self, mem_size):
        """Set virtual RAM size.

        :param mem_size: RAM size in Mega Bytes.
        :type mem_size: int
        """
        self._qemu_opt["mem_size"] = int(mem_size)

    def qemu_set_huge_mnt(self, huge_mnt):
        """Set hugefile mount point.

        :param huge_mnt: System hugefile mount point.
        :type huge_mnt: int
        """
        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

    def qemu_set_disk_image(self, disk_image):
        """Set disk image.

        :param disk_image: Path of the disk image.
        :type disk_image: str
        """
        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
        of CPU cores.

        :param host_cpus: List of CPU cores.
        :type host_cpus: list
        """
        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")

        for qemu_cpu, host_cpu in zip(qemu_cpus, host_cpus):
            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"])
                )

    def qemu_set_scheduler_policy(self):
        """Set scheduler policy to SCHED_RR with priority 1 for all Qemu CPU
         processes.

        :raises RuntimeError: Set scheduler policy failed.
        """
        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"])
            (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"])
                )

    def qemu_set_node(self, node):
        """Set node to run QEMU on.

        :param node: Node to run QEMU on.
        :type node: dict
        """
        self._node = node
        self._vm_info["host"] = node["host"]

    def qemu_add_vhost_user_if(self, socket, server=True, mac=None):
        """Add Vhost-user interface.

        :param socket: Path of the unix socket.
        :param server: If True the socket shall be a listening socket.
        :param mac: Vhost-user interface MAC address (optional, otherwise is
            used auto-generated MAC 52:54:00:00:xx:yy).
        :type socket: str
        :type server: bool
        :type mac: str
        """
        self._vhost_id += 1
        # Create unix socket character device.
        chardev = " -chardev socket,id=char{0},path={1}".format(self._vhost_id, socket)
        if server is True:
            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
        # 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"
        )
        # 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
        # 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
        # Add socket to the socket list
        self._socks.append(socket)

    def _qemu_qmp_exec(self, cmd):
        """Execute QMP command.

        QMP is JSON based protocol which allows to control QEMU instance.

        :param cmd: QMP command to execute.
        :type cmd: str
        :return: Command output in python representation of JSON format. The
            { "return": {} } response is QMP's success response. An error
            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
        )

        (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(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"]))
        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
        )
        # 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(stdout)
        if not stdout:
            return {}
        return json.loads(stdout.split("\n", 1)[0])

    def _qemu_qga_exec(self, cmd):
        """Execute QGA command.

        QGA provide access to a system-level agent via standard QMP commands.

        :param cmd: QGA command to execute.
        :type cmd: str
        """
        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(stdout)
        if not stdout:
            return {}
        return json.loads(stdout.split("\n", 1)[0])

    def _wait_until_vm_boot(self, timeout=60):
        """Wait until QEMU VM is booted.

        Ping QEMU guest agent each 5s until VM booted or timeout.

        :param timeout: Waiting timeout in seconds (optional, default 60s).
        :type timeout: int
        """
        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"]
                    )
                )
            out = None
            try:
                self._qemu_qga_flush()
                out = self._qemu_qga_exec("guest-ping")
            except ValueError:
                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:
                break
            # Skip error and wait
            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(
            "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")
        mac_name = {}
        if not interfaces:
            raise RuntimeError(
                "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:
                continue
            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")
            if_name = mac_name.get(mac)
            if if_name is None:
                logging.debug("Interface name for MAC {} not found".format(mac))
            else:
                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")

        # Get huge pages information
        huge_size = self._get_huge_page_size()
        huge_free = self._get_huge_page_free(huge_size)
        huge_total = self._get_huge_page_total(huge_size)

        # Check if memory reqested by qemu is available on host
        if (mem_size * 1024) > (huge_free * huge_size):
            # If we want to allocate hugepage dynamically
            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
                # 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
                )
                (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
                )
                (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"])
                    )
            # 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)
                )
        # Check if huge pages mount point exist
        has_huge_mnt = False
        (_, 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:
                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)
            (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)
            (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"])
                )

    def _get_huge_page_size(self):
        """Get default size of huge pages in system.

        :returns: Default size of free huge pages in system.
        :rtype: int
        :raises: RuntimeError if reading failed for three times.
        """
        # TODO: remove to dedicated library
        cmd_huge_size = "grep Hugepagesize /proc/meminfo | awk '{ print $2 }'"
        for _ in range(3):
            (ret, out, _) = self._ssh.exec_command_sudo(cmd_huge_size)
            if ret == 0:
                try:
                    huge_size = int(out)
                except ValueError:
                    logging.debug("Reading huge page size information failed")
                else:
                    break
        else:
            raise RuntimeError("Getting huge page size information failed.")
        return huge_size

    def _get_huge_page_free(self, huge_size):
        """Get total number of huge pages in system.

        :param huge_size: Size of hugepages.
        :type huge_size: int
        :returns: Number of free huge pages in system.
        :rtype: int
        :raises: RuntimeError if reading failed for three times.
        """
        # 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)
        )
        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")
                else:
                    break
        else:
            raise RuntimeError("Getting free huge pages information failed.")
        return huge_free

    def _get_huge_page_total(self, huge_size):
        """Get total number of huge pages in system.

        :param huge_size: Size of hugepages.
        :type huge_size: int
        :returns: Total number of huge pages in system.
        :rtype: int
        :raises: RuntimeError if reading failed for three times.
        """
        # 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)
        )
        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")
                else:
                    break
        else:
            raise RuntimeError("Getting total huge pages information failed.")
        return huge_total

    def qemu_start(self):
        """Start QEMU and wait until VM boot.

        :return: VM node info.
        :rtype: dict
        .. note:: First set at least node to run QEMU on.
        .. 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")
        )
        # 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")
            )
        )

        # 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"))

        # Disk option
        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)
        # 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")
            )
        )
        # 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)
        )
        # Graphic setup
        graphic = "-monitor none -display none -vga none"
        # 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,
        )
        (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")
        # Wait until VM boot
        try:
            self._wait_until_vm_boot()
        except RuntimeError:
            self.qemu_kill_all()
            self.qemu_clear_socks()
            raise
        # Update interface names in VM node dict
        self._update_vm_interfaces()
        # Return VM node dict
        return self._vm_info

    def qemu_quit(self):
        """Quit the QEMU emulator."""
        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)
                )
            )

    def qemu_system_powerdown(self):
        """Power down the system (if supported)."""
        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))
            )

    def qemu_system_reset(self):
        """Reset the system."""
        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))
            )

    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))
        # Delete PID file
        cmd = "rm -f {}".format(self._pid_file)
        self._ssh.exec_command_sudo(cmd)

    def qemu_kill_all(self, node=None):
        """Kill all qemu processes on DUT node if specified.

        :param node: Node to kill all QEMU processes on.
        :type node: dict
        """
        if node:
            self.qemu_set_node(node)
        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"))
        self._ssh.exec_command_sudo(cmd)
        # Delete all created sockets
        for sock in self._socks:
            cmd = "rm -f {}".format(sock)
            self._ssh.exec_command_sudo(cmd)

    def qemu_system_status(self):
        """Return current VM status.

        VM should be in following status:

            - debug: QEMU running on a debugger
            - finish-migrate: paused to finish the migration process
            - inmigrate: waiting for an incoming migration
            - internal-error: internal error has occurred
            - io-error: the last IOP has failed
            - paused: paused
            - postmigrate: paused following a successful migrate
            - prelaunch: QEMU was started with -S and guest has not started
            - restore-vm: paused to restore VM state
            - running: actively running
            - save-vm: paused to save the VM state
            - shutdown: shut down (and -no-shutdown is in use)
            - suspended: suspended (ACPI S3)
            - watchdog: watchdog action has been triggered
            - guest-panicked: panicked as a result of guest OS panic

        :return: VM status.
        :rtype: str
        """
        out = self._qemu_qmp_exec("query-status")
        ret = out.get("return")
        if ret is not None:
            return ret.get("status")
        else:
            err = out.get("error")
            raise RuntimeError(
                "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):
        """Build QEMU from sources.

        :param node: Node to build QEMU on.
        :param force_install: If True, then remove previous build.
        :param apply_patch: If True, then apply patches from qemu_patches dir.
        :type node: dict
        :type force_install: bool
        :type apply_patch: bool
        :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,
        )

        if int(ret_code) != 0:
            logging.debug("QEMU build failed {0}".format(stdout + stderr))
            raise RuntimeError("QEMU build failed on {0}".format(node["host"]))