Merge remote branch 'autotest-upstream/master' into autotest-merge

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 374 matching lines @@
                         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.
+
+    It uses yum to install and remove packages. Packages are specified
+    according to the syntax defined in the PkgSpec class.
     """
     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)
+        self.koji_cmd = params.get("koji_cmd", None)
+        if self.tag is not None:
+            kvm_utils.set_default_koji_tag(self.tag)
+        self.koji_pkgs = eval(params.get("koji_pkgs", "[]"))
 
 
     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)
+        koji_client = kvm_utils.KojiClient(cmd=self.koji_cmd)
+        for pkg_text in self.koji_pkgs:
+            pkg = kvm_utils.KojiPkgSpec(pkg_text)
+            if pkg.is_valid():
+                koji_client.get_pkgs(pkg, dst_dir=self.srcdir)
+            else:
+                logging.error('Package specification (%s) is invalid: %s', pkg,
+                              pkg.describe_invalid())
+
+
+    def _clean_previous_installs(self):
+        kill_qemu_processes()
+        removable_packages = " ".join(self._get_rpm_names())
+        utils.system("yum -y remove %s" % removable_packages)
 
 
     def install(self):
-        super(KojiInstaller, self)._clean_previous_installs()
+        self._clean_previous_installs()
         self._get_packages()
-        super(KojiInstaller, self)._install_packages()
+        self._install_packages()
         self.install_unittests()
         create_symlinks(test_bindir=self.test_bindir,
                         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)
 
 
+    def _get_rpm_names(self):
+        all_rpm_names = []
+        koji_client = kvm_utils.KojiClient(cmd=self.koji_cmd)
+        for pkg_text in self.koji_pkgs:
+            pkg = kvm_utils.KojiPkgSpec(pkg_text)
+            rpm_names = koji_client.get_pkg_rpm_names(pkg)
+            all_rpm_names += rpm_names
+        return all_rpm_names
+
+
+    def _get_rpm_file_names(self):
+        all_rpm_file_names = []
+        koji_client = kvm_utils.KojiClient(cmd=self.koji_cmd)
+        for pkg_text in self.koji_pkgs:
+            pkg = kvm_utils.KojiPkgSpec(pkg_text)
+            rpm_file_names = koji_client.get_pkg_rpm_file_names(pkg)
+            all_rpm_file_names += rpm_file_names
+        return all_rpm_file_names
+
+
+    def _install_packages(self):
+        """
+        Install all downloaded packages.
+        """
+        os.chdir(self.srcdir)
+        rpm_file_names = " ".join(self._get_rpm_file_names())
+        utils.system("yum --nogpgcheck -y localinstall %s" % rpm_file_names)
+
+
 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
@@ skipping 186 matching lines @@
         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))
+                utils.system('patch -p1 < %s' % os.path.basename(patch))
 
         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))
+                    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))
+                    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'
@@ skipping 109 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)