client/tests/kvm/control.parallel

AUTHOR = """
uril@redhat.com (Uri Lublin)
drusso@redhat.com (Dror Russo)
mgoldish@redhat.com (Michael Goldish)
dhuff@redhat.com (David Huff)
aeromenk@redhat.com (Alexey Eromenko)
mburns@redhat.com (Mike Burns)
"""
TIME = 'SHORT'
NAME = 'KVM test'
TEST_TYPE = 'client'
TEST_CLASS = 'Virtualization'
TEST_CATEGORY = 'Functional'

DOC = """
Executes the KVM test framework on a given host. This module is separated in
minor functions, that execute different tests for doing Quality Assurance on
KVM (both kernelspace and userspace) code.
"""


import sys, os, commands, re

#-----------------------------------------------------------------------------
# set English environment (command output might be localized, need to be safe)
#-----------------------------------------------------------------------------
os.environ['LANG'] = 'en_US.UTF-8'

#---------------------------------------------------------
# Enable modules import from current directory (tests/kvm)
#---------------------------------------------------------
pwd = os.path.join(os.environ['AUTODIR'],'tests/kvm')
sys.path.append(pwd)

# ------------------------
# create required symlinks
# ------------------------
# When dispatching tests from autotest-server the links we need do not exist on
# the host (the client). The following lines create those symlinks. Change
# 'rootdir' here and/or mount appropriate directories in it.
#
# When dispatching tests on local host (client mode) one can either setup kvm
# links, or same as server mode use rootdir and set all appropriate links and
# mount-points there. For example, guest installation tests need to know where
# to find the iso-files.
#
# We create the links only if not already exist, so if one already set up the
# links for client/local run we do not touch the links.
rootdir='/tmp/kvm_autotest_root'
iso=os.path.join(rootdir, 'iso')
images=os.path.join(rootdir, 'images')
qemu=os.path.join(rootdir, 'qemu')
qemu_img=os.path.join(rootdir, 'qemu-img')


def link_if_not_exist(ldir, target, link_name):
    t = target
    l = os.path.join(ldir, link_name)
    if not os.path.exists(l):
        os.system('ln -s %s %s' % (t, l))

# Create links only if not already exist
link_if_not_exist(pwd, '../../', 'autotest')
link_if_not_exist(pwd, iso, 'isos')
link_if_not_exist(pwd, images, 'images')
link_if_not_exist(pwd, qemu, 'qemu')
link_if_not_exist(pwd, qemu_img, 'qemu-img')

# --------------------------------------------------------
# Params that will be passed to the KVM install/build test
# --------------------------------------------------------
params = {
    "name": "build",
    "shortname": "build",
    "type": "build",
    #"mode": "release",
    #"mode": "snapshot",
    #"mode": "localtar",
    #"mode": "localsrc",
    #"mode": "git",
    "mode": "noinstall",
    #"mode": "koji",

    ## Are we going to load modules built by this test?
    ## Defaults to 'yes', so if you are going to provide only userspace code to
    ## be built by this test, please set load_modules to 'no', and make sure
    ## the kvm and kvm-[vendor] module is already loaded by the time you start
    ## it.
    #"load_modules": "no",

    ## Install from a kvm release ("mode": "release"). You can optionally
    ## specify a release tag. If you omit it, the test will get the latest
    ## release tag available.
    #"release_tag": '84',
    #"release_dir": 'http://downloads.sourceforge.net/project/kvm/',
    # This is the place that contains the sourceforge project list of files
    #"release_listing": 'http://sourceforge.net/projects/kvm/files/',

    ## Install from a kvm snapshot location ("mode": "snapshot"). You can
    ## optionally specify a snapshot date. If you omit it, the test will get
    ## yesterday's snapshot.
    #"snapshot_date": '20090712'
    #"snapshot_dir": 'http://foo.org/kvm-snapshots/',

    ## Install from a tarball ("mode": "localtar")
    #"tarball": "/tmp/kvm-84.tar.gz",

    ## Install from a local source code dir ("mode": "localsrc")
    #"srcdir": "/path/to/source-dir"

    ## Install from koji build server ("mode": "koji")
    ## Koji is the Fedora Project buildserver. It is possible to install
    ## packages right from Koji if you provide a release tag or a build.
    ## Tag (if available)
    #"koji_tag": 'dist-f11',
    ## Build (if available, is going to override tag).
    #"koji_build": 'qemu-0.10-16.fc11',
    ## Command to interact with the build server
    #"koji_cmd": '/usr/bin/koji',
    ## The name of the source package that's being built
    #"src_pkg": 'qemu',
    ## Name of the rpms we need installed
    #"pkg_list": ['qemu-kvm', 'qemu-kvm-tools', 'qemu-system-x86', 'qemu-common', 'qemu-img'],
    ## Paths of the qemu relevant executables that should be checked
    #"qemu_bin_paths": ['/usr/bin/qemu-kvm', '/usr/bin/qemu-img'],

    ## Install from git ("mode": "git")
    ## If you provide only "git_repo" and "user_git_repo", the build test
    ## will assume it will perform all build from the userspace dir, building
    ## modules trough make -C kernel LINUX=%s sync. As of today (07-13-2009)
    ## we need 3 git repos, "git_repo" (linux sources), "user_git_repo" and 
    ## "kmod_repo" to build KVM userspace + kernel modules.
    #"git_repo": 'git://git.kernel.org/pub/scm/linux/kernel/git/avi/kvm.git',
    #"kernel_branch": 'kernel_branch_name',
    #"kernel_lbranch": 'kernel_lbranch_name',
    #"kernel_tag": 'kernel_tag_name',
    #"user_git_repo": 'git://git.kernel.org/pub/scm/virt/kvm/qemu-kvm.git',
    #"user_branch": 'user_branch_name',
    #"user_lbranch": 'user_lbranch_name',
    #"user_tag": 'user_tag_name',
    #"kmod_repo": 'git://git.kernel.org/pub/scm/virt/kvm/kvm-kmod.git',
    #"kmod_branch": 'kmod_branch_name',
    #"kmod_lbranch": 'kmod_lbranch_name',
    #"kmod_tag": 'kmod_tag_name',
}

# If you don't want to execute the build stage, just use 'noinstall' as the
# install type. If you run the tests from autotest-server, make sure that
# /tmp/kvm-autotest-root/qemu is a link to your existing executable. Note that
# if kvm_install is chose to run, it overwrites existing qemu and qemu-img
# links to point to the newly built executables.

if not params.get("mode") == "noinstall":
    if not job.run_test("kvm", params=params, tag=params.get("shortname")):
        print 'kvm_installation failed ... exiting'
        sys.exit(1)

# ----------------------------------------------------------
# Get test set (dictionary list) from the configuration file
# ----------------------------------------------------------
from autotest_lib.client.common_lib import cartesian_config

str = """
# This string will be parsed after tests.cfg.  Make any desired changes to the
# test configuration here.  For example:
#install, setup: timeout_multiplier = 3
#display = sdl
"""

parser = cartesian_config.Parser()
parser.parse_file(os.path.join(pwd, "tests.cfg"))
parser.parse_string(str)

tests = list(parser.get_dicts())

# -------------
# Run the tests
# -------------
from autotest_lib.client.virt import virt_scheduler
from autotest_lib.client.bin import utils

# total_cpus defaults to the number of CPUs reported by /proc/cpuinfo
total_cpus = utils.count_cpus()
# total_mem defaults to 3/4 of the total memory reported by 'free'
total_mem = int(commands.getoutput("free -m").splitlines()[1].split()[1]) * 3/4
# We probably won't need more workers than CPUs
num_workers = total_cpus

# Start the scheduler and workers
s = virt_scheduler.scheduler(tests, num_workers, total_cpus, total_mem, pwd)
job.parallel([s.scheduler],
             *[(s.worker, i, job.run_test) for i in range(num_workers)])

# create the html report in result dir
reporter = os.path.join(pwd, 'make_html_report.py')
html_file = os.path.join(job.resultdir,'results.html')
os.system('%s -r %s -f %s -R'%(reporter, job.resultdir, html_file))