client/virt/kvm_installer.py

   1 import os, logging, datetime, glob, shutil
   2 from autotest_lib.client.bin import utils, os_dep
   3 from autotest_lib.client.common_lib import error
   4 import virt_utils, virt_installer
   5
   6
   7 def kill_qemu_processes():
   8     """
   9     Kills all qemu processes, also kills all processes holding /dev/kvm down.
  10     """
  11     logging.debug("Killing any qemu processes that might be left behind")
  12     utils.system("pkill qemu", ignore_status=True)
  13     # Let's double check to see if some other process is holding /dev/kvm
  14     if os.path.isfile("/dev/kvm"):
  15         utils.system("fuser -k /dev/kvm", ignore_status=True)
  16
  17
  18 def create_symlinks(test_bindir, prefix=None, bin_list=None, unittest=None):
  19     """
  20     Create symbolic links for the appropriate qemu and qemu-img commands on
  21     the kvm test bindir.
  22
  23     @param test_bindir: KVM test bindir
  24     @param prefix: KVM prefix path
  25     @param bin_list: List of qemu binaries to link
  26     @param unittest: Path to configuration file unittests.cfg
  27     """
  28     qemu_path = os.path.join(test_bindir, "qemu")
  29     qemu_img_path = os.path.join(test_bindir, "qemu-img")
  30     qemu_unittest_path = os.path.join(test_bindir, "unittests")
  31     if os.path.lexists(qemu_path):
  32         os.unlink(qemu_path)
  33     if os.path.lexists(qemu_img_path):
  34         os.unlink(qemu_img_path)
  35     if unittest and os.path.lexists(qemu_unittest_path):
  36         os.unlink(qemu_unittest_path)
  37
  38     logging.debug("Linking qemu binaries")
  39
  40     if bin_list:
  41         for bin in bin_list:
  42             if os.path.basename(bin) == 'qemu-kvm':
  43                 os.symlink(bin, qemu_path)
  44             elif os.path.basename(bin) == 'qemu-img':
  45                 os.symlink(bin, qemu_img_path)
  46
  47     elif prefix:
  48         kvm_qemu = os.path.join(prefix, "bin", "qemu-system-x86_64")
  49         if not os.path.isfile(kvm_qemu):
  50             raise error.TestError('Invalid qemu path')
  51         kvm_qemu_img = os.path.join(prefix, "bin", "qemu-img")
  52         if not os.path.isfile(kvm_qemu_img):
  53             raise error.TestError('Invalid qemu-img path')
  54         os.symlink(kvm_qemu, qemu_path)
  55         os.symlink(kvm_qemu_img, qemu_img_path)
  56
  57     if unittest:
  58         logging.debug("Linking unittest dir")
  59         os.symlink(unittest, qemu_unittest_path)
  60
  61
  62 def install_roms(rom_dir, prefix):
  63     logging.debug("Path to roms specified. Copying roms to install prefix")
  64     rom_dst_dir = os.path.join(prefix, 'share', 'qemu')
  65     for rom_src in glob.glob('%s/*.bin' % rom_dir):
  66         rom_dst = os.path.join(rom_dst_dir, os.path.basename(rom_src))
  67         logging.debug("Copying rom file %s to %s", rom_src, rom_dst)
  68         shutil.copy(rom_src, rom_dst)
  69
  70
  71 class KvmInstallException(Exception):
  72     pass
  73
  74
  75 class FailedKvmInstall(KvmInstallException):
  76     pass
  77
  78
  79 class KvmNotInstalled(KvmInstallException):
  80     pass
  81
  82
  83 class BaseInstaller(object):
  84     def __init__(self, mode=None):
  85         self.install_mode = mode
  86         self._full_module_list = None
  87
  88     def set_install_params(self, test, params):
  89         self.params = params
  90
  91         load_modules = params.get('load_modules', 'no')
  92         if not load_modules or load_modules == 'yes':
  93             self.should_load_modules = True
  94         elif load_modules == 'no':
  95             self.should_load_modules = False
  96         default_extra_modules = str(None)
  97         self.extra_modules = eval(params.get("extra_modules",
  98                                              default_extra_modules))
  99
 100         self.cpu_vendor = virt_utils.get_cpu_vendor()
 101
 102         self.srcdir = test.srcdir
 103         if not os.path.isdir(self.srcdir):
 104             os.makedirs(self.srcdir)
 105
 106         self.test_bindir = test.bindir
 107         self.results_dir = test.resultsdir
 108
 109         # KVM build prefix, for the modes that do need it
 110         prefix = os.path.join(test.bindir, 'build')
 111         self.prefix = os.path.abspath(prefix)
 112
 113         # Current host kernel directory
 114         default_host_kernel_source = '/lib/modules/%s/build' % os.uname()[2]
 115         self.host_kernel_srcdir = params.get('host_kernel_source',
 116                                              default_host_kernel_source)
 117
 118         # Extra parameters that can be passed to the configure script
 119         self.extra_configure_options = params.get('extra_configure_options',
 120                                                   None)
 121
 122         # Do we want to save the result of the build on test.resultsdir?
 123         self.save_results = True
 124         save_results = params.get('save_results', 'no')
 125         if save_results == 'no':
 126             self.save_results = False
 127
 128         self._full_module_list = list(self._module_list())
 129
 130
 131     def install_unittests(self):
 132         userspace_srcdir = os.path.join(self.srcdir, "kvm_userspace")
 133         test_repo = self.params.get("test_git_repo")
 134         test_branch = self.params.get("test_branch", "master")
 135         test_commit = self.params.get("test_commit", None)
 136         test_lbranch = self.params.get("test_lbranch", "master")
 137
 138         if test_repo:
 139             test_srcdir = os.path.join(self.srcdir, "kvm-unit-tests")
 140             virt_utils.get_git_branch(test_repo, test_branch, test_srcdir,
 141                                      test_commit, test_lbranch)
 142             unittest_cfg = os.path.join(test_srcdir, 'x86',
 143                                         'unittests.cfg')
 144             self.test_srcdir = test_srcdir
 145         else:
 146             unittest_cfg = os.path.join(userspace_srcdir, 'kvm', 'test', 'x86',
 147                                         'unittests.cfg')
 148         self.unittest_cfg = None
 149         if os.path.isfile(unittest_cfg):
 150             self.unittest_cfg = unittest_cfg
 151         else:
 152             if test_repo:
 153                 logging.error("No unittest config file %s found, skipping "
 154                               "unittest build", self.unittest_cfg)
 155
 156         self.unittest_prefix = None
 157         if self.unittest_cfg:
 158             logging.info("Building and installing unittests")
 159             os.chdir(os.path.dirname(os.path.dirname(self.unittest_cfg)))
 160             utils.system('./configure --prefix=%s' % self.prefix)
 161             utils.system('make')
 162             utils.system('make install')
 163             self.unittest_prefix = os.path.join(self.prefix, 'share', 'qemu',
 164                                                 'tests')
 165
 166
 167     def full_module_list(self):
 168         """Return the module list used by the installer
 169
 170         Used by the module_probe test, to avoid using utils.unload_module().
 171         """
 172         if self._full_module_list is None:
 173             raise KvmNotInstalled("KVM modules not installed yet (installer: %s)" % (type(self)))
 174         return self._full_module_list
 175
 176
 177     def _module_list(self):
 178         """Generate the list of modules that need to be loaded
 179         """
 180         yield 'kvm'
 181         yield 'kvm-%s' % (self.cpu_vendor)
 182         if self.extra_modules:
 183             for module in self.extra_modules:
 184                 yield module
 185
 186
 187     def _load_modules(self, mod_list):
 188         """
 189         Load the KVM modules
 190
 191         May be overridden by subclasses.
 192         """
 193         logging.info("Loading KVM modules")
 194         for module in mod_list:
 195             utils.system("modprobe %s" % module)
 196
 197
 198     def load_modules(self, mod_list=None):
 199         if mod_list is None:
 200             mod_list = self.full_module_list()
 201         self._load_modules(mod_list)
 202
 203
 204     def _unload_modules(self, mod_list=None):
 205         """
 206         Just unload the KVM modules, without trying to kill Qemu
 207         """
 208         if mod_list is None:
 209             mod_list = self.full_module_list()
 210         logging.info("Unloading previously loaded KVM modules")
 211         for module in reversed(mod_list):
 212             utils.unload_module(module)
 213
 214
 215     def unload_modules(self, mod_list=None):
 216         """
 217         Kill Qemu and unload the KVM modules
 218         """
 219         kill_qemu_processes()
 220         self._unload_modules(mod_list)
 221
 222
 223     def reload_modules(self):
 224         """
 225         Reload the KVM modules after killing Qemu and unloading the current modules
 226         """
 227         self.unload_modules()
 228         self.load_modules()
 229
 230
 231     def reload_modules_if_needed(self):
 232         if self.should_load_modules:
 233             self.reload_modules()
 234
 235
 236 class YumInstaller(BaseInstaller):
 237     """
 238     Class that uses yum to install and remove packages.
 239     """
 240     def set_install_params(self, test, params):
 241         super(YumInstaller, self).set_install_params(test, params)
 242         # Checking if all required dependencies are available
 243         os_dep.command("rpm")
 244         os_dep.command("yum")
 245
 246         default_pkg_list = str(['qemu-kvm', 'qemu-kvm-tools'])
 247         default_qemu_bin_paths = str(['/usr/bin/qemu-kvm', '/usr/bin/qemu-img'])
 248         default_pkg_path_list = str(None)
 249         self.pkg_list = eval(params.get("pkg_list", default_pkg_list))
 250         self.pkg_path_list = eval(params.get("pkg_path_list",
 251                                              default_pkg_path_list))
 252         self.qemu_bin_paths = eval(params.get("qemu_bin_paths",
 253                                               default_qemu_bin_paths))
 254
 255
 256     def _clean_previous_installs(self):
 257         kill_qemu_processes()
 258         removable_packages = ""
 259         for pkg in self.pkg_list:
 260             removable_packages += " %s" % pkg
 261
 262         utils.system("yum remove -y %s" % removable_packages)
 263
 264
 265     def _get_packages(self):
 266         for pkg in self.pkg_path_list:
 267             utils.get_file(pkg, os.path.join(self.srcdir,
 268                                              os.path.basename(pkg)))
 269
 270
 271     def _install_packages(self):
 272         """
 273         Install all downloaded packages.
 274         """
 275         os.chdir(self.srcdir)
 276         utils.system("yum install --nogpgcheck -y *.rpm")
 277
 278
 279     def install(self):
 280         self.install_unittests()
 281         self._clean_previous_installs()
 282         self._get_packages()
 283         self._install_packages()
 284         create_symlinks(test_bindir=self.test_bindir,
 285                         bin_list=self.qemu_bin_paths,
 286                         unittest=self.unittest_prefix)
 287         self.reload_modules_if_needed()
 288         if self.save_results:
 289             virt_utils.archive_as_tarball(self.srcdir, self.results_dir)
 290
 291
 292 class KojiInstaller(YumInstaller):
 293     """
 294     Class that handles installing KVM from the fedora build service, koji.
 295
 296     It uses yum to install and remove packages. Packages are specified
 297     according to the syntax defined in the PkgSpec class.
 298     """
 299     def set_install_params(self, test, params):
 300         """
 301         Gets parameters and initializes the package downloader.
 302
 303         @param test: kvm test object
 304         @param params: Dictionary with test arguments
 305         """
 306         super(KojiInstaller, self).set_install_params(test, params)
 307         self.tag = params.get("koji_tag", None)
 308         self.koji_cmd = params.get("koji_cmd", None)
 309         if self.tag is not None:
 310             virt_utils.set_default_koji_tag(self.tag)
 311         self.koji_pkgs = eval(params.get("koji_pkgs", "[]"))
 312
 313
 314     def _get_packages(self):
 315         """
 316         Downloads the specific arch RPMs for the specific build name.
 317         """
 318         koji_client = virt_utils.KojiClient(cmd=self.koji_cmd)
 319         for pkg_text in self.koji_pkgs:
 320             pkg = virt_utils.KojiPkgSpec(pkg_text)
 321             if pkg.is_valid():
 322                 koji_client.get_pkgs(pkg, dst_dir=self.srcdir)
 323             else:
 324                 logging.error('Package specification (%s) is invalid: %s', pkg,
 325                               pkg.describe_invalid())
 326
 327
 328     def _clean_previous_installs(self):
 329         kill_qemu_processes()
 330         removable_packages = " ".join(self._get_rpm_names())
 331         utils.system("yum -y remove %s" % removable_packages)
 332
 333
 334     def install(self):
 335         self._clean_previous_installs()
 336         self._get_packages()
 337         self._install_packages()
 338         self.install_unittests()
 339         create_symlinks(test_bindir=self.test_bindir,
 340                         bin_list=self.qemu_bin_paths,
 341                         unittest=self.unittest_prefix)
 342         self.reload_modules_if_needed()
 343         if self.save_results:
 344             virt_utils.archive_as_tarball(self.srcdir, self.results_dir)
 345
 346
 347     def _get_rpm_names(self):
 348         all_rpm_names = []
 349         koji_client = virt_utils.KojiClient(cmd=self.koji_cmd)
 350         for pkg_text in self.koji_pkgs:
 351             pkg = virt_utils.KojiPkgSpec(pkg_text)
 352             rpm_names = koji_client.get_pkg_rpm_names(pkg)
 353             all_rpm_names += rpm_names
 354         return all_rpm_names
 355
 356
 357     def _get_rpm_file_names(self):
 358         all_rpm_file_names = []
 359         koji_client = virt_utils.KojiClient(cmd=self.koji_cmd)
 360         for pkg_text in self.koji_pkgs:
 361             pkg = virt_utils.KojiPkgSpec(pkg_text)
 362             rpm_file_names = koji_client.get_pkg_rpm_file_names(pkg)
 363             all_rpm_file_names += rpm_file_names
 364         return all_rpm_file_names
 365
 366
 367     def _install_packages(self):
 368         """
 369         Install all downloaded packages.
 370         """
 371         os.chdir(self.srcdir)
 372         rpm_file_names = " ".join(self._get_rpm_file_names())
 373         utils.system("yum --nogpgcheck -y localinstall %s" % rpm_file_names)
 374
 375
 376 class SourceDirInstaller(BaseInstaller):
 377     """
 378     Class that handles building/installing KVM directly from a tarball or
 379     a single source code dir.
 380     """
 381     def set_install_params(self, test, params):
 382         """
 383         Initializes class attributes, and retrieves KVM code.
 384
 385         @param test: kvm test object
 386         @param params: Dictionary with test arguments
 387         """
 388         super(SourceDirInstaller, self).set_install_params(test, params)
 389
 390         self.mod_install_dir = os.path.join(self.prefix, 'modules')
 391
 392         srcdir = params.get("srcdir", None)
 393         self.path_to_roms = params.get("path_to_rom_images", None)
 394
 395         if self.install_mode == 'localsrc':
 396             if srcdir is None:
 397                 raise error.TestError("Install from source directory specified"
 398                                       "but no source directory provided on the"
 399                                       "control file.")
 400             else:
 401                 shutil.copytree(srcdir, self.srcdir)
 402
 403         elif self.install_mode == 'localtar':
 404             tarball = params.get("tarball")
 405             if not tarball:
 406                 raise error.TestError("KVM Tarball install specified but no"
 407                                       " tarball provided on control file.")
 408             logging.info("Installing KVM from a local tarball")
 409             logging.info("Using tarball %s")
 410             tarball = utils.unmap_url("/", params.get("tarball"), "/tmp")
 411             utils.extract_tarball_to_dir(tarball, self.srcdir)
 412
 413         if self.install_mode in ['localtar', 'srcdir']:
 414             self.repo_type = virt_utils.check_kvm_source_dir(self.srcdir)
 415             p = os.path.join(self.srcdir, 'configure')
 416             self.configure_options = virt_installer.check_configure_options(p)
 417
 418
 419     def _build(self):
 420         make_jobs = utils.count_cpus()
 421         os.chdir(self.srcdir)
 422         # For testing purposes, it's better to build qemu binaries with
 423         # debugging symbols, so we can extract more meaningful stack traces.
 424         cfg = "./configure --prefix=%s" % self.prefix
 425         if "--disable-strip" in self.configure_options:
 426             cfg += " --disable-strip"
 427         steps = [cfg, "make clean", "make -j %s" % make_jobs]
 428         logging.info("Building KVM")
 429         for step in steps:
 430             utils.system(step)
 431
 432
 433     def _install(self):
 434         os.chdir(self.srcdir)
 435         logging.info("Installing KVM userspace")
 436         if self.repo_type == 1:
 437             utils.system("make -C qemu install")
 438         elif self.repo_type == 2:
 439             utils.system("make install")
 440         if self.path_to_roms:
 441             install_roms(self.path_to_roms, self.prefix)
 442         self.install_unittests()
 443         create_symlinks(test_bindir=self.test_bindir,
 444                         prefix=self.prefix,
 445                         unittest=self.unittest_prefix)
 446
 447
 448     def install(self):
 449         self._build()
 450         self._install()
 451         self.reload_modules_if_needed()
 452         if self.save_results:
 453             virt_utils.archive_as_tarball(self.srcdir, self.results_dir)
 454
 455 class GitRepo(object):
 456     def __init__(self, installer, prefix,
 457             srcdir, build_steps=[], repo_param=None):
 458         params = installer.params
 459         self.installer = installer
 460         self.repo = params.get(repo_param or (prefix + '_repo'))
 461         self.branch = params.get(prefix + '_branch', 'master')
 462         self.lbranch = params.get(prefix + '_lbranch', 'master')
 463         self.commit = params.get(prefix + '_commit', None)
 464         # The config system yields strings, which have to be evalued
 465         self.patches = eval(params.get(prefix + '_patches', "[]"))
 466         self.build_steps = build_steps
 467         self.srcdir = os.path.join(self.installer.srcdir, srcdir)
 468
 469
 470     def fetch_and_patch(self):
 471         if not self.repo:
 472             return
 473         virt_utils.get_git_branch(self.repo, self.branch, self.srcdir,
 474                                  self.commit, self.lbranch)
 475         os.chdir(self.srcdir)
 476         for patch in self.patches:
 477             utils.get_file(patch, os.path.join(self.srcdir,
 478                                                os.path.basename(patch)))
 479             utils.system('patch -p1 < %s' % os.path.basename(patch))
 480
 481
 482     def build(self):
 483         os.chdir(self.srcdir)
 484         for step in self.build_steps:
 485             logging.info(step)
 486             utils.run(step)
 487
 488
 489 class GitInstaller(SourceDirInstaller):
 490     def _pull_code(self):
 491         """
 492         Retrieves code from git repositories.
 493         """
 494         params = self.params
 495         make_jobs = utils.count_cpus()
 496         cfg = 'PKG_CONFIG_PATH="%s/lib/pkgconfig:%s/share/pkgconfig" ./configure' % (
 497             self.prefix, self.prefix)
 498
 499         self.spice_protocol = GitRepo(installer=self, prefix='spice_protocol',
 500             srcdir='spice-protocol',
 501             build_steps= ['./autogen.sh',
 502                           './configure --prefix=%s' % self.prefix,
 503                           'make clean',
 504                           'make -j %s' % (make_jobs),
 505                           'make install'])
 506
 507         self.spice = GitRepo(installer=self, prefix='spice', srcdir='spice',
 508             build_steps= ['PKG_CONFIG_PATH="%s/lib/pkgconfig:%s/share/pkgconfig" CXXFLAGS=-Wl,--add-needed ./autogen.sh --prefix=%s' % (self.prefix, self.prefix, self.prefix),
 509                           'make clean',
 510                           'make -j %s' % (make_jobs),
 511                           'make install'])
 512
 513         self.userspace = GitRepo(installer=self, prefix='user',
 514             repo_param='user_git_repo', srcdir='kvm_userspace')
 515
 516         p = os.path.join(self.userspace.srcdir, 'configure')
 517         self.configure_options = virt_installer.check_configure_options(p)
 518
 519         cfg = cfg + ' --prefix=%s' % self.prefix
 520         if "--disable-strip" in self.configure_options:
 521             cfg += ' --disable-strip'
 522         if self.extra_configure_options:
 523             cfg += ' %s' % self.extra_configure_options
 524
 525         self.userspace.build_steps=[cfg, 'make clean', 'make -j %s' % make_jobs]
 526
 527         if not self.userspace.repo:
 528             message = "KVM user git repository path not specified"
 529             logging.error(message)
 530             raise error.TestError(message)
 531
 532         for repo in [self.userspace, self.spice_protocol, self.spice]:
 533             if not repo.repo:
 534                 continue
 535             repo.fetch_and_patch()
 536
 537     def _build(self):
 538         if self.spice_protocol.repo:
 539             logging.info('Building Spice-protocol')
 540             self.spice_protocol.build()
 541
 542         if self.spice.repo:
 543             logging.info('Building Spice')
 544             self.spice.build()
 545
 546         logging.info('Building KVM userspace code')
 547         self.userspace.build()
 548
 549
 550     def _install(self):
 551         os.chdir(self.userspace.srcdir)
 552         utils.system('make install')
 553
 554         if self.path_to_roms:
 555             install_roms(self.path_to_roms, self.prefix)
 556         self.install_unittests()
 557         create_symlinks(test_bindir=self.test_bindir, prefix=self.prefix,
 558                         bin_list=None,
 559                         unittest=self.unittest_prefix)
 560
 561
 562     def install(self):
 563         self._pull_code()
 564         self._build()
 565         self._install()
 566         self.reload_modules_if_needed()
 567         if self.save_results:
 568             virt_utils.archive_as_tarball(self.srcdir, self.results_dir)
 569
 570
 571 class PreInstalledKvm(BaseInstaller):
 572     def install(self):
 573         logging.info("Expecting KVM to be already installed. Doing nothing")
 574
 575
 576 class FailedInstaller:
 577     """
 578     Class used to be returned instead of the installer if a installation fails
 579
 580     Useful to make sure no installer object is used if KVM installation fails.
 581     """
 582     def __init__(self, msg="KVM install failed"):
 583         self._msg = msg
 584
 585
 586     def load_modules(self):
 587         """Will refuse to load the KVM modules as install failed"""
 588         raise FailedKvmInstall("KVM modules not available. reason: %s" % (self._msg))
 589
 590
 591 installer_classes = {
 592     'localsrc': SourceDirInstaller,
 593     'localtar': SourceDirInstaller,
 594     'git': GitInstaller,
 595     'yum': YumInstaller,
 596     'koji': KojiInstaller,
 597     'preinstalled': PreInstalledKvm,
 598 }
 599
 600
 601 def _installer_class(install_mode):
 602     c = installer_classes.get(install_mode)
 603     if c is None:
 604         raise error.TestError('Invalid or unsupported'
 605                               ' install mode: %s' % install_mode)
 606     return c
 607
 608
 609 def make_installer(params):
 610     # priority:
 611     # - 'install_mode' param
 612     # - 'mode' param
 613     mode = params.get("install_mode", params.get("mode"))
 614     klass = _installer_class(mode)
 615     return klass(mode)