[mirror_qemu.git] / tests / vm / basevm.py

#!/usr/bin/env python
#
# VM testing base class
#
# Copyright 2017-2019 Red Hat Inc.
#
# Authors:
#  Fam Zheng <famz@redhat.com>
#  Gerd Hoffmann <kraxel@redhat.com>
#
# This code is licensed under the GPL version 2 or later.  See
# the COPYING file in the top-level directory.
#

from __future__ import print_function
import os
import re
import sys
import socket
import logging
import time
import datetime
sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
from qemu import kvm_available
from qemu.machine import QEMUMachine
import subprocess
import hashlib
import optparse
import atexit
import tempfile
import shutil
import multiprocessing
import traceback

SSH_KEY = open(os.path.join(os.path.dirname(__file__),
               "..", "keys", "id_rsa")).read()
SSH_PUB_KEY = open(os.path.join(os.path.dirname(__file__),
                   "..", "keys", "id_rsa.pub")).read()

class BaseVM(object):
    GUEST_USER = "qemu"
    GUEST_PASS = "qemupass"
    ROOT_PASS = "qemupass"

    envvars = [
        "https_proxy",
        "http_proxy",
        "ftp_proxy",
        "no_proxy",
    ]

    # The script to run in the guest that builds QEMU
    BUILD_SCRIPT = ""
    # The guest name, to be overridden by subclasses
    name = "#base"
    # The guest architecture, to be overridden by subclasses
    arch = "#arch"
    # command to halt the guest, can be overridden by subclasses
    poweroff = "poweroff"
    # enable IPv6 networking
    ipv6 = True
    def __init__(self, debug=False, vcpus=None):
        self._guest = None
        self._tmpdir = os.path.realpath(tempfile.mkdtemp(prefix="vm-test-",
                                                         suffix=".tmp",
                                                         dir="."))
        atexit.register(shutil.rmtree, self._tmpdir)

        self._ssh_key_file = os.path.join(self._tmpdir, "id_rsa")
        open(self._ssh_key_file, "w").write(SSH_KEY)
        subprocess.check_call(["chmod", "600", self._ssh_key_file])

        self._ssh_pub_key_file = os.path.join(self._tmpdir, "id_rsa.pub")
        open(self._ssh_pub_key_file, "w").write(SSH_PUB_KEY)

        self.debug = debug
        self._stderr = sys.stderr
        self._devnull = open(os.devnull, "w")
        if self.debug:
            self._stdout = sys.stdout
        else:
            self._stdout = self._devnull
        self._args = [ \
            "-nodefaults", "-m", "4G",
            "-cpu", "max",
            "-netdev", "user,id=vnet,hostfwd=:127.0.0.1:0-:22" +
                       (",ipv6=no" if not self.ipv6 else ""),
            "-device", "virtio-net-pci,netdev=vnet",
            "-vnc", "127.0.0.1:0,to=20"]
        if vcpus and vcpus > 1:
            self._args += ["-smp", "%d" % vcpus]
        if kvm_available(self.arch):
            self._args += ["-enable-kvm"]
        else:
            logging.info("KVM not available, not using -enable-kvm")
        self._data_args = []

    def _download_with_cache(self, url, sha256sum=None):
        def check_sha256sum(fname):
            if not sha256sum:
                return True
            checksum = subprocess.check_output(["sha256sum", fname]).split()[0]
            return sha256sum == checksum.decode("utf-8")

        cache_dir = os.path.expanduser("~/.cache/qemu-vm/download")
        if not os.path.exists(cache_dir):
            os.makedirs(cache_dir)
        fname = os.path.join(cache_dir,
                             hashlib.sha1(url.encode("utf-8")).hexdigest())
        if os.path.exists(fname) and check_sha256sum(fname):
            return fname
        logging.debug("Downloading %s to %s...", url, fname)
        subprocess.check_call(["wget", "-c", url, "-O", fname + ".download"],
                              stdout=self._stdout, stderr=self._stderr)
        os.rename(fname + ".download", fname)
        return fname

    def _ssh_do(self, user, cmd, check):
        ssh_cmd = ["ssh", "-q", "-t",
                   "-o", "StrictHostKeyChecking=no",
                   "-o", "UserKnownHostsFile=" + os.devnull,
                   "-o", "ConnectTimeout=1",
                   "-p", self.ssh_port, "-i", self._ssh_key_file]
        for var in self.envvars:
            ssh_cmd += ['-o', "SendEnv=%s" % var ]
        assert not isinstance(cmd, str)
        ssh_cmd += ["%s@127.0.0.1" % user] + list(cmd)
        logging.debug("ssh_cmd: %s", " ".join(ssh_cmd))
        r = subprocess.call(ssh_cmd)
        if check and r != 0:
            raise Exception("SSH command failed: %s" % cmd)
        return r

    def ssh(self, *cmd):
        return self._ssh_do(self.GUEST_USER, cmd, False)

    def ssh_root(self, *cmd):
        return self._ssh_do("root", cmd, False)

    def ssh_check(self, *cmd):
        self._ssh_do(self.GUEST_USER, cmd, True)

    def ssh_root_check(self, *cmd):
        self._ssh_do("root", cmd, True)

    def build_image(self, img):
        raise NotImplementedError

    def add_source_dir(self, src_dir):
        name = "data-" + hashlib.sha1(src_dir.encode("utf-8")).hexdigest()[:5]
        tarfile = os.path.join(self._tmpdir, name + ".tar")
        logging.debug("Creating archive %s for src_dir dir: %s", tarfile, src_dir)
        subprocess.check_call(["./scripts/archive-source.sh", tarfile],
                              cwd=src_dir, stdin=self._devnull,
                              stdout=self._stdout, stderr=self._stderr)
        self._data_args += ["-drive",
                            "file=%s,if=none,id=%s,cache=writeback,format=raw" % \
                                    (tarfile, name),
                            "-device",
                            "virtio-blk,drive=%s,serial=%s,bootindex=1" % (name, name)]

    def boot(self, img, extra_args=[]):
        args = self._args + [
            "-device", "VGA",
            "-drive", "file=%s,if=none,id=drive0,cache=writeback" % img,
            "-device", "virtio-blk,drive=drive0,bootindex=0"]
        args += self._data_args + extra_args
        logging.debug("QEMU args: %s", " ".join(args))
        qemu_bin = os.environ.get("QEMU", "qemu-system-" + self.arch)
        guest = QEMUMachine(binary=qemu_bin, args=args)
        guest.set_machine('pc')
        guest.set_console()
        try:
            guest.launch()
        except:
            logging.error("Failed to launch QEMU, command line:")
            logging.error(" ".join([qemu_bin] + args))
            logging.error("Log:")
            logging.error(guest.get_log())
            logging.error("QEMU version >= 2.10 is required")
            raise
        atexit.register(self.shutdown)
        self._guest = guest
        usernet_info = guest.qmp("human-monitor-command",
                                 command_line="info usernet")
        self.ssh_port = None
        for l in usernet_info["return"].splitlines():
            fields = l.split()
            if "TCP[HOST_FORWARD]" in fields and "22" in fields:
                self.ssh_port = l.split()[3]
        if not self.ssh_port:
            raise Exception("Cannot find ssh port from 'info usernet':\n%s" % \
                            usernet_info)

    def console_init(self, timeout = 120):
        vm = self._guest
        vm.console_socket.settimeout(timeout)

    def console_log(self, text):
        for line in re.split("[\r\n]", text):
            # filter out terminal escape sequences
            line = re.sub("\x1b\[[0-9;?]*[a-zA-Z]", "", line)
            line = re.sub("\x1b\([0-9;?]*[a-zA-Z]", "", line)
            # replace unprintable chars
            line = re.sub("\x1b", "<esc>", line)
            line = re.sub("[\x00-\x1f]", ".", line)
            line = re.sub("[\x80-\xff]", ".", line)
            if line == "":
                continue
            # log console line
            sys.stderr.write("con recv: %s\n" % line)

    def console_wait(self, expect, expectalt = None):
        vm = self._guest
        output = ""
        while True:
            try:
                chars = vm.console_socket.recv(1)
            except socket.timeout:
                sys.stderr.write("console: *** read timeout ***\n")
                sys.stderr.write("console: waiting for: '%s'\n" % expect)
                if not expectalt is None:
                    sys.stderr.write("console: waiting for: '%s' (alt)\n" % expectalt)
                sys.stderr.write("console: line buffer:\n")
                sys.stderr.write("\n")
                self.console_log(output.rstrip())
                sys.stderr.write("\n")
                raise
            output += chars.decode("latin1")
            if expect in output:
                break
            if not expectalt is None and expectalt in output:
                break
            if "\r" in output or "\n" in output:
                lines = re.split("[\r\n]", output)
                output = lines.pop()
                if self.debug:
                    self.console_log("\n".join(lines))
        if self.debug:
            self.console_log(output)
        if not expectalt is None and expectalt in output:
            return False
        return True

    def console_consume(self):
        vm = self._guest
        output = ""
        vm.console_socket.setblocking(0)
        while True:
            try:
                chars = vm.console_socket.recv(1)
            except:
                break
            output += chars.decode("latin1")
            if "\r" in output or "\n" in output:
                lines = re.split("[\r\n]", output)
                output = lines.pop()
                if self.debug:
                    self.console_log("\n".join(lines))
        if self.debug:
            self.console_log(output)
        vm.console_socket.setblocking(1)

    def console_send(self, command):
        vm = self._guest
        if self.debug:
            logline = re.sub("\n", "<enter>", command)
            logline = re.sub("[\x00-\x1f]", ".", logline)
            sys.stderr.write("con send: %s\n" % logline)
        for char in list(command):
            vm.console_socket.send(char.encode("utf-8"))
            time.sleep(0.01)

    def console_wait_send(self, wait, command):
        self.console_wait(wait)
        self.console_send(command)

    def console_ssh_init(self, prompt, user, pw):
        sshkey_cmd = "echo '%s' > .ssh/authorized_keys\n" % SSH_PUB_KEY.rstrip()
        self.console_wait_send("login:",    "%s\n" % user)
        self.console_wait_send("Password:", "%s\n" % pw)
        self.console_wait_send(prompt,      "mkdir .ssh\n")
        self.console_wait_send(prompt,      sshkey_cmd)
        self.console_wait_send(prompt,      "chmod 755 .ssh\n")
        self.console_wait_send(prompt,      "chmod 644 .ssh/authorized_keys\n")

    def console_sshd_config(self, prompt):
        self.console_wait(prompt)
        self.console_send("echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config\n")
        for var in self.envvars:
            self.console_wait(prompt)
            self.console_send("echo 'AcceptEnv %s' >> /etc/ssh/sshd_config\n" % var)

    def print_step(self, text):
        sys.stderr.write("### %s ...\n" % text)

    def wait_ssh(self, seconds=300):
        starttime = datetime.datetime.now()
        endtime = starttime + datetime.timedelta(seconds=seconds)
        guest_up = False
        while datetime.datetime.now() < endtime:
            if self.ssh("exit 0") == 0:
                guest_up = True
                break
            seconds = (endtime - datetime.datetime.now()).total_seconds()
            logging.debug("%ds before timeout", seconds)
            time.sleep(1)
        if not guest_up:
            raise Exception("Timeout while waiting for guest ssh")

    def shutdown(self):
        self._guest.shutdown()

    def wait(self):
        self._guest.wait()

    def graceful_shutdown(self):
        self.ssh_root(self.poweroff)
        self._guest.wait()

    def qmp(self, *args, **kwargs):
        return self._guest.qmp(*args, **kwargs)

def parse_args(vmcls):

    def get_default_jobs():
        if kvm_available(vmcls.arch):
            return multiprocessing.cpu_count() // 2
        else:
            return 1

    parser = optparse.OptionParser(
        description="VM test utility.  Exit codes: "
                    "0 = success, "
                    "1 = command line error, "
                    "2 = environment initialization failed, "
                    "3 = test command failed")
    parser.add_option("--debug", "-D", action="store_true",
                      help="enable debug output")
    parser.add_option("--image", "-i", default="%s.img" % vmcls.name,
                      help="image file name")
    parser.add_option("--force", "-f", action="store_true",
                      help="force build image even if image exists")
    parser.add_option("--jobs", type=int, default=get_default_jobs(),
                      help="number of virtual CPUs")
    parser.add_option("--verbose", "-V", action="store_true",
                      help="Pass V=1 to builds within the guest")
    parser.add_option("--build-image", "-b", action="store_true",
                      help="build image")
    parser.add_option("--build-qemu",
                      help="build QEMU from source in guest")
    parser.add_option("--build-target",
                      help="QEMU build target", default="check")
    parser.add_option("--interactive", "-I", action="store_true",
                      help="Interactively run command")
    parser.add_option("--snapshot", "-s", action="store_true",
                      help="run tests with a snapshot")
    parser.disable_interspersed_args()
    return parser.parse_args()

def main(vmcls):
    try:
        args, argv = parse_args(vmcls)
        if not argv and not args.build_qemu and not args.build_image:
            print("Nothing to do?")
            return 1
        logging.basicConfig(level=(logging.DEBUG if args.debug
                                   else logging.WARN))
        vm = vmcls(debug=args.debug, vcpus=args.jobs)
        if args.build_image:
            if os.path.exists(args.image) and not args.force:
                sys.stderr.writelines(["Image file exists: %s\n" % args.image,
                                      "Use --force option to overwrite\n"])
                return 1
            return vm.build_image(args.image)
        if args.build_qemu:
            vm.add_source_dir(args.build_qemu)
            cmd = [vm.BUILD_SCRIPT.format(
                   configure_opts = " ".join(argv),
                   jobs=int(args.jobs),
                   target=args.build_target,
                   verbose = "V=1" if args.verbose else "")]
        else:
            cmd = argv
        img = args.image
        if args.snapshot:
            img += ",snapshot=on"
        vm.boot(img)
        vm.wait_ssh()
    except Exception as e:
        if isinstance(e, SystemExit) and e.code == 0:
            return 0
        sys.stderr.write("Failed to prepare guest environment\n")
        traceback.print_exc()
        return 2

    exitcode = 0
    if vm.ssh(*cmd) != 0:
        exitcode = 3
    if exitcode != 0 and args.interactive:
        vm.ssh()

    if not args.snapshot:
        vm.graceful_shutdown()

    return exitcode
Commit	Line	Data
ff2ebff0 FZ	1	#!/usr/bin/env python
	2	#
	3	# VM testing base class
	4	#
8dd38334	5	# Copyright 2017-2019 Red Hat Inc.
ff2ebff0 FZ	6	#
	7	# Authors:
	8	# Fam Zheng <famz@redhat.com>
8dd38334	9	# Gerd Hoffmann <kraxel@redhat.com>
ff2ebff0 FZ	10	#
	11	# This code is licensed under the GPL version 2 or later. See
	12	# the COPYING file in the top-level directory.
	13	#
	14
f03868bd	15	from __future__ import print_function
ff2ebff0	16	import os
8dd38334	17	import re
ff2ebff0	18	import sys
8dd38334	19	import socket
ff2ebff0 FZ	20	import logging
	21	import time
	22	import datetime
8f8fd9ed	23	sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
abf0bf99 JS	24	from qemu import kvm_available
abf0bf99 JS	25	from qemu.machine import QEMUMachine
ff2ebff0 FZ	26	import subprocess
	27	import hashlib
	28	import optparse
	29	import atexit
	30	import tempfile
	31	import shutil
	32	import multiprocessing
	33	import traceback
	34
	35	SSH_KEY = open(os.path.join(os.path.dirname(__file__),
	36	"..", "keys", "id_rsa")).read()
	37	SSH_PUB_KEY = open(os.path.join(os.path.dirname(__file__),
	38	"..", "keys", "id_rsa.pub")).read()
	39
	40	class BaseVM(object):
	41	GUEST_USER = "qemu"
	42	GUEST_PASS = "qemupass"
	43	ROOT_PASS = "qemupass"
	44
b08ba163 GH	45	envvars = [
	46	"https_proxy",
	47	"http_proxy",
	48	"ftp_proxy",
	49	"no_proxy",
	50	]
	51
ff2ebff0 FZ	52	# The script to run in the guest that builds QEMU
	53	BUILD_SCRIPT = ""
	54	# The guest name, to be overridden by subclasses
	55	name = "#base"
31719c37 PMD	56	# The guest architecture, to be overridden by subclasses
31719c37 PMD	57	arch = "#arch"
b3f94b2f GH	58	# command to halt the guest, can be overridden by subclasses
b3f94b2f GH	59	poweroff = "poweroff"
5b790481 EH	60	# enable IPv6 networking
5b790481 EH	61	ipv6 = True
ff2ebff0 FZ	62	def __init__(self, debug=False, vcpus=None):
	63	self._guest = None
	64	self._tmpdir = os.path.realpath(tempfile.mkdtemp(prefix="vm-test-",
	65	suffix=".tmp",
	66	dir="."))
	67	atexit.register(shutil.rmtree, self._tmpdir)
	68
	69	self._ssh_key_file = os.path.join(self._tmpdir, "id_rsa")
	70	open(self._ssh_key_file, "w").write(SSH_KEY)
	71	subprocess.check_call(["chmod", "600", self._ssh_key_file])
	72
	73	self._ssh_pub_key_file = os.path.join(self._tmpdir, "id_rsa.pub")
	74	open(self._ssh_pub_key_file, "w").write(SSH_PUB_KEY)
	75
	76	self.debug = debug
	77	self._stderr = sys.stderr
	78	self._devnull = open(os.devnull, "w")
	79	if self.debug:
	80	self._stdout = sys.stdout
	81	else:
	82	self._stdout = self._devnull
	83	self._args = [ \
eb2712f5	84	"-nodefaults", "-m", "4G",
b33bd859	85	"-cpu", "max",
5b790481 EH	86	"-netdev", "user,id=vnet,hostfwd=:127.0.0.1:0-:22" +
5b790481 EH	87	(",ipv6=no" if not self.ipv6 else ""),
ff2ebff0	88	"-device", "virtio-net-pci,netdev=vnet",
8dd38334	89	"-vnc", "127.0.0.1:0,to=20"]
071cf5a4	90	if vcpus and vcpus > 1:
3ace9be6	91	self._args += ["-smp", "%d" % vcpus]
71531bb5	92	if kvm_available(self.arch):
ff2ebff0 FZ	93	self._args += ["-enable-kvm"]
	94	else:
	95	logging.info("KVM not available, not using -enable-kvm")
	96	self._data_args = []
	97
	98	def _download_with_cache(self, url, sha256sum=None):
	99	def check_sha256sum(fname):
	100	if not sha256sum:
	101	return True
	102	checksum = subprocess.check_output(["sha256sum", fname]).split()[0]
3ace9be6	103	return sha256sum == checksum.decode("utf-8")
ff2ebff0 FZ	104
	105	cache_dir = os.path.expanduser("~/.cache/qemu-vm/download")
	106	if not os.path.exists(cache_dir):
	107	os.makedirs(cache_dir)
3ace9be6 GH	108	fname = os.path.join(cache_dir,
3ace9be6 GH	109	hashlib.sha1(url.encode("utf-8")).hexdigest())
ff2ebff0 FZ	110	if os.path.exists(fname) and check_sha256sum(fname):
	111	return fname
	112	logging.debug("Downloading %s to %s...", url, fname)
	113	subprocess.check_call(["wget", "-c", url, "-O", fname + ".download"],
	114	stdout=self._stdout, stderr=self._stderr)
	115	os.rename(fname + ".download", fname)
	116	return fname
	117
796471e9 GH	118	def _ssh_do(self, user, cmd, check):
796471e9 GH	119	ssh_cmd = ["ssh", "-q", "-t",
ff2ebff0 FZ	120	"-o", "StrictHostKeyChecking=no",
	121	"-o", "UserKnownHostsFile=" + os.devnull,
	122	"-o", "ConnectTimeout=1",
	123	"-p", self.ssh_port, "-i", self._ssh_key_file]
b08ba163 GH	124	for var in self.envvars:
b08ba163 GH	125	ssh_cmd += ['-o', "SendEnv=%s" % var ]
ff2ebff0 FZ	126	assert not isinstance(cmd, str)
	127	ssh_cmd += ["%s@127.0.0.1" % user] + list(cmd)
	128	logging.debug("ssh_cmd: %s", " ".join(ssh_cmd))
726c9a3b	129	r = subprocess.call(ssh_cmd)
ff2ebff0 FZ	130	if check and r != 0:
	131	raise Exception("SSH command failed: %s" % cmd)
	132	return r
	133
	134	def ssh(self, *cmd):
	135	return self._ssh_do(self.GUEST_USER, cmd, False)
	136
ff2ebff0 FZ	137	def ssh_root(self, *cmd):
	138	return self._ssh_do("root", cmd, False)
	139
	140	def ssh_check(self, *cmd):
	141	self._ssh_do(self.GUEST_USER, cmd, True)
	142
	143	def ssh_root_check(self, *cmd):
	144	self._ssh_do("root", cmd, True)
	145
	146	def build_image(self, img):
	147	raise NotImplementedError
	148
	149	def add_source_dir(self, src_dir):
3ace9be6	150	name = "data-" + hashlib.sha1(src_dir.encode("utf-8")).hexdigest()[:5]
ff2ebff0 FZ	151	tarfile = os.path.join(self._tmpdir, name + ".tar")
	152	logging.debug("Creating archive %s for src_dir dir: %s", tarfile, src_dir)
	153	subprocess.check_call(["./scripts/archive-source.sh", tarfile],
	154	cwd=src_dir, stdin=self._devnull,
	155	stdout=self._stdout, stderr=self._stderr)
	156	self._data_args += ["-drive",
	157	"file=%s,if=none,id=%s,cache=writeback,format=raw" % \
	158	(tarfile, name),
	159	"-device",
	160	"virtio-blk,drive=%s,serial=%s,bootindex=1" % (name, name)]
	161
	162	def boot(self, img, extra_args=[]):
	163	args = self._args + [
	164	"-device", "VGA",
	165	"-drive", "file=%s,if=none,id=drive0,cache=writeback" % img,
	166	"-device", "virtio-blk,drive=drive0,bootindex=0"]
	167	args += self._data_args + extra_args
	168	logging.debug("QEMU args: %s", " ".join(args))
31719c37	169	qemu_bin = os.environ.get("QEMU", "qemu-system-" + self.arch)
ff2ebff0	170	guest = QEMUMachine(binary=qemu_bin, args=args)
8dd38334 GH	171	guest.set_machine('pc')
8dd38334 GH	172	guest.set_console()
ff2ebff0 FZ	173	try:
	174	guest.launch()
	175	except:
	176	logging.error("Failed to launch QEMU, command line:")
	177	logging.error(" ".join([qemu_bin] + args))
	178	logging.error("Log:")
	179	logging.error(guest.get_log())
	180	logging.error("QEMU version >= 2.10 is required")
	181	raise
	182	atexit.register(self.shutdown)
	183	self._guest = guest
	184	usernet_info = guest.qmp("human-monitor-command",
	185	command_line="info usernet")
	186	self.ssh_port = None
	187	for l in usernet_info["return"].splitlines():
	188	fields = l.split()
	189	if "TCP[HOST_FORWARD]" in fields and "22" in fields:
	190	self.ssh_port = l.split()[3]
	191	if not self.ssh_port:
	192	raise Exception("Cannot find ssh port from 'info usernet':\n%s" % \
	193	usernet_info)
	194
8dd38334 GH	195	def console_init(self, timeout = 120):
	196	vm = self._guest
	197	vm.console_socket.settimeout(timeout)
	198
	199	def console_log(self, text):
	200	for line in re.split("[\r\n]", text):
	201	# filter out terminal escape sequences
	202	line = re.sub("\x1b\[[0-9;?]*[a-zA-Z]", "", line)
	203	line = re.sub("\x1b\([0-9;?]*[a-zA-Z]", "", line)
	204	# replace unprintable chars
	205	line = re.sub("\x1b", "<esc>", line)
	206	line = re.sub("[\x00-\x1f]", ".", line)
	207	line = re.sub("[\x80-\xff]", ".", line)
	208	if line == "":
	209	continue
	210	# log console line
	211	sys.stderr.write("con recv: %s\n" % line)
	212
60136e06	213	def console_wait(self, expect, expectalt = None):
8dd38334 GH	214	vm = self._guest
	215	output = ""
	216	while True:
	217	try:
	218	chars = vm.console_socket.recv(1)
	219	except socket.timeout:
	220	sys.stderr.write("console: * read timeout *\n")
	221	sys.stderr.write("console: waiting for: '%s'\n" % expect)
60136e06 GH	222	if not expectalt is None:
60136e06 GH	223	sys.stderr.write("console: waiting for: '%s' (alt)\n" % expectalt)
8dd38334 GH	224	sys.stderr.write("console: line buffer:\n")
	225	sys.stderr.write("\n")
	226	self.console_log(output.rstrip())
	227	sys.stderr.write("\n")
	228	raise
	229	output += chars.decode("latin1")
	230	if expect in output:
	231	break
60136e06 GH	232	if not expectalt is None and expectalt in output:
60136e06 GH	233	break
8dd38334 GH	234	if "\r" in output or "\n" in output:
	235	lines = re.split("[\r\n]", output)
	236	output = lines.pop()
	237	if self.debug:
	238	self.console_log("\n".join(lines))
	239	if self.debug:
	240	self.console_log(output)
60136e06 GH	241	if not expectalt is None and expectalt in output:
	242	return False
	243	return True
8dd38334	244
6c4f0416 GH	245	def console_consume(self):
	246	vm = self._guest
	247	output = ""
	248	vm.console_socket.setblocking(0)
	249	while True:
	250	try:
	251	chars = vm.console_socket.recv(1)
	252	except:
	253	break
	254	output += chars.decode("latin1")
	255	if "\r" in output or "\n" in output:
	256	lines = re.split("[\r\n]", output)
	257	output = lines.pop()
	258	if self.debug:
	259	self.console_log("\n".join(lines))
	260	if self.debug:
	261	self.console_log(output)
	262	vm.console_socket.setblocking(1)
	263
8dd38334 GH	264	def console_send(self, command):
	265	vm = self._guest
	266	if self.debug:
	267	logline = re.sub("\n", "<enter>", command)
	268	logline = re.sub("[\x00-\x1f]", ".", logline)
	269	sys.stderr.write("con send: %s\n" % logline)
	270	for char in list(command):
	271	vm.console_socket.send(char.encode("utf-8"))
	272	time.sleep(0.01)
	273
	274	def console_wait_send(self, wait, command):
	275	self.console_wait(wait)
	276	self.console_send(command)
	277
	278	def console_ssh_init(self, prompt, user, pw):
	279	sshkey_cmd = "echo '%s' > .ssh/authorized_keys\n" % SSH_PUB_KEY.rstrip()
	280	self.console_wait_send("login:", "%s\n" % user)
	281	self.console_wait_send("Password:", "%s\n" % pw)
	282	self.console_wait_send(prompt, "mkdir .ssh\n")
	283	self.console_wait_send(prompt, sshkey_cmd)
	284	self.console_wait_send(prompt, "chmod 755 .ssh\n")
	285	self.console_wait_send(prompt, "chmod 644 .ssh/authorized_keys\n")
	286
	287	def console_sshd_config(self, prompt):
	288	self.console_wait(prompt)
	289	self.console_send("echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config\n")
	290	for var in self.envvars:
	291	self.console_wait(prompt)
	292	self.console_send("echo 'AcceptEnv %s' >> /etc/ssh/sshd_config\n" % var)
	293
	294	def print_step(self, text):
	295	sys.stderr.write("### %s ...\n" % text)
	296
6b699ae1	297	def wait_ssh(self, seconds=300):
ff2ebff0	298	starttime = datetime.datetime.now()
f5d3d218	299	endtime = starttime + datetime.timedelta(seconds=seconds)
ff2ebff0	300	guest_up = False
f5d3d218	301	while datetime.datetime.now() < endtime:
ff2ebff0 FZ	302	if self.ssh("exit 0") == 0:
	303	guest_up = True
	304	break
f5d3d218 PMD	305	seconds = (endtime - datetime.datetime.now()).total_seconds()
f5d3d218 PMD	306	logging.debug("%ds before timeout", seconds)
ff2ebff0 FZ	307	time.sleep(1)
	308	if not guest_up:
	309	raise Exception("Timeout while waiting for guest ssh")
	310
	311	def shutdown(self):
	312	self._guest.shutdown()
	313
	314	def wait(self):
	315	self._guest.wait()
	316
b3f94b2f GH	317	def graceful_shutdown(self):
	318	self.ssh_root(self.poweroff)
	319	self._guest.wait()
	320
ff2ebff0 FZ	321	def qmp(self, args, *kwargs):
	322	return self._guest.qmp(args, *kwargs)
	323
63a24c5e	324	def parse_args(vmcls):
8a6e007e PMD	325
8a6e007e PMD	326	def get_default_jobs():
63a24c5e	327	if kvm_available(vmcls.arch):
3ad3e36e	328	return multiprocessing.cpu_count() // 2
8a6e007e PMD	329	else:
	330	return 1
	331
ff2ebff0 FZ	332	parser = optparse.OptionParser(
	333	description="VM test utility. Exit codes: "
	334	"0 = success, "
	335	"1 = command line error, "
	336	"2 = environment initialization failed, "
	337	"3 = test command failed")
	338	parser.add_option("--debug", "-D", action="store_true",
	339	help="enable debug output")
63a24c5e	340	parser.add_option("--image", "-i", default="%s.img" % vmcls.name,
ff2ebff0 FZ	341	help="image file name")
	342	parser.add_option("--force", "-f", action="store_true",
	343	help="force build image even if image exists")
8a6e007e	344	parser.add_option("--jobs", type=int, default=get_default_jobs(),
ff2ebff0	345	help="number of virtual CPUs")
41e3340a PM	346	parser.add_option("--verbose", "-V", action="store_true",
41e3340a PM	347	help="Pass V=1 to builds within the guest")
ff2ebff0 FZ	348	parser.add_option("--build-image", "-b", action="store_true",
	349	help="build image")
	350	parser.add_option("--build-qemu",
	351	help="build QEMU from source in guest")
5c2ec9b6 AB	352	parser.add_option("--build-target",
5c2ec9b6 AB	353	help="QEMU build target", default="check")
ff2ebff0 FZ	354	parser.add_option("--interactive", "-I", action="store_true",
ff2ebff0 FZ	355	help="Interactively run command")
983c2a77 FZ	356	parser.add_option("--snapshot", "-s", action="store_true",
983c2a77 FZ	357	help="run tests with a snapshot")
ff2ebff0 FZ	358	parser.disable_interspersed_args()
	359	return parser.parse_args()
	360
	361	def main(vmcls):
	362	try:
63a24c5e	363	args, argv = parse_args(vmcls)
ff2ebff0	364	if not argv and not args.build_qemu and not args.build_image:
f03868bd	365	print("Nothing to do?")
ff2ebff0	366	return 1
fb3b4e6d EH	367	logging.basicConfig(level=(logging.DEBUG if args.debug
fb3b4e6d EH	368	else logging.WARN))
ff2ebff0 FZ	369	vm = vmcls(debug=args.debug, vcpus=args.jobs)
	370	if args.build_image:
	371	if os.path.exists(args.image) and not args.force:
	372	sys.stderr.writelines(["Image file exists: %s\n" % args.image,
	373	"Use --force option to overwrite\n"])
	374	return 1
	375	return vm.build_image(args.image)
	376	if args.build_qemu:
	377	vm.add_source_dir(args.build_qemu)
	378	cmd = [vm.BUILD_SCRIPT.format(
	379	configure_opts = " ".join(argv),
3ace9be6	380	jobs=int(args.jobs),
5c2ec9b6	381	target=args.build_target,
41e3340a	382	verbose = "V=1" if args.verbose else "")]
ff2ebff0 FZ	383	else:
ff2ebff0 FZ	384	cmd = argv
983c2a77 FZ	385	img = args.image
	386	if args.snapshot:
	387	img += ",snapshot=on"
	388	vm.boot(img)
ff2ebff0 FZ	389	vm.wait_ssh()
	390	except Exception as e:
	391	if isinstance(e, SystemExit) and e.code == 0:
	392	return 0
	393	sys.stderr.write("Failed to prepare guest environment\n")
	394	traceback.print_exc()
	395	return 2
	396
b3f94b2f GH	397	exitcode = 0
	398	if vm.ssh(*cmd) != 0:
	399	exitcode = 3
	400	if exitcode != 0 and args.interactive:
796471e9	401	vm.ssh()
b3f94b2f GH	402
	403	if not args.snapshot:
	404	vm.graceful_shutdown()
	405
	406	return exitcode