[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, sha512sum=None):
        def check_sha256sum(fname):
            if not sha256sum:
                return True
            checksum = subprocess.check_output(["sha256sum", fname]).split()[0]
            return sha256sum == checksum.decode("utf-8")

        def check_sha512sum(fname):
            if not sha512sum:
                return True
            checksum = subprocess.check_output(["sha512sum", fname]).split()[0]
            return sha512sum == 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) and check_sha512sum(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
5b4b4865	98	def _download_with_cache(self, url, sha256sum=None, sha512sum=None):
ff2ebff0 FZ	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	104
5b4b4865 AB	105	def check_sha512sum(fname):
	106	if not sha512sum:
	107	return True
	108	checksum = subprocess.check_output(["sha512sum", fname]).split()[0]
	109	return sha512sum == checksum.decode("utf-8")
	110
ff2ebff0 FZ	111	cache_dir = os.path.expanduser("~/.cache/qemu-vm/download")
	112	if not os.path.exists(cache_dir):
	113	os.makedirs(cache_dir)
3ace9be6 GH	114	fname = os.path.join(cache_dir,
3ace9be6 GH	115	hashlib.sha1(url.encode("utf-8")).hexdigest())
5b4b4865	116	if os.path.exists(fname) and check_sha256sum(fname) and check_sha512sum(fname):
ff2ebff0 FZ	117	return fname
	118	logging.debug("Downloading %s to %s...", url, fname)
	119	subprocess.check_call(["wget", "-c", url, "-O", fname + ".download"],
	120	stdout=self._stdout, stderr=self._stderr)
	121	os.rename(fname + ".download", fname)
	122	return fname
	123
796471e9 GH	124	def _ssh_do(self, user, cmd, check):
796471e9 GH	125	ssh_cmd = ["ssh", "-q", "-t",
ff2ebff0 FZ	126	"-o", "StrictHostKeyChecking=no",
	127	"-o", "UserKnownHostsFile=" + os.devnull,
	128	"-o", "ConnectTimeout=1",
	129	"-p", self.ssh_port, "-i", self._ssh_key_file]
b08ba163 GH	130	for var in self.envvars:
b08ba163 GH	131	ssh_cmd += ['-o', "SendEnv=%s" % var ]
ff2ebff0 FZ	132	assert not isinstance(cmd, str)
	133	ssh_cmd += ["%s@127.0.0.1" % user] + list(cmd)
	134	logging.debug("ssh_cmd: %s", " ".join(ssh_cmd))
726c9a3b	135	r = subprocess.call(ssh_cmd)
ff2ebff0 FZ	136	if check and r != 0:
	137	raise Exception("SSH command failed: %s" % cmd)
	138	return r
	139
	140	def ssh(self, *cmd):
	141	return self._ssh_do(self.GUEST_USER, cmd, False)
	142
ff2ebff0 FZ	143	def ssh_root(self, *cmd):
	144	return self._ssh_do("root", cmd, False)
	145
	146	def ssh_check(self, *cmd):
	147	self._ssh_do(self.GUEST_USER, cmd, True)
	148
	149	def ssh_root_check(self, *cmd):
	150	self._ssh_do("root", cmd, True)
	151
	152	def build_image(self, img):
	153	raise NotImplementedError
	154
	155	def add_source_dir(self, src_dir):
3ace9be6	156	name = "data-" + hashlib.sha1(src_dir.encode("utf-8")).hexdigest()[:5]
ff2ebff0 FZ	157	tarfile = os.path.join(self._tmpdir, name + ".tar")
	158	logging.debug("Creating archive %s for src_dir dir: %s", tarfile, src_dir)
	159	subprocess.check_call(["./scripts/archive-source.sh", tarfile],
	160	cwd=src_dir, stdin=self._devnull,
	161	stdout=self._stdout, stderr=self._stderr)
	162	self._data_args += ["-drive",
	163	"file=%s,if=none,id=%s,cache=writeback,format=raw" % \
	164	(tarfile, name),
	165	"-device",
	166	"virtio-blk,drive=%s,serial=%s,bootindex=1" % (name, name)]
	167
	168	def boot(self, img, extra_args=[]):
	169	args = self._args + [
	170	"-device", "VGA",
	171	"-drive", "file=%s,if=none,id=drive0,cache=writeback" % img,
	172	"-device", "virtio-blk,drive=drive0,bootindex=0"]
	173	args += self._data_args + extra_args
	174	logging.debug("QEMU args: %s", " ".join(args))
31719c37	175	qemu_bin = os.environ.get("QEMU", "qemu-system-" + self.arch)
ff2ebff0	176	guest = QEMUMachine(binary=qemu_bin, args=args)
8dd38334 GH	177	guest.set_machine('pc')
8dd38334 GH	178	guest.set_console()
ff2ebff0 FZ	179	try:
	180	guest.launch()
	181	except:
	182	logging.error("Failed to launch QEMU, command line:")
	183	logging.error(" ".join([qemu_bin] + args))
	184	logging.error("Log:")
	185	logging.error(guest.get_log())
	186	logging.error("QEMU version >= 2.10 is required")
	187	raise
	188	atexit.register(self.shutdown)
	189	self._guest = guest
	190	usernet_info = guest.qmp("human-monitor-command",
	191	command_line="info usernet")
	192	self.ssh_port = None
	193	for l in usernet_info["return"].splitlines():
	194	fields = l.split()
	195	if "TCP[HOST_FORWARD]" in fields and "22" in fields:
	196	self.ssh_port = l.split()[3]
	197	if not self.ssh_port:
	198	raise Exception("Cannot find ssh port from 'info usernet':\n%s" % \
	199	usernet_info)
	200
8dd38334 GH	201	def console_init(self, timeout = 120):
	202	vm = self._guest
	203	vm.console_socket.settimeout(timeout)
	204
	205	def console_log(self, text):
	206	for line in re.split("[\r\n]", text):
	207	# filter out terminal escape sequences
	208	line = re.sub("\x1b\[[0-9;?]*[a-zA-Z]", "", line)
	209	line = re.sub("\x1b\([0-9;?]*[a-zA-Z]", "", line)
	210	# replace unprintable chars
	211	line = re.sub("\x1b", "<esc>", line)
	212	line = re.sub("[\x00-\x1f]", ".", line)
	213	line = re.sub("[\x80-\xff]", ".", line)
	214	if line == "":
	215	continue
	216	# log console line
	217	sys.stderr.write("con recv: %s\n" % line)
	218
60136e06	219	def console_wait(self, expect, expectalt = None):
8dd38334 GH	220	vm = self._guest
	221	output = ""
	222	while True:
	223	try:
	224	chars = vm.console_socket.recv(1)
	225	except socket.timeout:
	226	sys.stderr.write("console: * read timeout *\n")
	227	sys.stderr.write("console: waiting for: '%s'\n" % expect)
60136e06 GH	228	if not expectalt is None:
60136e06 GH	229	sys.stderr.write("console: waiting for: '%s' (alt)\n" % expectalt)
8dd38334 GH	230	sys.stderr.write("console: line buffer:\n")
	231	sys.stderr.write("\n")
	232	self.console_log(output.rstrip())
	233	sys.stderr.write("\n")
	234	raise
	235	output += chars.decode("latin1")
	236	if expect in output:
	237	break
60136e06 GH	238	if not expectalt is None and expectalt in output:
60136e06 GH	239	break
8dd38334 GH	240	if "\r" in output or "\n" in output:
	241	lines = re.split("[\r\n]", output)
	242	output = lines.pop()
	243	if self.debug:
	244	self.console_log("\n".join(lines))
	245	if self.debug:
	246	self.console_log(output)
60136e06 GH	247	if not expectalt is None and expectalt in output:
	248	return False
	249	return True
8dd38334	250
6c4f0416 GH	251	def console_consume(self):
	252	vm = self._guest
	253	output = ""
	254	vm.console_socket.setblocking(0)
	255	while True:
	256	try:
	257	chars = vm.console_socket.recv(1)
	258	except:
	259	break
	260	output += chars.decode("latin1")
	261	if "\r" in output or "\n" in output:
	262	lines = re.split("[\r\n]", output)
	263	output = lines.pop()
	264	if self.debug:
	265	self.console_log("\n".join(lines))
	266	if self.debug:
	267	self.console_log(output)
	268	vm.console_socket.setblocking(1)
	269
8dd38334 GH	270	def console_send(self, command):
	271	vm = self._guest
	272	if self.debug:
	273	logline = re.sub("\n", "<enter>", command)
	274	logline = re.sub("[\x00-\x1f]", ".", logline)
	275	sys.stderr.write("con send: %s\n" % logline)
	276	for char in list(command):
	277	vm.console_socket.send(char.encode("utf-8"))
	278	time.sleep(0.01)
	279
	280	def console_wait_send(self, wait, command):
	281	self.console_wait(wait)
	282	self.console_send(command)
	283
	284	def console_ssh_init(self, prompt, user, pw):
	285	sshkey_cmd = "echo '%s' > .ssh/authorized_keys\n" % SSH_PUB_KEY.rstrip()
	286	self.console_wait_send("login:", "%s\n" % user)
	287	self.console_wait_send("Password:", "%s\n" % pw)
	288	self.console_wait_send(prompt, "mkdir .ssh\n")
	289	self.console_wait_send(prompt, sshkey_cmd)
	290	self.console_wait_send(prompt, "chmod 755 .ssh\n")
	291	self.console_wait_send(prompt, "chmod 644 .ssh/authorized_keys\n")
	292
	293	def console_sshd_config(self, prompt):
	294	self.console_wait(prompt)
	295	self.console_send("echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config\n")
	296	for var in self.envvars:
	297	self.console_wait(prompt)
	298	self.console_send("echo 'AcceptEnv %s' >> /etc/ssh/sshd_config\n" % var)
	299
	300	def print_step(self, text):
	301	sys.stderr.write("### %s ...\n" % text)
	302
6b699ae1	303	def wait_ssh(self, seconds=300):
ff2ebff0	304	starttime = datetime.datetime.now()
f5d3d218	305	endtime = starttime + datetime.timedelta(seconds=seconds)
ff2ebff0	306	guest_up = False
f5d3d218	307	while datetime.datetime.now() < endtime:
ff2ebff0 FZ	308	if self.ssh("exit 0") == 0:
	309	guest_up = True
	310	break
f5d3d218 PMD	311	seconds = (endtime - datetime.datetime.now()).total_seconds()
f5d3d218 PMD	312	logging.debug("%ds before timeout", seconds)
ff2ebff0 FZ	313	time.sleep(1)
	314	if not guest_up:
	315	raise Exception("Timeout while waiting for guest ssh")
	316
	317	def shutdown(self):
	318	self._guest.shutdown()
	319
	320	def wait(self):
	321	self._guest.wait()
	322
b3f94b2f GH	323	def graceful_shutdown(self):
	324	self.ssh_root(self.poweroff)
	325	self._guest.wait()
	326
ff2ebff0 FZ	327	def qmp(self, args, *kwargs):
	328	return self._guest.qmp(args, *kwargs)
	329
63a24c5e	330	def parse_args(vmcls):
8a6e007e PMD	331
8a6e007e PMD	332	def get_default_jobs():
63a24c5e	333	if kvm_available(vmcls.arch):
3ad3e36e	334	return multiprocessing.cpu_count() // 2
8a6e007e PMD	335	else:
	336	return 1
	337
ff2ebff0 FZ	338	parser = optparse.OptionParser(
	339	description="VM test utility. Exit codes: "
	340	"0 = success, "
	341	"1 = command line error, "
	342	"2 = environment initialization failed, "
	343	"3 = test command failed")
	344	parser.add_option("--debug", "-D", action="store_true",
	345	help="enable debug output")
63a24c5e	346	parser.add_option("--image", "-i", default="%s.img" % vmcls.name,
ff2ebff0 FZ	347	help="image file name")
	348	parser.add_option("--force", "-f", action="store_true",
	349	help="force build image even if image exists")
8a6e007e	350	parser.add_option("--jobs", type=int, default=get_default_jobs(),
ff2ebff0	351	help="number of virtual CPUs")
41e3340a PM	352	parser.add_option("--verbose", "-V", action="store_true",
41e3340a PM	353	help="Pass V=1 to builds within the guest")
ff2ebff0 FZ	354	parser.add_option("--build-image", "-b", action="store_true",
	355	help="build image")
	356	parser.add_option("--build-qemu",
	357	help="build QEMU from source in guest")
5c2ec9b6 AB	358	parser.add_option("--build-target",
5c2ec9b6 AB	359	help="QEMU build target", default="check")
ff2ebff0 FZ	360	parser.add_option("--interactive", "-I", action="store_true",
ff2ebff0 FZ	361	help="Interactively run command")
983c2a77 FZ	362	parser.add_option("--snapshot", "-s", action="store_true",
983c2a77 FZ	363	help="run tests with a snapshot")
ff2ebff0 FZ	364	parser.disable_interspersed_args()
	365	return parser.parse_args()
	366
	367	def main(vmcls):
	368	try:
63a24c5e	369	args, argv = parse_args(vmcls)
ff2ebff0	370	if not argv and not args.build_qemu and not args.build_image:
f03868bd	371	print("Nothing to do?")
ff2ebff0	372	return 1
fb3b4e6d EH	373	logging.basicConfig(level=(logging.DEBUG if args.debug
fb3b4e6d EH	374	else logging.WARN))
ff2ebff0 FZ	375	vm = vmcls(debug=args.debug, vcpus=args.jobs)
	376	if args.build_image:
	377	if os.path.exists(args.image) and not args.force:
	378	sys.stderr.writelines(["Image file exists: %s\n" % args.image,
	379	"Use --force option to overwrite\n"])
	380	return 1
	381	return vm.build_image(args.image)
	382	if args.build_qemu:
	383	vm.add_source_dir(args.build_qemu)
	384	cmd = [vm.BUILD_SCRIPT.format(
	385	configure_opts = " ".join(argv),
3ace9be6	386	jobs=int(args.jobs),
5c2ec9b6	387	target=args.build_target,
41e3340a	388	verbose = "V=1" if args.verbose else "")]
ff2ebff0 FZ	389	else:
ff2ebff0 FZ	390	cmd = argv
983c2a77 FZ	391	img = args.image
	392	if args.snapshot:
	393	img += ",snapshot=on"
	394	vm.boot(img)
ff2ebff0 FZ	395	vm.wait_ssh()
	396	except Exception as e:
	397	if isinstance(e, SystemExit) and e.code == 0:
	398	return 0
	399	sys.stderr.write("Failed to prepare guest environment\n")
	400	traceback.print_exc()
	401	return 2
	402
b3f94b2f GH	403	exitcode = 0
	404	if vm.ssh(*cmd) != 0:
	405	exitcode = 3
	406	if exitcode != 0 and args.interactive:
796471e9	407	vm.ssh()
b3f94b2f GH	408
	409	if not args.snapshot:
	410	vm.graceful_shutdown()
	411
	412	return exitcode