Revert "Merge remote branch 'cros/upstream' into autotest-rebase"

client/tests/kvm/installer.py

Index: client/tests/kvm/installer.py
diff --git a/client/tests/kvm/installer.py b/client/tests/kvm/installer.py
deleted file mode 100644
index 30ee657dbecf002eaefd7cd09eadf0896e7bf008..0000000000000000000000000000000000000000
--- a/client/tests/kvm/installer.py
+++ /dev/null
@@ -1,781 +0,0 @@
-import time, os, sys, urllib, re, signal, logging, datetime, glob, ConfigParser
-import shutil
-from autotest_lib.client.bin import utils, test, os_dep
-from autotest_lib.client.common_lib import error
-import kvm_utils
-
-
-def check_configure_options(script_path):
-    """
-    Return the list of available options (flags) of a given kvm configure build
-    script.
-
-    @param script: Path to the configure script
-    """
-    abspath = os.path.abspath(script_path)
-    help_raw = utils.system_output('%s --help' % abspath, ignore_status=True)
-    help_output = help_raw.split("\n")
-    option_list = []
-    for line in help_output:
-        cleaned_line = line.lstrip()
-        if cleaned_line.startswith("--"):
-            option = cleaned_line.split()[0]
-            option = option.split("=")[0]
-            option_list.append(option)
-
-    return option_list
-
-
-def kill_qemu_processes():
-    """
-    Kills all qemu processes, also kills all processes holding /dev/kvm down.
-    """
-    logging.debug("Killing any qemu processes that might be left behind")
-    utils.system("pkill qemu", ignore_status=True)
-    # Let's double check to see if some other process is holding /dev/kvm
-    if os.path.isfile("/dev/kvm"):
-        utils.system("fuser -k /dev/kvm", ignore_status=True)
-
-
-def cpu_vendor():
-    vendor = "intel"
-    if os.system("grep vmx /proc/cpuinfo 1>/dev/null") != 0:
-        vendor = "amd"
-    logging.debug("Detected CPU vendor as '%s'" %(vendor))
-    return vendor
-
-
-def _unload_kvm_modules(mod_list):
-    logging.info("Unloading previously loaded KVM modules")
-    for module in reversed(mod_list):
-        utils.unload_module(module)
-
-
-def _load_kvm_modules(mod_list, module_dir=None, load_stock=False):
-    """
-    Just load the KVM modules, without killing Qemu or unloading previous
-    modules.
-
-    Load modules present on any sub directory of module_dir. Function will walk
-    through module_dir until it finds the modules.
-
-    @param module_dir: Directory where the KVM modules are located.
-    @param load_stock: Whether we are going to load system kernel modules.
-    @param extra_modules: List of extra modules to load.
-    """
-    if module_dir:
-        logging.info("Loading the built KVM modules...")
-        kvm_module_path = None
-        kvm_vendor_module_path = None
-        abort = False
-
-        list_modules = ['%s.ko' % (m) for m in mod_list]
-
-        list_module_paths = []
-        for folder, subdirs, files in os.walk(module_dir):
-            for module in list_modules:
-                if module in files:
-                    module_path = os.path.join(folder, module)
-                    list_module_paths.append(module_path)
-
-        # We might need to arrange the modules in the correct order
-        # to avoid module load problems
-        list_modules_load = []
-        for module in list_modules:
-            for module_path in list_module_paths:
-                if os.path.basename(module_path) == module:
-                    list_modules_load.append(module_path)
-
-        if len(list_module_paths) != len(list_modules):
-            logging.error("KVM modules not found. If you don't want to use the "
-                          "modules built by this test, make sure the option "
-                          "load_modules: 'no' is marked on the test control "
-                          "file.")
-            raise error.TestError("The modules %s were requested to be loaded, "
-                                  "but the only modules found were %s" %
-                                  (list_modules, list_module_paths))
-
-        for module_path in list_modules_load:
-            try:
-                utils.system("insmod %s" % module_path)
-            except Exception, e:
-                raise error.TestFail("Failed to load KVM modules: %s" % e)
-
-    if load_stock:
-        logging.info("Loading current system KVM modules...")
-        for module in mod_list:
-            utils.system("modprobe %s" % module)
-
-
-def create_symlinks(test_bindir, prefix=None, bin_list=None, unittest=None):
-    """
-    Create symbolic links for the appropriate qemu and qemu-img commands on
-    the kvm test bindir.
-
-    @param test_bindir: KVM test bindir
-    @param prefix: KVM prefix path
-    @param bin_list: List of qemu binaries to link
-    @param unittest: Path to configuration file unittests.cfg
-    """
-    qemu_path = os.path.join(test_bindir, "qemu")
-    qemu_img_path = os.path.join(test_bindir, "qemu-img")
-    qemu_unittest_path = os.path.join(test_bindir, "unittests")
-    if os.path.lexists(qemu_path):
-        os.unlink(qemu_path)
-    if os.path.lexists(qemu_img_path):
-        os.unlink(qemu_img_path)
-    if unittest and os.path.lexists(qemu_unittest_path):
-        os.unlink(qemu_unittest_path)
-
-    logging.debug("Linking qemu binaries")
-
-    if bin_list:
-        for bin in bin_list:
-            if os.path.basename(bin) == 'qemu-kvm':
-                os.symlink(bin, qemu_path)
-            elif os.path.basename(bin) == 'qemu-img':
-                os.symlink(bin, qemu_img_path)
-
-    elif prefix:
-        kvm_qemu = os.path.join(prefix, "bin", "qemu-system-x86_64")
-        if not os.path.isfile(kvm_qemu):
-            raise error.TestError('Invalid qemu path')
-        kvm_qemu_img = os.path.join(prefix, "bin", "qemu-img")
-        if not os.path.isfile(kvm_qemu_img):
-            raise error.TestError('Invalid qemu-img path')
-        os.symlink(kvm_qemu, qemu_path)
-        os.symlink(kvm_qemu_img, qemu_img_path)
-
-    if unittest:
-        logging.debug("Linking unittest dir")
-        os.symlink(unittest, qemu_unittest_path)
-
-
-def install_roms(rom_dir, prefix):
-    logging.debug("Path to roms specified. Copying roms to install prefix")
-    rom_dst_dir = os.path.join(prefix, 'share', 'qemu')
-    for rom_src in glob.glob('%s/*.bin' % rom_dir):
-        rom_dst = os.path.join(rom_dst_dir, os.path.basename(rom_src))
-        logging.debug("Copying rom file %s to %s", rom_src, rom_dst)
-        shutil.copy(rom_src, rom_dst)
-
-
-def save_build(build_dir, dest_dir):
-    logging.debug('Saving the result of the build on %s', dest_dir)
-    base_name = os.path.basename(build_dir)
-    tarball_name = base_name + '.tar.bz2'
-    os.chdir(os.path.dirname(build_dir))
-    utils.system('tar -cjf %s %s' % (tarball_name, base_name))
-    shutil.move(tarball_name, os.path.join(dest_dir, tarball_name))
-
-
-class KvmInstallException(Exception):
-    pass
-
-
-class FailedKvmInstall(KvmInstallException):
-    pass
-
-
-class KvmNotInstalled(KvmInstallException):
-    pass
-
-
-class BaseInstaller(object):
-    # default value for load_stock argument
-    load_stock_modules = True
-    def __init__(self, mode=None):
-        self.install_mode = mode
-        self._full_module_list = None
-
-    def set_install_params(self, test, params):
-        self.params = params
-
-        load_modules = params.get('load_modules', 'no')
-        if not load_modules or load_modules == 'yes':
-            self.should_load_modules = True
-        elif load_modules == 'no':
-            self.should_load_modules = False
-        default_extra_modules = str(None)
-        self.extra_modules = eval(params.get("extra_modules",
-                                             default_extra_modules))
-
-        self.cpu_vendor = cpu_vendor()
-
-        self.srcdir = test.srcdir
-        if not os.path.isdir(self.srcdir):
-            os.makedirs(self.srcdir)
-
-        self.test_bindir = test.bindir
-        self.results_dir = test.resultsdir
-
-        # KVM build prefix, for the modes that do need it
-        prefix = os.path.join(test.bindir, 'build')
-        self.prefix = os.path.abspath(prefix)
-
-        # Current host kernel directory
-        default_host_kernel_source = '/lib/modules/%s/build' % os.uname()[2]
-        self.host_kernel_srcdir = params.get('host_kernel_source',
-                                             default_host_kernel_source)
-
-        # Extra parameters that can be passed to the configure script
-        self.extra_configure_options = params.get('extra_configure_options',
-                                                  None)
-
-        # Do we want to save the result of the build on test.resultsdir?
-        self.save_results = True
-        save_results = params.get('save_results', 'no')
-        if save_results == 'no':
-            self.save_results = False
-
-        self._full_module_list = list(self._module_list())
-
-
-    def full_module_list(self):
-        """Return the module list used by the installer
-
-        Used by the module_probe test, to avoid using utils.unload_module().
-        """
-        if self._full_module_list is None:
-            raise KvmNotInstalled("KVM modules not installed yet (installer: %s)" % (type(self)))
-        return self._full_module_list
-
-
-    def _module_list(self):
-        """Generate the list of modules that need to be loaded
-        """
-        yield 'kvm'
-        yield 'kvm-%s' % (self.cpu_vendor)
-        if self.extra_modules:
-            for module in self.extra_modules:
-                yield module
-
-
-    def _load_modules(self, mod_list):
-        """
-        Load the KVM modules
-
-        May be overridden by subclasses.
-        """
-        _load_kvm_modules(mod_list, load_stock=self.load_stock_modules)
-
-
-    def load_modules(self, mod_list=None):
-        if mod_list is None:
-            mod_list = self.full_module_list()
-        self._load_modules(mod_list)
-
-
-    def _unload_modules(self, mod_list=None):
-        """
-        Just unload the KVM modules, without trying to kill Qemu
-        """
-        if mod_list is None:
-            mod_list = self.full_module_list()
-        _unload_kvm_modules(mod_list)
-
-
-    def unload_modules(self, mod_list=None):
-        """
-        Kill Qemu and unload the KVM modules
-        """
-        kill_qemu_processes()
-        self._unload_modules(mod_list)
-
-
-    def reload_modules(self):
-        """
-        Reload the KVM modules after killing Qemu and unloading the current modules
-        """
-        self.unload_modules()
-        self.load_modules()
-
-
-    def reload_modules_if_needed(self):
-        if self.should_load_modules:
-            self.reload_modules()
-
-
-class YumInstaller(BaseInstaller):
-    """
-    Class that uses yum to install and remove packages.
-    """
-    load_stock_modules = True
-    def set_install_params(self, test, params):
-        super(YumInstaller, self).set_install_params(test, params)
-        # Checking if all required dependencies are available
-        os_dep.command("rpm")
-        os_dep.command("yum")
-
-        default_pkg_list = str(['qemu-kvm', 'qemu-kvm-tools'])
-        default_qemu_bin_paths = str(['/usr/bin/qemu-kvm', '/usr/bin/qemu-img'])
-        default_pkg_path_list = str(None)
-        self.pkg_list = eval(params.get("pkg_list", default_pkg_list))
-        self.pkg_path_list = eval(params.get("pkg_path_list",
-                                             default_pkg_path_list))
-        self.qemu_bin_paths = eval(params.get("qemu_bin_paths",
-                                              default_qemu_bin_paths))
-
-
-    def _clean_previous_installs(self):
-        kill_qemu_processes()
-        removable_packages = ""
-        for pkg in self.pkg_list:
-            removable_packages += " %s" % pkg
-
-        utils.system("yum remove -y %s" % removable_packages)
-
-
-    def _get_packages(self):
-        for pkg in self.pkg_path_list:
-            utils.get_file(pkg, os.path.join(self.srcdir,
-                                             os.path.basename(pkg)))
-
-
-    def _install_packages(self):
-        """
-        Install all downloaded packages.
-        """
-        os.chdir(self.srcdir)
-        utils.system("yum install --nogpgcheck -y *.rpm")
-
-
-    def install(self):
-        self._clean_previous_installs()
-        self._get_packages()
-        self._install_packages()
-        create_symlinks(test_bindir=self.test_bindir,
-                        bin_list=self.qemu_bin_paths)
-        self.reload_modules_if_needed()
-        if self.save_results:
-            save_build(self.srcdir, self.results_dir)
-
-
-class KojiInstaller(YumInstaller):
-    """
-    Class that handles installing KVM from the fedora build service, koji.
-    It uses yum to install and remove packages.
-    """
-    load_stock_modules = True
-    def set_install_params(self, test, params):
-        """
-        Gets parameters and initializes the package downloader.
-
-        @param test: kvm test object
-        @param params: Dictionary with test arguments
-        """
-        super(KojiInstaller, self).set_install_params(test, params)
-        default_koji_cmd = '/usr/bin/koji'
-        default_src_pkg = 'qemu'
-        self.src_pkg = params.get("src_pkg", default_src_pkg)
-        self.tag = params.get("koji_tag", None)
-        self.build = params.get("koji_build", None)
-        self.koji_cmd = params.get("koji_cmd", default_koji_cmd)
-
-
-    def _get_packages(self):
-        """
-        Downloads the specific arch RPMs for the specific build name.
-        """
-        downloader = kvm_utils.KojiDownloader(cmd=self.koji_cmd)
-        downloader.get(src_package=self.src_pkg, tag=self.tag,
-                            build=self.build, dst_dir=self.srcdir)
-
-
-    def install(self):
-        super(KojiInstaller, self)._clean_previous_installs()
-        self._get_packages()
-        super(KojiInstaller, self)._install_packages()
-        create_symlinks(test_bindir=self.test_bindir,
-                        bin_list=self.qemu_bin_paths)
-        self.reload_modules_if_needed()
-        if self.save_results:
-            save_build(self.srcdir, self.results_dir)
-
-
-class SourceDirInstaller(BaseInstaller):
-    """
-    Class that handles building/installing KVM directly from a tarball or
-    a single source code dir.
-    """
-    def set_install_params(self, test, params):
-        """
-        Initializes class attributes, and retrieves KVM code.
-
-        @param test: kvm test object
-        @param params: Dictionary with test arguments
-        """
-        super(SourceDirInstaller, self).set_install_params(test, params)
-
-        self.mod_install_dir = os.path.join(self.prefix, 'modules')
-        self.installed_kmods = False  # it will be set to True in case we
-                                      # installed our own modules
-
-        srcdir = params.get("srcdir", None)
-        self.path_to_roms = params.get("path_to_rom_images", None)
-
-        if self.install_mode == 'localsrc':
-            if srcdir is None:
-                raise error.TestError("Install from source directory specified"
-                                      "but no source directory provided on the"
-                                      "control file.")
-            else:
-                shutil.copytree(srcdir, self.srcdir)
-
-        if self.install_mode == 'release':
-            release_tag = params.get("release_tag")
-            release_dir = params.get("release_dir")
-            release_listing = params.get("release_listing")
-            logging.info("Installing KVM from release tarball")
-            if not release_tag:
-                release_tag = kvm_utils.get_latest_kvm_release_tag(
-                                                                release_listing)
-            tarball = os.path.join(release_dir, 'kvm', release_tag,
-                                   "kvm-%s.tar.gz" % release_tag)
-            logging.info("Retrieving release kvm-%s" % release_tag)
-            tarball = utils.unmap_url("/", tarball, "/tmp")
-
-        elif self.install_mode == 'snapshot':
-            logging.info("Installing KVM from snapshot")
-            snapshot_dir = params.get("snapshot_dir")
-            if not snapshot_dir:
-                raise error.TestError("Snapshot dir not provided")
-            snapshot_date = params.get("snapshot_date")
-            if not snapshot_date:
-                # Take yesterday's snapshot
-                d = (datetime.date.today() -
-                     datetime.timedelta(1)).strftime("%Y%m%d")
-            else:
-                d = snapshot_date
-            tarball = os.path.join(snapshot_dir, "kvm-snapshot-%s.tar.gz" % d)
-            logging.info("Retrieving kvm-snapshot-%s" % d)
-            tarball = utils.unmap_url("/", tarball, "/tmp")
-
-        elif self.install_mode == 'localtar':
-            tarball = params.get("tarball")
-            if not tarball:
-                raise error.TestError("KVM Tarball install specified but no"
-                                      " tarball provided on control file.")
-            logging.info("Installing KVM from a local tarball")
-            logging.info("Using tarball %s")
-            tarball = utils.unmap_url("/", params.get("tarball"), "/tmp")
-
-        if self.install_mode in ['release', 'snapshot', 'localtar']:
-            utils.extract_tarball_to_dir(tarball, self.srcdir)
-
-        if self.install_mode in ['release', 'snapshot', 'localtar', 'srcdir']:
-            self.repo_type = kvm_utils.check_kvm_source_dir(self.srcdir)
-            configure_script = os.path.join(self.srcdir, 'configure')
-            self.configure_options = check_configure_options(configure_script)
-
-
-    def _build(self):
-        make_jobs = utils.count_cpus()
-        os.chdir(self.srcdir)
-        # For testing purposes, it's better to build qemu binaries with
-        # debugging symbols, so we can extract more meaningful stack traces.
-        cfg = "./configure --prefix=%s" % self.prefix
-        if "--disable-strip" in self.configure_options:
-            cfg += " --disable-strip"
-        steps = [cfg, "make clean", "make -j %s" % make_jobs]
-        logging.info("Building KVM")
-        for step in steps:
-            utils.system(step)
-
-
-    def _install_kmods_old_userspace(self, userspace_path):
-        """
-        Run the module install command.
-
-        This is for the "old userspace" code, that contained a 'kernel' subdirectory
-        with the kmod build code.
-
-        The code would be much simpler if we could specify the module install
-        path as parameter to the toplevel Makefile. As we can't do that and
-        the module install code doesn't use --prefix, we have to call
-        'make -C kernel install' directly, setting the module directory
-        parameters.
-
-        If the userspace tree doens't have a 'kernel' subdirectory, the
-        module install step will be skipped.
-
-        @param userspace_path: the path the kvm-userspace directory
-        """
-        kdir = os.path.join(userspace_path, 'kernel')
-        if os.path.isdir(kdir):
-            os.chdir(kdir)
-            # INSTALLDIR is the target dir for the modules
-            # ORIGMODDIR is the dir where the old modules will be removed. we
-            #            don't want to mess with the system modules, so set it
-            #            to a non-existing directory
-            utils.system('make install INSTALLDIR=%s ORIGMODDIR=/tmp/no-old-modules' % (self.mod_install_dir))
-            self.installed_kmods = True
-
-
-    def _install_kmods(self, kmod_path):
-        """Run the module install command for the kmod-kvm repository
-
-        @param kmod_path: the path to the kmod-kvm.git working copy
-        """
-        os.chdir(kmod_path)
-        utils.system('make modules_install DESTDIR=%s' % (self.mod_install_dir))
-        self.installed_kmods = True
-
-
-    def _install(self):
-        os.chdir(self.srcdir)
-        logging.info("Installing KVM userspace")
-        if self.repo_type == 1:
-            utils.system("make -C qemu install")
-            self._install_kmods_old_userspace(self.srcdir)
-        elif self.repo_type == 2:
-            utils.system("make install")
-        if self.path_to_roms:
-            install_roms(self.path_to_roms, self.prefix)
-        create_symlinks(self.test_bindir, self.prefix)
-
-
-    def _load_modules(self, mod_list):
-        # load the installed KVM modules in case we installed them
-        # ourselves. Otherwise, just load the system modules.
-        if self.installed_kmods:
-            logging.info("Loading installed KVM modules")
-            _load_kvm_modules(mod_list, module_dir=self.mod_install_dir)
-        else:
-            logging.info("Loading stock KVM modules")
-            _load_kvm_modules(mod_list, load_stock=True)
-
-
-    def install(self):
-        self._build()
-        self._install()
-        self.reload_modules_if_needed()
-        if self.save_results:
-            save_build(self.srcdir, self.results_dir)
-
-
-class GitInstaller(SourceDirInstaller):
-    def _pull_code(self):
-        """
-        Retrieves code from git repositories.
-        """
-        params = self.params
-
-        kernel_repo = params.get("git_repo")
-        user_repo = params.get("user_git_repo")
-        kmod_repo = params.get("kmod_repo")
-        test_repo = params.get("test_git_repo")
-
-        kernel_branch = params.get("kernel_branch", "master")
-        user_branch = params.get("user_branch", "master")
-        kmod_branch = params.get("kmod_branch", "master")
-        test_branch = params.get("test_branch", "master")
-
-        kernel_lbranch = params.get("kernel_lbranch", "master")
-        user_lbranch = params.get("user_lbranch", "master")
-        kmod_lbranch = params.get("kmod_lbranch", "master")
-        test_lbranch = params.get("test_lbranch", "master")
-
-        kernel_commit = params.get("kernel_commit", None)
-        user_commit = params.get("user_commit", None)
-        kmod_commit = params.get("kmod_commit", None)
-        test_commit = params.get("test_commit", None)
-
-        kernel_patches = eval(params.get("kernel_patches", "[]"))
-        user_patches = eval(params.get("user_patches", "[]"))
-        kmod_patches = eval(params.get("user_patches", "[]"))
-
-        if not user_repo:
-            message = "KVM user git repository path not specified"
-            logging.error(message)
-            raise error.TestError(message)
-
-        userspace_srcdir = os.path.join(self.srcdir, "kvm_userspace")
-        kvm_utils.get_git_branch(user_repo, user_branch, userspace_srcdir,
-                                 user_commit, user_lbranch)
-        self.userspace_srcdir = userspace_srcdir
-
-        if user_patches:
-            os.chdir(self.userspace_srcdir)
-            for patch in user_patches:
-                utils.get_file(patch, os.path.join(self.userspace_srcdir,
-                                                   os.path.basename(patch)))
-                utils.system('patch -p1 %s' % os.path.basename(patch))
-
-        if test_repo:
-            test_srcdir = os.path.join(self.srcdir, "kvm-unit-tests")
-            kvm_utils.get_git_branch(test_repo, test_branch, test_srcdir,
-                                     test_commit, test_lbranch)
-            unittest_cfg = os.path.join(test_srcdir, 'x86',
-                                        'unittests.cfg')
-            self.test_srcdir = test_srcdir
-        else:
-            unittest_cfg = os.path.join(userspace_srcdir, 'kvm', 'test', 'x86',
-                                        'unittests.cfg')
-
-        self.unittest_cfg = None
-        if os.path.isfile(unittest_cfg):
-            self.unittest_cfg = unittest_cfg
-
-        if kernel_repo:
-            kernel_srcdir = os.path.join(self.srcdir, "kvm")
-            kvm_utils.get_git_branch(kernel_repo, kernel_branch, kernel_srcdir,
-                                     kernel_commit, kernel_lbranch)
-            self.kernel_srcdir = kernel_srcdir
-            if kernel_patches:
-                os.chdir(self.kernel_srcdir)
-                for patch in kernel_patches:
-                    utils.get_file(patch, os.path.join(self.userspace_srcdir,
-                                                       os.path.basename(patch)))
-                    utils.system('patch -p1 %s' % os.path.basename(patch))
-        else:
-            self.kernel_srcdir = None
-
-        if kmod_repo:
-            kmod_srcdir = os.path.join (self.srcdir, "kvm_kmod")
-            kvm_utils.get_git_branch(kmod_repo, kmod_branch, kmod_srcdir,
-                                     kmod_commit, kmod_lbranch)
-            self.kmod_srcdir = kmod_srcdir
-            if kmod_patches:
-                os.chdir(self.kmod_srcdir)
-                for patch in kmod_patches:
-                    utils.get_file(patch, os.path.join(self.userspace_srcdir,
-                                                       os.path.basename(patch)))
-                    utils.system('patch -p1 %s' % os.path.basename(patch))
-        else:
-            self.kmod_srcdir = None
-
-        configure_script = os.path.join(self.userspace_srcdir, 'configure')
-        self.configure_options = check_configure_options(configure_script)
-
-
-    def _build(self):
-        make_jobs = utils.count_cpus()
-        cfg = './configure'
-        if self.kmod_srcdir:
-            logging.info('Building KVM modules')
-            os.chdir(self.kmod_srcdir)
-            module_build_steps = [cfg,
-                                  'make clean',
-                                  'make sync LINUX=%s' % self.kernel_srcdir,
-                                  'make']
-        elif self.kernel_srcdir:
-            logging.info('Building KVM modules')
-            os.chdir(self.userspace_srcdir)
-            cfg += ' --kerneldir=%s' % self.host_kernel_srcdir
-            module_build_steps = [cfg,
-                            'make clean',
-                            'make -C kernel LINUX=%s sync' % self.kernel_srcdir]
-        else:
-            module_build_steps = []
-
-        for step in module_build_steps:
-            utils.run(step)
-
-        logging.info('Building KVM userspace code')
-        os.chdir(self.userspace_srcdir)
-        cfg += ' --prefix=%s' % self.prefix
-        if "--disable-strip" in self.configure_options:
-            cfg += ' --disable-strip'
-        if self.extra_configure_options:
-            cfg += ' %s' % self.extra_configure_options
-        utils.system(cfg)
-        utils.system('make clean')
-        utils.system('make -j %s' % make_jobs)
-
-        self.unittest_prefix = None
-        if self.unittest_cfg:
-            os.chdir(os.path.dirname(os.path.dirname(self.unittest_cfg)))
-            utils.system('./configure --prefix=%s' % self.prefix)
-            utils.system('make')
-            utils.system('make install')
-            self.unittest_prefix = os.path.join(self.prefix, 'share', 'qemu',
-                                                'tests')
-
-
-    def _install(self):
-        if self.kernel_srcdir:
-            os.chdir(self.userspace_srcdir)
-            # the kernel module install with --prefix doesn't work, and DESTDIR
-            # wouldn't work for the userspace stuff, so we clear WANT_MODULE:
-            utils.system('make install WANT_MODULE=')
-            # and install the old-style-kmod modules manually:
-            self._install_kmods_old_userspace(self.userspace_srcdir)
-        elif self.kmod_srcdir:
-            # if we have a kmod repository, it is easier:
-            # 1) install userspace:
-            os.chdir(self.userspace_srcdir)
-            utils.system('make install')
-            # 2) install kmod:
-            self._install_kmods(self.kmod_srcdir)
-        else:
-            # if we don't have kmod sources, we just install
-            # userspace:
-            os.chdir(self.userspace_srcdir)
-            utils.system('make install')
-
-        if self.path_to_roms:
-            install_roms(self.path_to_roms, self.prefix)
-        create_symlinks(test_bindir=self.test_bindir, prefix=self.prefix,
-                        bin_list=None,
-                        unittest=self.unittest_prefix)
-
-
-    def install(self):
-        self._pull_code()
-        self._build()
-        self._install()
-        self.reload_modules_if_needed()
-        if self.save_results:
-            save_build(self.srcdir, self.results_dir)
-
-
-class PreInstalledKvm(BaseInstaller):
-    # load_modules() will use the stock modules:
-    load_stock_modules = True
-    def install(self):
-        logging.info("Expecting KVM to be already installed. Doing nothing")
-
-
-class FailedInstaller:
-    """
-    Class used to be returned instead of the installer if a installation fails
-
-    Useful to make sure no installer object is used if KVM installation fails.
-    """
-    def __init__(self, msg="KVM install failed"):
-        self._msg = msg
-
-
-    def load_modules(self):
-        """Will refuse to load the KVM modules as install failed"""
-        raise FailedKvmInstall("KVM modules not available. reason: %s" % (self._msg))
-
-
-installer_classes = {
-    'localsrc': SourceDirInstaller,
-    'localtar': SourceDirInstaller,
-    'release': SourceDirInstaller,
-    'snapshot': SourceDirInstaller,
-    'git': GitInstaller,
-    'yum': YumInstaller,
-    'koji': KojiInstaller,
-    'preinstalled': PreInstalledKvm,
-}
-
-
-def _installer_class(install_mode):
-    c = installer_classes.get(install_mode)
-    if c is None:
-        raise error.TestError('Invalid or unsupported'
-                              ' install mode: %s' % install_mode)
-    return c
-
-
-def make_installer(params):
-    # priority:
-    # - 'install_mode' param
-    # - 'mode' param
-    mode = params.get("install_mode", params.get("mode"))
-    klass = _installer_class(mode)
-    return klass(mode)