def test_get_package_version_rpm_command(self): remote = Mock() remote.os.package_type = "rpm" packaging.get_package_version(remote, "httpd") args, kwargs = remote.run.call_args expected_args = ['rpm', '-q', 'httpd', '--qf', '%{VERSION}-%{RELEASE}'] assert expected_args == kwargs['args']
def test_get_package_version_deb_command(self): remote = Mock() remote.os.package_type = "deb" packaging.get_package_version(remote, "apache2") args, kwargs = remote.run.call_args expected_args = ['dpkg-query', '-W', '-f', '${Version}', 'apache2'] assert expected_args == kwargs['args']
def test_get_package_version_rpm_command(self): remote = Mock() remote.os.package_type = "rpm" packaging.get_package_version(remote, "httpd") args, kwargs = remote.run.call_args expected_args = ["rpm", "-q", "httpd", "--qf", "%{VERSION}"] assert expected_args == kwargs["args"]
def test_get_package_version_deb_command(self): remote = Mock() remote.os.package_type = "deb" packaging.get_package_version(remote, "apache2") args, kwargs = remote.run.call_args expected_args = ["dpkg-query", "-W", "-f", "${Version}", "apache2"] assert expected_args == kwargs["args"]
def install_pkgs(ctx, remote, version, downstream_config): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object :param downstream_config the dict object that has downstream pkg info """ rh_version_check = downstream_config.get('versions').get('rpm').get('mapped') rh_rpm_pkgs = downstream_config.get('pkgs').get('rpm') pkgs = str.join(' ', rh_rpm_pkgs) log.info("Remove any epel packages installed on node %s", remote.shortname) # below packages can come from epel and still work, ensure we use cdn pkgs remote.run( args=[ 'sudo', 'yum', 'remove', run.Raw("leveldb xmlstarlet fcgi"), '-y'], check_status=False) log.info("Installing redhat ceph packages") remote.run(args=['sudo', 'yum', '-y', 'install', run.Raw(pkgs)]) # check package version installed_version = packaging.get_package_version(remote, 'ceph-common') log.info( "Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) req_ver = rh_version_check[version] if installed_version.startswith(req_ver): log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def install_deb_pkgs( ctx, remote, version, downstream_config, deb_repo, deb_gpg_key): """ Setup debian repo, Install gpg key and Install on debian packages : param ctx : param remote : param downstream_config the dict object that has downstream pkg info : deb_repo - http path of downstream ubuntu repo : deb_gpg_key - gpg key for the ubuntu pkg """ set_deb_repo(remote, deb_repo, deb_gpg_key) rh_version_check = downstream_config.get('versions').get('deb').get('mapped') rh_deb_pkgs = downstream_config.get('pkgs').get('deb') pkgs = str.join(' ', rh_deb_pkgs) log.info("Installing redhat ceph packages") remote.run(args=['sudo', 'apt-get', '-y', 'install', run.Raw(pkgs)]) # check package version installed_version = packaging.get_package_version(remote, 'ceph-common') log.info( "Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) req_ver = rh_version_check[version] if installed_version.startswith(req_ver): log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def upgrade_common(ctx, config, deploy_style): """ Common code for upgrading """ remotes = upgrade_remote_to_config(ctx, config) project = config.get('project', 'ceph') # FIXME: extra_pkgs is not distro-agnostic extra_pkgs = config.get('extra_packages', []) log.info('extra packages: {packages}'.format(packages=extra_pkgs)) for remote, node in remotes.iteritems(): system_type = teuthology.get_system_type(remote) assert system_type in ('deb', 'rpm') pkgs = get_package_list(ctx, config)[system_type] log.info("Upgrading {proj} {system_type} packages: {pkgs}".format( proj=project, system_type=system_type, pkgs=', '.join(pkgs))) # FIXME: again, make extra_pkgs distro-agnostic pkgs += extra_pkgs installed_version = packaging.get_package_version( remote, 'ceph-common') upgrade_version = get_upgrade_version(ctx, node, remote) log.info("Ceph {s} upgrade from {i} to {u}".format(s=system_type, i=installed_version, u=upgrade_version)) if _upgrade_is_downgrade(installed_version, upgrade_version): raise RuntimeError( "An attempt to upgrade from a higher version to a lower one " "will always fail. Hint: check tags in the target git branch.") deploy_style(ctx, node, remote, pkgs, system_type) verify_package_version(ctx, node, remote) return len(remotes)
def _downgrade_packages(ctx, remote, pkgs, pkg_version, config): """ Downgrade packages listed by 'downgrade_packages' Downgrade specified packages to given version. The list of packages downgrade is provided by 'downgrade_packages' as a property of "install" task. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object :param pkgs: list of package names to install :param pkg_version: the version to which all packages will be downgraded :param config: the config dict :return: list of package names from 'pkgs' which are not yet installed/downgraded """ downgrade_pkgs = config.get('downgrade_packages', []) if not downgrade_pkgs: return pkgs log.info('Downgrading packages: {pkglist}'.format( pkglist=', '.join(downgrade_pkgs))) # assuming we are going to downgrade packages with the same version first_pkg = downgrade_pkgs[0] installed_version = packaging.get_package_version(remote, first_pkg) assert installed_version, "failed to get version of {}".format(first_pkg) assert LooseVersion(installed_version) > LooseVersion(pkg_version) # to compose package name like "librados2-0.94.10-87.g116a558.el7" pkgs_opt = ['-'.join([pkg, pkg_version]) for pkg in downgrade_pkgs] remote.run(args='sudo yum -y downgrade {}'.format(' '.join(pkgs_opt))) return [pkg for pkg in pkgs if pkg not in downgrade_pkgs]
def install_deb_pkgs(ctx, remote, version, downstream_config): """ Setup debian repo, Install gpg key and Install on debian packages : param ctx : param remote : param downstream_config the dict object that has downstream pkg info """ rh_version_check = downstream_config.get('versions').get('deb').get( 'mapped') rh_deb_pkgs = downstream_config.get('pkgs').get('deb') extras = [ downstream_config.get('extra_system_packages'), downstream_config.get('extra_packages') ] for extra in extras: if isinstance(extra, dict): rh_deb_pkgs += extra.get('deb', []) elif isinstance(extra, list): rh_deb_pkgs += extra pkgs = str.join(' ', rh_deb_pkgs) log.info("Installing redhat ceph packages") remote.run(args=['sudo', 'apt-get', '-y', 'install', run.Raw(pkgs)]) # check package version installed_version = packaging.get_package_version(remote, 'ceph-common') log.info("Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) req_ver = rh_version_check[version] if installed_version.startswith(req_ver): log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def verify_package_version(ctx, config, remote): """ Ensures that the version of package installed is what was asked for in the config. For most cases this is for ceph, but we also install samba for example. """ # Do not verify the version if the ceph-deploy task is being used to # install ceph. Verifying the ceph installed by ceph-deploy should work, # but the qa suites will need reorganized first to run ceph-deploy # before the install task. # see: http://tracker.ceph.com/issues/11248 if config.get("extras"): log.info("Skipping version verification...") return True if 'repos' in config and config.get('repos'): log.info( "Skipping version verification because we have custom repos...") return True builder = _get_builder_project(ctx, remote, config) version = builder.version pkg_to_check = builder.project installed_ver = packaging.get_package_version(remote, pkg_to_check) if installed_ver and version in installed_ver: msg = "The correct {pkg} version {ver} is installed.".format( ver=version, pkg=pkg_to_check) log.info(msg) else: raise RuntimeError( "{pkg} version {ver} was not installed, found {installed}.".format( ver=version, installed=installed_ver, pkg=pkg_to_check))
def install_pkgs(ctx, remote, version, downstream_config): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object :param downstream_config the dict object that has downstream pkg info """ rh_version_check = downstream_config.get('versions').get('rpm').get( 'mapped') rh_rpm_pkgs = downstream_config.get('pkgs').get('rpm') pkgs = str.join(' ', rh_rpm_pkgs) log.info("Remove any epel packages installed on node %s", remote.shortname) # below packages can come from epel and still work, ensure we use cdn pkgs remote.run(args=[ 'sudo', 'yum', 'remove', run.Raw("leveldb xmlstarlet fcgi"), '-y' ], check_status=False) log.info("Installing redhat ceph packages") remote.run(args=['sudo', 'yum', '-y', 'install', run.Raw(pkgs)]) # check package version installed_version = packaging.get_package_version(remote, 'ceph-common') log.info("Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) req_ver = rh_version_check[version] if installed_version.startswith(req_ver): log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def rh_install_pkgs(ctx, remote, installed_version): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object """ pkgs = ['ceph-deploy'] # install ceph-selinux for 1.3.2 as its not dependency of any core packages if (installed_version == '1.3.2'): pkgs.append('ceph-selinux') # install ceph-fuse for 2.0 as its not dependency of any core packages if (installed_version == '2.0'): pkgs.append('ceph-fuse') rh_version_check = {'0.94.1': '1.3.0', '0.94.3': '1.3.1', '0.94.5': '1.3.2', '10.1.0': '2.0'} log.info("Remove any epel packages installed on node %s", remote.shortname) remote.run(args=['sudo', 'yum', 'remove', run.Raw("leveldb xmlstarlet fcgi"), '-y'],check_status=False) for pkg in pkgs: log.info("Check if %s is already installed on node %s", pkg, remote.shortname) remote.run(args=['sudo', 'yum', 'clean', 'metadata']) r = remote.run( args=['yum', 'list', 'installed', run.Raw(pkg)], stdout=StringIO(), check_status=False, ) if r.stdout.getvalue().find(pkg) == -1: log.info("Installing %s " % pkg) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) else: log.info("Removing and reinstalling %s on %s", pkg, remote.shortname) remote.run(args=['sudo', 'yum', 'remove', pkg, '-y']) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) log.info("Check if ceph is already installed on %s", remote.shortname) r = remote.run( args=['yum', 'list', 'installed','ceph'], stdout=StringIO(), check_status=False, ) host = r.hostname if r.stdout.getvalue().find('ceph') == -1: log.info("Install ceph using ceph-deploy on %s", remote.shortname) remote.run(args=['sudo', 'ceph-deploy', 'install', run.Raw('--no-adjust-repos'), host]) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) else: log.info("Removing and reinstalling Ceph on %s", remote.shortname) remote.run(args=['sudo', 'ceph-deploy', 'uninstall', host]) remote.run(args=['sudo', 'ceph-deploy', 'purgedata', host]) remote.run(args=['sudo', 'ceph-deploy', 'install', host]) remote.run(args=['sudo', 'yum', 'remove', 'ceph-test', '-y']) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) # check package version version = packaging.get_package_version(remote, 'ceph-common') log.info("Node: {n} Ceph version installed is {v}".format(n=remote.shortname,v=version)) if rh_version_check[version] == installed_version: log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def verify_package_version(ctx, config, remote): """ Ensures that the version of package installed is what was asked for in the config. For most cases this is for ceph, but we also install samba for example. """ # Do not verify the version if the ceph-deploy task is being used to # install ceph. Verifying the ceph installed by ceph-deploy should work, # but the qa suites will need reorganized first to run ceph-deploy # before the install task. # see: http://tracker.ceph.com/issues/11248 if config.get("extras"): log.info("Skipping version verification...") return True gitbuilder = _get_gitbuilder_project(ctx, remote, config) version = gitbuilder.version pkg_to_check = gitbuilder.project installed_ver = packaging.get_package_version(remote, pkg_to_check) if installed_ver and version in installed_ver: msg = "The correct {pkg} version {ver} is installed.".format(ver=version, pkg=pkg_to_check) log.info(msg) else: raise RuntimeError( "{pkg} version {ver} was not installed, found {installed}.".format( ver=version, installed=installed_ver, pkg=pkg_to_check ) )
def install_deb_pkgs(ctx, remote, version, downstream_config, deb_repo, deb_gpg_key): """ Setup debian repo, Install gpg key and Install on debian packages : param ctx : param remote : param downstream_config the dict object that has downstream pkg info : deb_repo - http path of downstream ubuntu repo : deb_gpg_key - gpg key for the ubuntu pkg """ set_deb_repo(remote, deb_repo, deb_gpg_key) rh_version_check = downstream_config.get('versions').get('deb').get( 'mapped') rh_deb_pkgs = downstream_config.get('pkgs').get('deb') pkgs = str.join(' ', rh_deb_pkgs) log.info("Installing redhat ceph packages") remote.run(args=['sudo', 'apt-get', '-y', 'install', run.Raw(pkgs)]) # check package version installed_version = packaging.get_package_version(remote, 'ceph-common') log.info("Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) req_ver = rh_version_check[version] if installed_version.startswith(req_ver): log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def rh_install_pkgs(ctx, remote, installed_version): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object """ pkgs = ['ceph-deploy'] rh_version_check = {'0.94.1': '1.3.0'} for pkg in pkgs: log.info("Check if ceph-deploy is already installed on node %s", remote.shortname) remote.run(args=['sudo', 'yum', 'clean', 'metadata']) r = remote.run( args=['yum', 'list', 'installed', run.Raw(pkg)], stdout=StringIO(), check_status=False, ) if r.stdout.getvalue().find(pkg) == -1: log.info("Installing %s " % pkg) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) else: log.info("Removing and reinstalling ceph-deploy on %s", remote.shortname) remote.run(args=['sudo', 'yum', 'remove', pkg, '-y']) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) log.info("Check if ceph is already installed on %s", remote.shortname) r = remote.run( args=['yum', 'list', 'installed', 'ceph'], stdout=StringIO(), check_status=False, ) host = r.hostname if r.stdout.getvalue().find('ceph') == -1: log.info("Install ceph using ceph-deploy on %s", remote.shortname) remote.run(args=[ 'sudo', 'ceph-deploy', 'install', run.Raw('--no-adjust-repos'), host ]) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) else: log.info("Removing and reinstalling Ceph on %s", remote.shortname) remote.run(args=['sudo', 'ceph-deploy', 'uninstall', host]) remote.run(args=['sudo', 'ceph-deploy', 'purgedata', host]) remote.run(args=['sudo', 'ceph-deploy', 'install', host]) remote.run(args=['sudo', 'yum', 'remove', 'ceph-test', '-y']) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) # check package version version = packaging.get_package_version(remote, 'ceph') log.info("Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) if rh_version_check[version] == installed_version: log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def test_get_package_version_not_found(self): remote = Mock() remote.os.package_type = "rpm" proc = Mock() proc.exitstatus = 1 proc.stdout.getvalue.return_value = "not installed" remote.run.return_value = proc result = packaging.get_package_version(remote, "httpd") assert result is None
def test_get_package_version_rpm_found(self): remote = Mock() remote.os.package_type = "rpm" proc = Mock() proc.exitstatus = 0 proc.stdout.getvalue.return_value = "2.2" remote.run.return_value = proc result = packaging.get_package_version(remote, "httpd") assert result == "2.2"
def install_python3(ctx, config): assert isinstance(config, dict) log.info('Installing Python3 for Tempest') installed = [] for (client, _) in config.items(): (remote,) = ctx.cluster.only(client).remotes.keys() try: packaging.get_package_version(remote, 'python3') except: packaging.install_package('python3', remote) installed.append(client) try: yield finally: log.info('Removing Python3 required by Tempest...') for client in installed: (remote,) = ctx.cluster.only(client).remotes.keys() packaging.remove_package('python3', remote)
def test_filelock(self): """ Check that file lock doesn't get lost after an MDS restart """ a_version_str = get_package_version(self.mount_a.client_remote, "fuse") b_version_str = get_package_version(self.mount_b.client_remote, "fuse") flock_version_str = "2.9" version_regex = re.compile(r"[0-9\.]+") a_result = version_regex.match(a_version_str) self.assertTrue(a_result) b_result = version_regex.match(b_version_str) self.assertTrue(b_result) a_version = version.StrictVersion(a_result.group()) b_version = version.StrictVersion(b_result.group()) flock_version = version.StrictVersion(flock_version_str) flockable = False if (a_version >= flock_version and b_version >= flock_version): log.info("testing flock locks") flockable = True else: log.info( "not testing flock locks, machines have versions {av} and {bv}" .format(av=a_version_str, bv=b_version_str)) lock_holder = self.mount_a.lock_background(do_flock=flockable) self.mount_b.wait_for_visible("background_file-2") self.mount_b.check_filelock(do_flock=flockable) self.fs.mds_fail_restart() self.fs.wait_for_state('up:active', timeout=MDS_RESTART_GRACE) self.mount_b.check_filelock(do_flock=flockable) # Tear down the background process lock_holder.stdin.close() try: lock_holder.wait() except (CommandFailedError, ConnectionLostError): # We killed it, so it raises an error pass
def test_filelock(self): """ Check that file lock doesn't get lost after an MDS restart """ a_version_str = get_package_version(self.mount_a.client_remote, "fuse") b_version_str = get_package_version(self.mount_b.client_remote, "fuse") flock_version_str = "2.9" version_regex = re.compile(r"[0-9\.]+") a_result = version_regex.match(a_version_str) self.assertTrue(a_result) b_result = version_regex.match(b_version_str) self.assertTrue(b_result) a_version = version.StrictVersion(a_result.group()) b_version = version.StrictVersion(b_result.group()) flock_version=version.StrictVersion(flock_version_str) flockable = False if (a_version >= flock_version and b_version >= flock_version): log.info("testing flock locks") flockable = True else: log.info("not testing flock locks, machines have versions {av} and {bv}".format( av=a_version_str,bv=b_version_str)) lock_holder = self.mount_a.lock_background(do_flock=flockable) self.mount_b.wait_for_visible("background_file-2") self.mount_b.check_filelock(do_flock=flockable) self.fs.mds_fail_restart() self.fs.wait_for_state('up:active', timeout=MDS_RESTART_GRACE) self.mount_b.check_filelock(do_flock=flockable) # Tear down the background process lock_holder.stdin.close() try: lock_holder.wait() except (CommandFailedError, ConnectionLostError): # We killed it, so it raises an error pass
def test_get_package_version_invalid_version(self): # this tests the possibility that the package is not found # but the exitstatus is still 0. Not entirely sure we'll ever # hit this condition, but I want to test the codepath regardless remote = Mock() remote.os.package_type = "rpm" proc = Mock() proc.exitstatus = 0 proc.stdout.getvalue.return_value = "not installed" remote.run.return_value = proc result = packaging.get_package_version(remote, "httpd") assert result is None
def _is_flockable(self): a_version_str = get_package_version(self.mount_a.client_remote, "fuse") b_version_str = get_package_version(self.mount_b.client_remote, "fuse") flock_version_str = "2.9" version_regex = re.compile(r"[0-9\.]+") a_result = version_regex.match(a_version_str) self.assertTrue(a_result) b_result = version_regex.match(b_version_str) self.assertTrue(b_result) a_version = version.StrictVersion(a_result.group()) b_version = version.StrictVersion(b_result.group()) flock_version=version.StrictVersion(flock_version_str) if (a_version >= flock_version and b_version >= flock_version): log.info("flock locks are available") return True else: log.info("not testing flock locks, machines have versions {av} and {bv}".format( av=a_version_str,bv=b_version_str)) return False
def rh_install_pkgs(ctx, remote, installed_version): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object """ pkgs = ['ceph-deploy'] rh_version_check = {'0.94.1': '1.3.0', '0.94.3': '1.3.1'} for pkg in pkgs: log.info("Check if ceph-deploy is already installed on node %s", remote.shortname) remote.run(args=['sudo', 'yum', 'clean', 'metadata']) r = remote.run( args=['yum', 'list', 'installed', run.Raw(pkg)], stdout=StringIO(), check_status=False, ) if r.stdout.getvalue().find(pkg) == -1: log.info("Installing %s " % pkg) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) else: log.info("Removing and reinstalling ceph-deploy on %s", remote.shortname) remote.run(args=['sudo', 'yum', 'remove', pkg, '-y']) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) log.info("Check if ceph is already installed on %s", remote.shortname) r = remote.run( args=['yum', 'list', 'installed','ceph'], stdout=StringIO(), check_status=False, ) host = r.hostname if r.stdout.getvalue().find('ceph') == -1: log.info("Install ceph using ceph-deploy on %s", remote.shortname) remote.run(args=['sudo', 'ceph-deploy', 'install', run.Raw('--no-adjust-repos'), host]) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) else: log.info("Removing and reinstalling Ceph on %s", remote.shortname) remote.run(args=['sudo', 'ceph-deploy', 'uninstall', host]) remote.run(args=['sudo', 'ceph-deploy', 'purgedata', host]) remote.run(args=['sudo', 'ceph-deploy', 'install', host]) remote.run(args=['sudo', 'yum', 'remove', 'ceph-test', '-y']) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) # check package version version = packaging.get_package_version(remote, 'ceph') log.info("Node: {n} Ceph version installed is {v}".format(n=remote.shortname,v=version)) if rh_version_check[version] == installed_version: log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def install_dnsmasq(remote): """ If dnsmasq is not installed, install it for the duration of the task. """ try: existing = packaging.get_package_version(remote, 'dnsmasq') except: existing = None if existing is None: packaging.install_package('dnsmasq', remote) try: yield finally: if existing is None: packaging.remove_package('dnsmasq', remote)
def rh_install_pkgs(ctx, remote, installed_version): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object """ pkgs = ["ceph-deploy"] rh_version_check = {"0.94.1": "1.3.0", "0.94.2": "1.3.1"} for pkg in pkgs: log.info("Check if ceph-deploy is already installed on node %s", remote.shortname) remote.run(args=["sudo", "yum", "clean", "metadata"]) r = remote.run(args=["yum", "list", "installed", run.Raw(pkg)], stdout=StringIO(), check_status=False) if r.stdout.getvalue().find(pkg) == -1: log.info("Installing %s " % pkg) remote.run(args=["sudo", "yum", "install", pkg, "-y"]) else: log.info("Removing and reinstalling ceph-deploy on %s", remote.shortname) remote.run(args=["sudo", "yum", "remove", pkg, "-y"]) remote.run(args=["sudo", "yum", "install", pkg, "-y"]) log.info("Check if ceph is already installed on %s", remote.shortname) r = remote.run(args=["yum", "list", "installed", "ceph"], stdout=StringIO(), check_status=False) host = r.hostname if r.stdout.getvalue().find("ceph") == -1: log.info("Install ceph using ceph-deploy on %s", remote.shortname) remote.run(args=["sudo", "ceph-deploy", "install", run.Raw("--no-adjust-repos"), host]) remote.run(args=["sudo", "yum", "install", "ceph-test", "-y"]) else: log.info("Removing and reinstalling Ceph on %s", remote.shortname) remote.run(args=["sudo", "ceph-deploy", "uninstall", host]) remote.run(args=["sudo", "ceph-deploy", "purgedata", host]) remote.run(args=["sudo", "ceph-deploy", "install", host]) remote.run(args=["sudo", "yum", "remove", "ceph-test", "-y"]) remote.run(args=["sudo", "yum", "install", "ceph-test", "-y"]) # check package version version = packaging.get_package_version(remote, "ceph") log.info("Node: {n} Ceph version installed is {v}".format(n=remote.shortname, v=version)) if rh_version_check[version] == installed_version: log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)
def upgrade_common(ctx, config, deploy_style): """ Common code for upgrading """ remotes = upgrade_remote_to_config(ctx, config) project = config.get('project', 'ceph') extra_pkgs = config.get('extra_packages', []) log.info('extra packages: {packages}'.format(packages=extra_pkgs)) for remote, node in remotes.iteritems(): system_type = teuthology.get_system_type(remote) assert system_type in ('deb', 'rpm') pkgs = get_package_list(ctx, config)[system_type] log.info("Upgrading {proj} {system_type} packages: {pkgs}".format( proj=project, system_type=system_type, pkgs=', '.join(pkgs))) if isinstance(extra_pkgs, dict): pkgs += extra_pkgs.get(system_type, []) else: pkgs += extra_pkgs installed_version = packaging.get_package_version(remote, 'ceph-common') upgrade_version = get_upgrade_version(ctx, node, remote) log.info("Ceph {s} upgrade from {i} to {u}".format( s=system_type, i=installed_version, u=upgrade_version )) if _upgrade_is_downgrade(installed_version, upgrade_version): raise RuntimeError( "An attempt to upgrade from a higher version to a lower one " "will always fail. Hint: check tags in the target git branch." ) deploy_style(ctx, node, remote, pkgs, system_type) verify_package_version(ctx, node, remote) return len(remotes)
def rh_install_pkgs(ctx, remote, installed_version): """ Installs RH build using ceph-deploy. :param ctx: the argparse.Namespace object :param remote: the teuthology.orchestra.remote.Remote object """ pkgs = ['ceph-deploy'] # install ceph-selinux for 1.3.2 as its not dependency of any core packages if (installed_version == '1.3.2'): pkgs.append('ceph-selinux') # install ceph-fuse for 2.0 as its not dependency of any core packages if (installed_version == '2.0'): pkgs.append('ceph-fuse') rh_version_check = { '0.94.1': '1.3.0', '0.94.3': '1.3.1', '0.94.5': '1.3.2', '10.1.0': '2.0' } log.info("Remove any epel packages installed on node %s", remote.shortname) remote.run(args=[ 'sudo', 'yum', 'remove', run.Raw("leveldb xmlstarlet fcgi"), '-y' ], check_status=False) for pkg in pkgs: log.info("Check if %s is already installed on node %s", pkg, remote.shortname) remote.run(args=['sudo', 'yum', 'clean', 'metadata']) r = remote.run( args=['yum', 'list', 'installed', run.Raw(pkg)], stdout=StringIO(), check_status=False, ) if r.stdout.getvalue().find(pkg) == -1: log.info("Installing %s " % pkg) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) else: log.info("Removing and reinstalling %s on %s", pkg, remote.shortname) remote.run(args=['sudo', 'yum', 'remove', pkg, '-y']) remote.run(args=['sudo', 'yum', 'install', pkg, '-y']) log.info("Check if ceph is already installed on %s", remote.shortname) r = remote.run( args=['yum', 'list', 'installed', 'ceph'], stdout=StringIO(), check_status=False, ) host = r.hostname if r.stdout.getvalue().find('ceph') == -1: log.info("Install ceph using ceph-deploy on %s", remote.shortname) remote.run(args=[ 'sudo', 'ceph-deploy', 'install', run.Raw('--no-adjust-repos'), host ]) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) else: log.info("Removing and reinstalling Ceph on %s", remote.shortname) remote.run(args=['sudo', 'ceph-deploy', 'uninstall', host]) remote.run(args=['sudo', 'ceph-deploy', 'purgedata', host]) remote.run(args=['sudo', 'ceph-deploy', 'install', host]) remote.run(args=['sudo', 'yum', 'remove', 'ceph-test', '-y']) remote.run(args=['sudo', 'yum', 'install', 'ceph-test', '-y']) # check package version version = packaging.get_package_version(remote, 'ceph-common') log.info("Node: {n} Ceph version installed is {v}".format( n=remote.shortname, v=version)) if rh_version_check[version] == installed_version: log.info("Installed version matches on %s", remote.shortname) else: raise RuntimeError("Version check failed on node %s", remote.shortname)