def _install_phase_download(self):
koji_client = utils_koji.KojiClient(cmd=self.koji_cmd)
for pkg_text in self.koji_pkgs:
pkg = utils_koji.KojiPkgSpec(pkg_text)
if pkg.is_valid():
koji_client.get_pkgs(pkg, dst_dir=self.test_srcdir)
else:
logging.error('Package specification (%s) is invalid: %s' %
(pkg, pkg.describe_invalid()))
for pkg_text in self.koji_scratch_pkgs:
pkg = utils_koji.KojiScratchPkgSpec(pkg_text)
koji_client.get_scratch_pkgs(pkg, dst_dir=self.test_srcdir)
def _get_rpm_file_names(self):
all_rpm_file_names = []
koji_client = utils_koji.KojiClient(cmd=self.koji_cmd)
for pkg_text in self.koji_pkgs:
pkg = utils_koji.KojiPkgSpec(pkg_text)
rpm_file_names = koji_client.get_pkg_rpm_file_names(pkg)
all_rpm_file_names += rpm_file_names
for scratch_pkg_text in self.koji_scratch_pkgs:
pkg = utils_koji.KojiScratchPkgSpec(scratch_pkg_text)
rpm_urls = koji_client.get_scratch_pkg_urls(pkg)
file_names = map(os.path.basename, rpm_urls)
all_rpm_file_names += file_names
return all_rpm_file_names
def _get_rpm_names(self):
all_rpm_names = []
koji_client = utils_koji.KojiClient(cmd=self.koji_cmd)
for pkg_text in self.koji_pkgs:
pkg = utils_koji.KojiPkgSpec(pkg_text)
rpm_names = koji_client.get_pkg_rpm_names(pkg)
all_rpm_names += rpm_names
for scratch_pkg_text in self.koji_scratch_pkgs:
pkg = utils_koji.KojiScratchPkgSpec(scratch_pkg_text)
rpm_urls = koji_client.get_scratch_pkg_urls(pkg)
file_names = map(os.path.basename, rpm_urls)
for f in file_names:
r = utils_koji.RPMFileNameInfo(f)
all_rpm_names.append(r.get_nvr_info()['name'])
return all_rpm_names
def _kernel_install_koji(self,
kernel_koji_spec,
kernel_deps_koji_spec,
need_reboot=True):
# Using hardcoded package names (the names are not expected to change)
# we avoid lookup errors due to SSL problems, so let's go with that.
for koji_package in ['koji', 'brewkoji']:
if not self.sm.check_installed(koji_package):
logging.debug("%s missing - trying to install", koji_package)
self.sm.install(koji_package)
sys.path.append(self.bindir)
import utils_koji
# First, download packages via koji/brew
c = utils_koji.KojiClient()
deps_rpms = []
k_dep = utils_koji.KojiPkgSpec(text=kernel_deps_koji_spec)
logging.info('Fetching kernel dependencies: %s', kernel_deps_koji_spec)
c.get_pkgs(k_dep, self.bindir)
rpm_file_name_list = c.get_pkg_rpm_file_names(k_dep)
if len(rpm_file_name_list) == 0:
raise error.TestError("No packages on brew/koji match spec %s" %
kernel_deps_koji_spec)
dep_rpm_basename = rpm_file_name_list[0]
deps_rpms.append(os.path.join(self.bindir, dep_rpm_basename))
k = utils_koji.KojiPkgSpec(text=kernel_koji_spec)
logging.info('Fetching kernel: %s', kernel_koji_spec)
c.get_pkgs(k, self.bindir)
rpm_file_name_list = c.get_pkg_rpm_file_names(k)
if len(rpm_file_name_list) == 0:
raise error.TestError("No packages on brew/koji match spec %s" %
kernel_koji_spec)
kernel_rpm_basename = rpm_file_name_list[0]
kernel_rpm_path = os.path.join(self.bindir, kernel_rpm_basename)
# Then install kernel rpm packages.
self._kernel_install_rpm(kernel_rpm_path, deps_rpms, need_reboot)
def install_host_kernel(job, params):
"""
Install a host kernel, given the appropriate params.
@param job: Job object.
@param params: Dict with host kernel install params.
"""
install_type = params.get('host_kernel_install_type')
if install_type == 'rpm':
logging.info('Installing host kernel through rpm')
rpm_url = params.get('host_kernel_rpm_url')
k_basename = os.path.basename(rpm_url)
dst = os.path.join("/var/tmp", k_basename)
k = utils.get_file(rpm_url, dst)
host_kernel = job.kernel(k)
host_kernel.install(install_vmlinux=False)
utils.write_keyval(job.resultdir,
{'software_version_kernel': k_basename})
host_kernel.boot()
elif install_type in ['koji', 'brew']:
logging.info('Installing host kernel through koji/brew')
koji_cmd = params.get('host_kernel_koji_cmd')
koji_build = params.get('host_kernel_koji_build')
koji_tag = params.get('host_kernel_koji_tag')
k_deps = utils_koji.KojiPkgSpec(
tag=koji_tag,
build=koji_build,
package='kernel',
subpackages=['kernel-devel', 'kernel-firmware'])
k = utils_koji.KojiPkgSpec(tag=koji_tag,
build=koji_build,
package='kernel',
subpackages=['kernel'])
c = utils_koji.KojiClient(koji_cmd)
logging.info('Fetching kernel dependencies (-devel, -firmware)')
c.get_pkgs(k_deps, job.tmpdir)
logging.info(
'Installing kernel dependencies (-devel, -firmware) '
'through %s', install_type)
k_deps_rpm_file_names = [
os.path.join(job.tmpdir, rpm_file_name)
for rpm_file_name in c.get_pkg_rpm_file_names(k_deps)
]
utils.run('rpm -U --force %s' % " ".join(k_deps_rpm_file_names))
c.get_pkgs(k, job.tmpdir)
k_rpm = os.path.join(job.tmpdir, c.get_pkg_rpm_file_names(k)[0])
host_kernel = job.kernel(k_rpm)
host_kernel.install(install_vmlinux=False)
utils.write_keyval(job.resultdir, {
'software_version_kernel':
" ".join(c.get_pkg_rpm_file_names(k_deps))
})
host_kernel.boot()
elif install_type == 'git':
logging.info('Chose to install host kernel through git, proceeding')
repo = params.get('host_kernel_git_repo')
repo_base = params.get('host_kernel_git_repo_base', None)
branch = params.get('host_kernel_git_branch')
commit = params.get('host_kernel_git_commit')
patch_list = params.get('host_kernel_patch_list')
if patch_list:
patch_list = patch_list.split()
kernel_config = params.get('host_kernel_config', None)
repodir = os.path.join("/tmp", 'kernel_src')
r = git.GitRepoHelper(uri=repo,
branch=branch,
destination_dir=repodir,
commit=commit,
base_uri=repo_base)
r.execute()
host_kernel = job.kernel(r.destination_dir)
if patch_list:
host_kernel.patch(patch_list)
if kernel_config:
host_kernel.config(kernel_config)
host_kernel.build()
host_kernel.install()
git_repo_version = '%s:%s:%s' % (r.uri, r.branch, r.get_top_commit())
utils.write_keyval(job.resultdir,
{'software_version_kernel': git_repo_version})
host_kernel.boot()
else:
logging.info('Chose %s, using the current kernel for the host',
install_type)
k_version = utils.system_output('uname -r', ignore_status=True)
utils.write_keyval(job.resultdir,
{'software_version_kernel': k_version})
