task.kernel: Support fetching kernels from Shaman

Signed-off-by: Zack Cerza <zack@redhat.com>

diff --git a/teuthology/task/kernel.py b/teuthology/task/kernel.py
index 63f4608e37974c8ed490caa6a4ee904d8b6611a0..9bfc775f8417878223376ec383c1749042eb9043 100644 (file)
--- a/teuthology/task/kernel.py
+++ b/teuthology/task/kernel.py
@@ -7,13 +7,16 @@ import logging
 import os
 import re
 import shlex
+import urlparse
 
 from teuthology import misc as teuthology
+from teuthology.config import config as teuth_config
 from ..orchestra import run
-from ..config import config as teuth_config
-from ..exceptions import (UnsupportedPackageTypeError,
-                          ConfigError,
-                          VersionNotFoundError)
+from ..exceptions import (
+    UnsupportedPackageTypeError,
+    ConfigError,
+    VersionNotFoundError,
+)
 from ..packaging import (
     install_package,
     get_koji_build_info,
@@ -21,7 +24,7 @@ from ..packaging import (
     get_koji_package_name,
     get_koji_task_rpm_info,
     get_koji_task_result,
-    GitbuilderProject,
+    get_builder_project,
 )
 
 log = logging.getLogger(__name__)
@@ -31,6 +34,7 @@ TIMEOUT_DEFAULT = 300
 
 VERSION_KEYS = ['branch', 'tag', 'sha1', 'deb', 'rpm', 'koji', 'koji_task']
 
+
 def normalize_config(ctx, config):
     """
     Returns a config whose keys are all real roles.
@@ -94,6 +98,7 @@ def normalize_config(ctx, config):
                     new_config[name] = role_config.copy()
     return new_config
 
+
 def normalize_and_apply_overrides(ctx, config, overrides):
     """
     kernel task config is hierarchical and needs to be transformed into
@@ -132,6 +137,7 @@ def normalize_and_apply_overrides(ctx, config, overrides):
 
     return (config, timeout)
 
+
 def validate_config(ctx, config):
     """
     Make sure that all kernels in the list of remove kernels
@@ -164,6 +170,7 @@ def _vsplitter(version):
         return 'ceph-'
     return '-g'
 
+
 def need_to_install(ctx, role, version):
     """
     Check to see if we need to install a kernel.  Get the version of the
@@ -216,6 +223,7 @@ def need_to_install(ctx, role, version):
     uname_fp.close()
     return ret
 
+
 def install_firmware(ctx, config):
     """
     Go to the github to get the latest firmware.
@@ -284,6 +292,7 @@ def install_firmware(ctx, config):
                 ],
             )
 
+
 def gitbuilder_pkg_name(remote):
     if remote.os.package_type == 'rpm':
         pkg_name = 'kernel.x86_64.rpm'
@@ -293,6 +302,7 @@ def gitbuilder_pkg_name(remote):
         raise UnsupportedPackageTypeError(remote)
     return pkg_name
 
+
 def remote_pkg_path(remote):
     """
     This is where kernel packages are copied over (in case of local
@@ -301,6 +311,7 @@ def remote_pkg_path(remote):
     """
     return os.path.join('/tmp', gitbuilder_pkg_name(remote))
 
+
 def download_kernel(ctx, config):
     """
     Supply each remote with a kernel package:
@@ -366,17 +377,42 @@ def download_kernel(ctx, config):
             ))
             needs_download = True
 
-            gitbuilder = GitbuilderProject(
+            builder = get_builder_project()(
                 'kernel',
                 {'sha1': src},
                 ctx=ctx,
                 remote=role_remote,
             )
-            baseurl = gitbuilder.base_url + "/"
-
-            pkg_name = gitbuilder_pkg_name(role_remote)
+            if teuth_config.use_shaman:
+                if role_remote.os.package_type == 'rpm':
+                    arch = builder.arch
+                    baseurl = urlparse.urljoin(
+                        builder.base_url,
+                        '/'.join([arch, ''])
+                    )
+                    pkg_name = "kernel-%s.%s.rpm" % (
+                        builder.version,
+                        arch,
+                    )
+                elif role_remote.os.package_type == 'deb':
+                    arch = 'amd64'  # FIXME
+                    baseurl = urlparse.urljoin(
+                        builder.base_url,
+                        '/'.join([
+                            'pool', 'main', 'l',
+                            'linux-%s' % builder.scm_version, ''
+                        ])
+                    )
+                    pkg_name = 'linux-image-%s_%s_%s.deb' % (
+                        builder.scm_version,
+                        builder.version,
+                        arch,
+                    )
+            else:
+                baseurl = builder.base_url + "/"
+                pkg_name = gitbuilder_pkg_name(role_remote)
 
-            log.info("fetching, gitbuilder baseurl is %s", baseurl)
+            log.info("fetching, builder baseurl is %s", baseurl)
 
         if needs_download:
             proc = role_remote.run(
@@ -421,6 +457,7 @@ def _no_grub_link(in_file, remote, kernel_ver):
         args=['sudo', 'ln', '-s', '%s-%s' % (in_file, kernel_ver) , boot1, ],
     )
 
+
 def install_and_reboot(ctx, config):
     """
     Install and reboot the kernel.  This mostly performs remote
@@ -572,6 +609,7 @@ def install_and_reboot(ctx, config):
         log.debug('Waiting for install on %s to complete...', name)
         proc.wait()
 
+
 def enable_disable_kdb(ctx, config):
     """
     Enable kdb on remote machines in use.  Disable on those that are
@@ -807,6 +845,7 @@ def install_kernel(remote, path=None, version=None):
             remote.run( args=['sudo', 'shutdown', '-r', 'now'], wait=False )
             return
 
+
 def update_grub_rpm(remote, newversion):
     """
     Updates grub file to boot new kernel version on both legacy grub/grub2.
@@ -856,6 +895,7 @@ def grub2_kernel_select_generic(remote, newversion, ostype):
             entry_num += 1
     remote.run(args=['sudo', grubset, str(entry_num), ])
 
+
 def generate_legacy_grub_entry(remote, newversion):
     """
     This will likely need to be used for ceph kernels as well
@@ -912,6 +952,7 @@ def generate_legacy_grub_entry(remote, newversion):
         linenum += 1
     return newgrubconf
 
+
 def get_image_version(remote, path):
     """
     Get kernel image version from (rpm or deb) package.
@@ -1216,23 +1257,23 @@ def task(ctx, config):
                 need_install[role] = build_info
                 need_version[role] = version
         else:
-            gitbuilder = GitbuilderProject(
+            builder = get_builder_project()(
                 "kernel",
                 role_config,
                 ctx=ctx,
                 remote=role_remote,
             )
-            sha1 = gitbuilder.sha1
+            sha1 = builder.sha1
             log.debug('sha1 for {role} is {sha1}'.format(role=role, sha1=sha1))
             ctx.summary['{role}-kernel-sha1'.format(role=role)] = sha1
 
             if need_to_install(ctx, role, sha1):
-                version = gitbuilder.version
-
+                if teuth_config.use_shaman:
+                    version = builder.scm_version
+                else:
+                    version = builder.version
                 if not version:
-                    raise VersionNotFoundError("{url} is empty!".format(
-                        url=gitbuilder.base_url + "/version"))
-
+                    raise VersionNotFoundError(builder.base_url)
                 need_install[role] = sha1
                 need_version[role] = version