tests/vm/basevm.py

   1 #!/usr/bin/env python
   2 #
   3 # VM testing base class
   4 #
   5 # Copyright 2017 Red Hat Inc.
   6 #
   7 # Authors:
   8 #  Fam Zheng <famz@redhat.com>
   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
  14 from __future__ import print_function
  15 import os
  16 import sys
  17 import logging
  18 import time
  19 import datetime
  20 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
  21 from qemu import QEMUMachine, kvm_available
  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"
  45     # The guest architecture, to be overridden by subclasses
  46     arch = "#arch"
  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 = [ \
  69             "-nodefaults", "-m", "4G",
  70             "-cpu", "max",
  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")]
  75         if vcpus and vcpus > 1:
  76             self._args += ["-smp", "%d" % vcpus]
  77         if kvm_available(self.arch):
  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.decode("utf-8")
  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,
  94                              hashlib.sha1(url.encode("utf-8")).hexdigest())
  95         if os.path.exists(fname) and check_sha256sum(fname):
  96             return fname
  97         logging.debug("Downloading %s to %s...", url, fname)
  98         subprocess.check_call(["wget", "-c", url, "-O", fname + ".download"],
  99                               stdout=self._stdout, stderr=self._stderr)
 100         os.rename(fname + ".download", fname)
 101         return fname
 102
 103     def _ssh_do(self, user, cmd, check, interactive=False):
 104         ssh_cmd = ["ssh", "-q",
 105                    "-o", "StrictHostKeyChecking=no",
 106                    "-o", "UserKnownHostsFile=" + os.devnull,
 107                    "-o", "ConnectTimeout=1",
 108                    "-p", self.ssh_port, "-i", self._ssh_key_file]
 109         if interactive:
 110             ssh_cmd += ['-t']
 111         assert not isinstance(cmd, str)
 112         ssh_cmd += ["%s@127.0.0.1" % user] + list(cmd)
 113         logging.debug("ssh_cmd: %s", " ".join(ssh_cmd))
 114         r = subprocess.call(ssh_cmd)
 115         if check and r != 0:
 116             raise Exception("SSH command failed: %s" % cmd)
 117         return r
 118
 119     def ssh(self, *cmd):
 120         return self._ssh_do(self.GUEST_USER, cmd, False)
 121
 122     def ssh_interactive(self, *cmd):
 123         return self._ssh_do(self.GUEST_USER, cmd, False, True)
 124
 125     def ssh_root(self, *cmd):
 126         return self._ssh_do("root", cmd, False)
 127
 128     def ssh_check(self, *cmd):
 129         self._ssh_do(self.GUEST_USER, cmd, True)
 130
 131     def ssh_root_check(self, *cmd):
 132         self._ssh_do("root", cmd, True)
 133
 134     def build_image(self, img):
 135         raise NotImplementedError
 136
 137     def add_source_dir(self, src_dir):
 138         name = "data-" + hashlib.sha1(src_dir.encode("utf-8")).hexdigest()[:5]
 139         tarfile = os.path.join(self._tmpdir, name + ".tar")
 140         logging.debug("Creating archive %s for src_dir dir: %s", tarfile, src_dir)
 141         subprocess.check_call(["./scripts/archive-source.sh", tarfile],
 142                               cwd=src_dir, stdin=self._devnull,
 143                               stdout=self._stdout, stderr=self._stderr)
 144         self._data_args += ["-drive",
 145                             "file=%s,if=none,id=%s,cache=writeback,format=raw" % \
 146                                     (tarfile, name),
 147                             "-device",
 148                             "virtio-blk,drive=%s,serial=%s,bootindex=1" % (name, name)]
 149
 150     def boot(self, img, extra_args=[]):
 151         args = self._args + [
 152             "-device", "VGA",
 153             "-drive", "file=%s,if=none,id=drive0,cache=writeback" % img,
 154             "-device", "virtio-blk,drive=drive0,bootindex=0"]
 155         args += self._data_args + extra_args
 156         logging.debug("QEMU args: %s", " ".join(args))
 157         qemu_bin = os.environ.get("QEMU", "qemu-system-" + self.arch)
 158         guest = QEMUMachine(binary=qemu_bin, args=args)
 159         try:
 160             guest.launch()
 161         except:
 162             logging.error("Failed to launch QEMU, command line:")
 163             logging.error(" ".join([qemu_bin] + args))
 164             logging.error("Log:")
 165             logging.error(guest.get_log())
 166             logging.error("QEMU version >= 2.10 is required")
 167             raise
 168         atexit.register(self.shutdown)
 169         self._guest = guest
 170         usernet_info = guest.qmp("human-monitor-command",
 171                                  command_line="info usernet")
 172         self.ssh_port = None
 173         for l in usernet_info["return"].splitlines():
 174             fields = l.split()
 175             if "TCP[HOST_FORWARD]" in fields and "22" in fields:
 176                 self.ssh_port = l.split()[3]
 177         if not self.ssh_port:
 178             raise Exception("Cannot find ssh port from 'info usernet':\n%s" % \
 179                             usernet_info)
 180
 181     def wait_ssh(self, seconds=300):
 182         starttime = datetime.datetime.now()
 183         endtime = starttime + datetime.timedelta(seconds=seconds)
 184         guest_up = False
 185         while datetime.datetime.now() < endtime:
 186             if self.ssh("exit 0") == 0:
 187                 guest_up = True
 188                 break
 189             seconds = (endtime - datetime.datetime.now()).total_seconds()
 190             logging.debug("%ds before timeout", seconds)
 191             time.sleep(1)
 192         if not guest_up:
 193             raise Exception("Timeout while waiting for guest ssh")
 194
 195     def shutdown(self):
 196         self._guest.shutdown()
 197
 198     def wait(self):
 199         self._guest.wait()
 200
 201     def qmp(self, *args, **kwargs):
 202         return self._guest.qmp(*args, **kwargs)
 203
 204 def parse_args(vmcls):
 205
 206     def get_default_jobs():
 207         if kvm_available(vmcls.arch):
 208             return multiprocessing.cpu_count() // 2
 209         else:
 210             return 1
 211
 212     parser = optparse.OptionParser(
 213         description="VM test utility.  Exit codes: "
 214                     "0 = success, "
 215                     "1 = command line error, "
 216                     "2 = environment initialization failed, "
 217                     "3 = test command failed")
 218     parser.add_option("--debug", "-D", action="store_true",
 219                       help="enable debug output")
 220     parser.add_option("--image", "-i", default="%s.img" % vmcls.name,
 221                       help="image file name")
 222     parser.add_option("--force", "-f", action="store_true",
 223                       help="force build image even if image exists")
 224     parser.add_option("--jobs", type=int, default=get_default_jobs(),
 225                       help="number of virtual CPUs")
 226     parser.add_option("--verbose", "-V", action="store_true",
 227                       help="Pass V=1 to builds within the guest")
 228     parser.add_option("--build-image", "-b", action="store_true",
 229                       help="build image")
 230     parser.add_option("--build-qemu",
 231                       help="build QEMU from source in guest")
 232     parser.add_option("--build-target",
 233                       help="QEMU build target", default="check")
 234     parser.add_option("--interactive", "-I", action="store_true",
 235                       help="Interactively run command")
 236     parser.add_option("--snapshot", "-s", action="store_true",
 237                       help="run tests with a snapshot")
 238     parser.disable_interspersed_args()
 239     return parser.parse_args()
 240
 241 def main(vmcls):
 242     try:
 243         args, argv = parse_args(vmcls)
 244         if not argv and not args.build_qemu and not args.build_image:
 245             print("Nothing to do?")
 246             return 1
 247         logging.basicConfig(level=(logging.DEBUG if args.debug
 248                                    else logging.WARN))
 249         vm = vmcls(debug=args.debug, vcpus=args.jobs)
 250         if args.build_image:
 251             if os.path.exists(args.image) and not args.force:
 252                 sys.stderr.writelines(["Image file exists: %s\n" % args.image,
 253                                       "Use --force option to overwrite\n"])
 254                 return 1
 255             return vm.build_image(args.image)
 256         if args.build_qemu:
 257             vm.add_source_dir(args.build_qemu)
 258             cmd = [vm.BUILD_SCRIPT.format(
 259                    configure_opts = " ".join(argv),
 260                    jobs=int(args.jobs),
 261                    target=args.build_target,
 262                    verbose = "V=1" if args.verbose else "")]
 263         else:
 264             cmd = argv
 265         img = args.image
 266         if args.snapshot:
 267             img += ",snapshot=on"
 268         vm.boot(img)
 269         vm.wait_ssh()
 270     except Exception as e:
 271         if isinstance(e, SystemExit) and e.code == 0:
 272             return 0
 273         sys.stderr.write("Failed to prepare guest environment\n")
 274         traceback.print_exc()
 275         return 2
 276
 277     if args.interactive:
 278         if vm.ssh_interactive(*cmd) == 0:
 279             return 0
 280         vm.ssh_interactive()
 281         return 3
 282     else:
 283         if vm.ssh(*cmd) != 0:
 284             return 3