mirror of https://gitee.com/openkylin/qemu.git
tests: Add vm test lib
This is the common code to implement a "VM test" to 1) Download and initialize a pre-defined VM that has necessary dependencies to build QEMU and SSH access. 2) Archive $SRC_PATH to a .tar file. 3) Boot the VM, and pass the source tar file to the guest. 4) SSH into the VM, untar the source tarball, build from the source. Signed-off-by: Fam Zheng <famz@redhat.com> Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
This commit is contained in:
Fam Zheng
parent
57446e32ac
commit
ff2ebff079
|
|
@ -0,0 +1,262 @@
|
|||
#!/usr/bin/env python
|
||||
#
|
||||
# VM testing base class
|
||||
#
|
||||
# Copyright 2017 Red Hat Inc.
|
||||
#
|
||||
# Authors:
|
||||
# Fam Zheng <famz@redhat.com>
|
||||
#
|
||||
# This code is licensed under the GPL version 2 or later. See
|
||||
# the COPYING file in the top-level directory.
|
||||
#
|
||||
|
||||
import os
|
||||
import sys
|
||||
import logging
|
||||
import time
|
||||
import datetime
|
||||
sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "scripts"))
|
||||
from qemu 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"
|
||||
|
||||
# The script to run in the guest that builds QEMU
|
||||
BUILD_SCRIPT = ""
|
||||
# The guest name, to be overridden by subclasses
|
||||
name = "#base"
|
||||
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", "2G",
|
||||
"-cpu", "host",
|
||||
"-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:
|
||||
self._args += ["-smp", str(vcpus)]
|
||||
if os.access("/dev/kvm", os.R_OK | os.W_OK):
|
||||
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 += ["%s@127.0.0.1" % user] + list(cmd)
|
||||
logging.debug("ssh_cmd: %s", " ".join(ssh_cmd))
|
||||
r = subprocess.call(ssh_cmd,
|
||||
stdin=sys.stdin if interactive else self._devnull,
|
||||
stdout=sys.stdout if interactive else self._stdout,
|
||||
stderr=sys.stderr if interactive else self._stderr)
|
||||
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-x86_64")
|
||||
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=120):
|
||||
starttime = datetime.datetime.now()
|
||||
guest_up = False
|
||||
while (datetime.datetime.now() - starttime).total_seconds() < seconds:
|
||||
if self.ssh("exit 0") == 0:
|
||||
guest_up = True
|
||||
break
|
||||
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(vm_name):
|
||||
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" % vm_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=multiprocessing.cpu_count() / 2,
|
||||
help="number of virtual CPUs")
|
||||
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("--interactive", "-I", action="store_true",
|
||||
help="Interactively run command")
|
||||
parser.disable_interspersed_args()
|
||||
return parser.parse_args()
|
||||
|
||||
def main(vmcls):
|
||||
try:
|
||||
args, argv = parse_args(vmcls.name)
|
||||
if not argv and not args.build_qemu and not args.build_image:
|
||||
print "Nothing to do?"
|
||||
return 1
|
||||
if args.debug:
|
||||
logging.getLogger().setLevel(logging.DEBUG)
|
||||
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)]
|
||||
else:
|
||||
cmd = argv
|
||||
vm.boot(args.image + ",snapshot=on")
|
||||
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
|
||||
Loading…
Reference in New Issue