Merge remote branch 'autotest-upstream/master' into try-box1

client/tests/kvm/installer.py

 import os, logging, datetime, glob
 import shutil
 from autotest_lib.client.bin import utils, 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
@@ skipping 213 matching lines @@
 
         # 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 install_unittests(self):
+        userspace_srcdir = os.path.join(self.srcdir, "kvm_userspace")
+        test_repo = self.params.get("test_git_repo")
+        test_branch = self.params.get("test_branch", "master")
+        test_commit = self.params.get("test_commit", None)
+        test_lbranch = self.params.get("test_lbranch", "master")
+
+        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
+        else:
+            if test_repo:
+                logging.error("No unittest config file %s found, skipping "
+                              "unittest build", self.unittest_cfg)
+
+        self.unittest_prefix = None
+        if self.unittest_cfg:
+            logging.info("Building and installing unittests")
+            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 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
 
 
@@ skipping 90 matching lines @@
 
     def _install_packages(self):
         """
         Install all downloaded packages.
         """
         os.chdir(self.srcdir)
         utils.system("yum install --nogpgcheck -y *.rpm")
 
 
     def install(self):
+        self.install_unittests()
         self._clean_previous_installs()
         self._get_packages()
         self._install_packages()
         create_symlinks(test_bindir=self.test_bindir,
-                        bin_list=self.qemu_bin_paths)
+                        bin_list=self.qemu_bin_paths,
+                        unittest=self.unittest_prefix)
         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.
     """
@@ skipping 20 matching lines @@
         """
         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()
+        self.install_unittests()
         create_symlinks(test_bindir=self.test_bindir,
-                        bin_list=self.qemu_bin_paths)
+                        bin_list=self.qemu_bin_paths,
+                        unittest=self.unittest_prefix)
         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.
     """
@@ skipping 124 matching lines @@
     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)
+        self.install_unittests()
+        create_symlinks(test_bindir=self.test_bindir,
+                        prefix=self.prefix,
+                        unittest=self.unittest_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")
@@ skipping 11 matching lines @@
 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)))
@@ skipping 46 matching lines @@
         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)
+        self.install_unittests()
         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()
@@ skipping 43 matching lines @@
     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)