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

#!/usr/bin/env python
#
# VM testing base class
#
# Copyright 2017 Red Hat Inc.
#
# Authors:
#  Fam Zheng <[email protected]>
#
# 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 sys
import logging
import time
import datetime
sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
from qemu import QEMUMachine, kvm_available
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"

    # 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"
    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",
            "-device", "virtio-net-pci,netdev=vnet",
            "-vnc", "127.0.0.1:0,to=20",
            "-serial", "file:%s" % os.path.join(self._tmpdir, "serial.out")]
        if vcpus and vcpus > 1:
            self._args += ["-smp", str(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

        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).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, interactive=False):
        ssh_cmd = ["ssh", "-q",
                   "-o", "StrictHostKeyChecking=no",
                   "-o", "UserKnownHostsFile=" + os.devnull,
                   "-o", "ConnectTimeout=1",
                   "-p", self.ssh_port, "-i", self._ssh_key_file]
        if interactive:
            ssh_cmd += ['-t']
        assert not isinstance(cmd, str)
        ssh_cmd += ["%[email protected]" % 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_interactive(self, *cmd):
        return self._ssh_do(self.GUEST_USER, cmd, False, True)

    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).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)
        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 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 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=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

    if args.interactive:
        if vm.ssh_interactive(*cmd) == 0:
            return 0
        vm.ssh_interactive()
        return 3
    else:
        if vm.ssh(*cmd) != 0:
            return 3
Commit	Line	Data
ff2ebff0 FZ	1	#!/usr/bin/env python
	2	#
	3	# VM testing base class
	4	#
	5	# Copyright 2017 Red Hat Inc.
	6	#
	7	# Authors:
	8	# Fam Zheng <[email protected]>
	9	#
	10	# This code is licensed under the GPL version 2 or later. See
	11	# the COPYING file in the top-level directory.
	12	#
	13
f03868bd	14	from __future__ import print_function
ff2ebff0 FZ	15	import os
	16	import sys
	17	import logging
	18	import time
	19	import datetime
8f8fd9ed	20	sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
b59b82ed	21	from qemu import QEMUMachine, kvm_available
ff2ebff0 FZ	22	import subprocess
	23	import hashlib
	24	import optparse
	25	import atexit
	26	import tempfile
	27	import shutil
	28	import multiprocessing
	29	import traceback
	30
	31	SSH_KEY = open(os.path.join(os.path.dirname(__file__),
	32	"..", "keys", "id_rsa")).read()
	33	SSH_PUB_KEY = open(os.path.join(os.path.dirname(__file__),
	34	"..", "keys", "id_rsa.pub")).read()
	35
	36	class BaseVM(object):
	37	GUEST_USER = "qemu"
	38	GUEST_PASS = "qemupass"
	39	ROOT_PASS = "qemupass"
	40
	41	# The script to run in the guest that builds QEMU
	42	BUILD_SCRIPT = ""
	43	# The guest name, to be overridden by subclasses
	44	name = "#base"
31719c37 PMD	45	# The guest architecture, to be overridden by subclasses
31719c37 PMD	46	arch = "#arch"
ff2ebff0 FZ	47	def __init__(self, debug=False, vcpus=None):
	48	self._guest = None
	49	self._tmpdir = os.path.realpath(tempfile.mkdtemp(prefix="vm-test-",
	50	suffix=".tmp",
	51	dir="."))
	52	atexit.register(shutil.rmtree, self._tmpdir)
	53
	54	self._ssh_key_file = os.path.join(self._tmpdir, "id_rsa")
	55	open(self._ssh_key_file, "w").write(SSH_KEY)
	56	subprocess.check_call(["chmod", "600", self._ssh_key_file])
	57
	58	self._ssh_pub_key_file = os.path.join(self._tmpdir, "id_rsa.pub")
	59	open(self._ssh_pub_key_file, "w").write(SSH_PUB_KEY)
	60
	61	self.debug = debug
	62	self._stderr = sys.stderr
	63	self._devnull = open(os.devnull, "w")
	64	if self.debug:
	65	self._stdout = sys.stdout
	66	else:
	67	self._stdout = self._devnull
	68	self._args = [ \
eb2712f5	69	"-nodefaults", "-m", "4G",
b33bd859	70	"-cpu", "max",
ff2ebff0 FZ	71	"-netdev", "user,id=vnet,hostfwd=:127.0.0.1:0-:22",
	72	"-device", "virtio-net-pci,netdev=vnet",
	73	"-vnc", "127.0.0.1:0,to=20",
	74	"-serial", "file:%s" % os.path.join(self._tmpdir, "serial.out")]
071cf5a4	75	if vcpus and vcpus > 1:
ff2ebff0	76	self._args += ["-smp", str(vcpus)]
71531bb5	77	if kvm_available(self.arch):
ff2ebff0 FZ	78	self._args += ["-enable-kvm"]
	79	else:
	80	logging.info("KVM not available, not using -enable-kvm")
	81	self._data_args = []
	82
	83	def _download_with_cache(self, url, sha256sum=None):
	84	def check_sha256sum(fname):
	85	if not sha256sum:
	86	return True
	87	checksum = subprocess.check_output(["sha256sum", fname]).split()[0]
	88	return sha256sum == checksum
	89
	90	cache_dir = os.path.expanduser("~/.cache/qemu-vm/download")
	91	if not os.path.exists(cache_dir):
	92	os.makedirs(cache_dir)
	93	fname = os.path.join(cache_dir, hashlib.sha1(url).hexdigest())
	94	if os.path.exists(fname) and check_sha256sum(fname):
	95	return fname
	96	logging.debug("Downloading %s to %s...", url, fname)
	97	subprocess.check_call(["wget", "-c", url, "-O", fname + ".download"],
	98	stdout=self._stdout, stderr=self._stderr)
	99	os.rename(fname + ".download", fname)
	100	return fname
	101
	102	def _ssh_do(self, user, cmd, check, interactive=False):
	103	ssh_cmd = ["ssh", "-q",
	104	"-o", "StrictHostKeyChecking=no",
	105	"-o", "UserKnownHostsFile=" + os.devnull,
	106	"-o", "ConnectTimeout=1",
	107	"-p", self.ssh_port, "-i", self._ssh_key_file]
	108	if interactive:
	109	ssh_cmd += ['-t']
	110	assert not isinstance(cmd, str)
	111	ssh_cmd += ["%[email protected]" % user] + list(cmd)
	112	logging.debug("ssh_cmd: %s", " ".join(ssh_cmd))
726c9a3b	113	r = subprocess.call(ssh_cmd)
ff2ebff0 FZ	114	if check and r != 0:
	115	raise Exception("SSH command failed: %s" % cmd)
	116	return r
	117
	118	def ssh(self, *cmd):
	119	return self._ssh_do(self.GUEST_USER, cmd, False)
	120
	121	def ssh_interactive(self, *cmd):
	122	return self._ssh_do(self.GUEST_USER, cmd, False, True)
	123
	124	def ssh_root(self, *cmd):
	125	return self._ssh_do("root", cmd, False)
	126
	127	def ssh_check(self, *cmd):
	128	self._ssh_do(self.GUEST_USER, cmd, True)
	129
	130	def ssh_root_check(self, *cmd):
	131	self._ssh_do("root", cmd, True)
	132
	133	def build_image(self, img):
	134	raise NotImplementedError
	135
	136	def add_source_dir(self, src_dir):
	137	name = "data-" + hashlib.sha1(src_dir).hexdigest()[:5]
	138	tarfile = os.path.join(self._tmpdir, name + ".tar")
	139	logging.debug("Creating archive %s for src_dir dir: %s", tarfile, src_dir)
	140	subprocess.check_call(["./scripts/archive-source.sh", tarfile],
	141	cwd=src_dir, stdin=self._devnull,
	142	stdout=self._stdout, stderr=self._stderr)
	143	self._data_args += ["-drive",
	144	"file=%s,if=none,id=%s,cache=writeback,format=raw" % \
	145	(tarfile, name),
	146	"-device",
	147	"virtio-blk,drive=%s,serial=%s,bootindex=1" % (name, name)]
	148
	149	def boot(self, img, extra_args=[]):
	150	args = self._args + [
	151	"-device", "VGA",
	152	"-drive", "file=%s,if=none,id=drive0,cache=writeback" % img,
	153	"-device", "virtio-blk,drive=drive0,bootindex=0"]
	154	args += self._data_args + extra_args
	155	logging.debug("QEMU args: %s", " ".join(args))
31719c37	156	qemu_bin = os.environ.get("QEMU", "qemu-system-" + self.arch)
ff2ebff0 FZ	157	guest = QEMUMachine(binary=qemu_bin, args=args)
	158	try:
	159	guest.launch()
	160	except:
	161	logging.error("Failed to launch QEMU, command line:")
	162	logging.error(" ".join([qemu_bin] + args))
	163	logging.error("Log:")
	164	logging.error(guest.get_log())
	165	logging.error("QEMU version >= 2.10 is required")
	166	raise
	167	atexit.register(self.shutdown)
	168	self._guest = guest
	169	usernet_info = guest.qmp("human-monitor-command",
	170	command_line="info usernet")
	171	self.ssh_port = None
	172	for l in usernet_info["return"].splitlines():
	173	fields = l.split()
	174	if "TCP[HOST_FORWARD]" in fields and "22" in fields:
	175	self.ssh_port = l.split()[3]
	176	if not self.ssh_port:
	177	raise Exception("Cannot find ssh port from 'info usernet':\n%s" % \
	178	usernet_info)
	179
6b699ae1	180	def wait_ssh(self, seconds=300):
ff2ebff0	181	starttime = datetime.datetime.now()
f5d3d218	182	endtime = starttime + datetime.timedelta(seconds=seconds)
ff2ebff0	183	guest_up = False
f5d3d218	184	while datetime.datetime.now() < endtime:
ff2ebff0 FZ	185	if self.ssh("exit 0") == 0:
	186	guest_up = True
	187	break
f5d3d218 PMD	188	seconds = (endtime - datetime.datetime.now()).total_seconds()
f5d3d218 PMD	189	logging.debug("%ds before timeout", seconds)
ff2ebff0 FZ	190	time.sleep(1)
	191	if not guest_up:
	192	raise Exception("Timeout while waiting for guest ssh")
	193
	194	def shutdown(self):
	195	self._guest.shutdown()
	196
	197	def wait(self):
	198	self._guest.wait()
	199
	200	def qmp(self, args, *kwargs):
	201	return self._guest.qmp(args, *kwargs)
	202
63a24c5e	203	def parse_args(vmcls):
8a6e007e PMD	204
8a6e007e PMD	205	def get_default_jobs():
63a24c5e	206	if kvm_available(vmcls.arch):
8a6e007e PMD	207	return multiprocessing.cpu_count() / 2
	208	else:
	209	return 1
	210
ff2ebff0 FZ	211	parser = optparse.OptionParser(
	212	description="VM test utility. Exit codes: "
	213	"0 = success, "
	214	"1 = command line error, "
	215	"2 = environment initialization failed, "
	216	"3 = test command failed")
	217	parser.add_option("--debug", "-D", action="store_true",
	218	help="enable debug output")
63a24c5e	219	parser.add_option("--image", "-i", default="%s.img" % vmcls.name,
ff2ebff0 FZ	220	help="image file name")
	221	parser.add_option("--force", "-f", action="store_true",
	222	help="force build image even if image exists")
8a6e007e	223	parser.add_option("--jobs", type=int, default=get_default_jobs(),
ff2ebff0	224	help="number of virtual CPUs")
41e3340a PM	225	parser.add_option("--verbose", "-V", action="store_true",
41e3340a PM	226	help="Pass V=1 to builds within the guest")
ff2ebff0 FZ	227	parser.add_option("--build-image", "-b", action="store_true",
	228	help="build image")
	229	parser.add_option("--build-qemu",
	230	help="build QEMU from source in guest")
5c2ec9b6 AB	231	parser.add_option("--build-target",
5c2ec9b6 AB	232	help="QEMU build target", default="check")
ff2ebff0 FZ	233	parser.add_option("--interactive", "-I", action="store_true",
ff2ebff0 FZ	234	help="Interactively run command")
983c2a77 FZ	235	parser.add_option("--snapshot", "-s", action="store_true",
983c2a77 FZ	236	help="run tests with a snapshot")
ff2ebff0 FZ	237	parser.disable_interspersed_args()
	238	return parser.parse_args()
	239
	240	def main(vmcls):
	241	try:
63a24c5e	242	args, argv = parse_args(vmcls)
ff2ebff0	243	if not argv and not args.build_qemu and not args.build_image:
f03868bd	244	print("Nothing to do?")
ff2ebff0	245	return 1
fb3b4e6d EH	246	logging.basicConfig(level=(logging.DEBUG if args.debug
fb3b4e6d EH	247	else logging.WARN))
ff2ebff0 FZ	248	vm = vmcls(debug=args.debug, vcpus=args.jobs)
	249	if args.build_image:
	250	if os.path.exists(args.image) and not args.force:
	251	sys.stderr.writelines(["Image file exists: %s\n" % args.image,
	252	"Use --force option to overwrite\n"])
	253	return 1
	254	return vm.build_image(args.image)
	255	if args.build_qemu:
	256	vm.add_source_dir(args.build_qemu)
	257	cmd = [vm.BUILD_SCRIPT.format(
	258	configure_opts = " ".join(argv),
41e3340a	259	jobs=args.jobs,
5c2ec9b6	260	target=args.build_target,
41e3340a	261	verbose = "V=1" if args.verbose else "")]
ff2ebff0 FZ	262	else:
ff2ebff0 FZ	263	cmd = argv
983c2a77 FZ	264	img = args.image
	265	if args.snapshot:
	266	img += ",snapshot=on"
	267	vm.boot(img)
ff2ebff0 FZ	268	vm.wait_ssh()
	269	except Exception as e:
	270	if isinstance(e, SystemExit) and e.code == 0:
	271	return 0
	272	sys.stderr.write("Failed to prepare guest environment\n")
	273	traceback.print_exc()
	274	return 2
	275
	276	if args.interactive:
	277	if vm.ssh_interactive(*cmd) == 0:
	278	return 0
	279	vm.ssh_interactive()
	280	return 3
	281	else:
	282	if vm.ssh(*cmd) != 0:
	283	return 3