teuthology 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

teuthology/task/install/deb.py

@@ -142,7 +142,7 @@ def _remove(ctx, config, remote, debs):
             run.Raw('|'),
             # Any package that is unpacked or half-installed and also requires
             # reinstallation
-            'grep', '^.\(U\|H\)R',
+            'grep', r'^.\(U\|H\)R',
             run.Raw('|'),
             'awk', '{print $2}',
             run.Raw('|'),

teuthology/task/install/rpm.py

@@ -145,16 +145,19 @@ def _downgrade_packages(ctx, remote, pkgs, pkg_version, config):
     remote.run(args='sudo yum -y downgrade {}'.format(' '.join(pkgs_opt)))
     return [pkg for pkg in pkgs if pkg not in downgrade_pkgs]
 
-def _retry_if_503_in_output(remote, args):
+def _retry_if_failures_are_recoverable(remote, args):
     # wait at most 5 minutes
     with safe_while(sleep=10, tries=30) as proceed:
         while proceed():
             stdout = StringIO()
+            stderr = StringIO()
             try:
-                return remote.run(args=args, stdout=stdout)
+                return remote.run(args=args, stderr=stderr, stdout=stdout)
             except run.CommandFailedError:
                 if "status code: 503" in stdout.getvalue().lower():
                     continue
+                if "failed to download metadata for repo" in stderr.getvalue().lower():
+                    continue
                 else:
                     raise
 
@@ -170,6 +173,13 @@ def _update_package_list_and_install(ctx, remote, rpm, config):
     :param rpm: list of packages names to install
     :param config: the config dict
     """
+
+    enable_coprs = config.get('enable_coprs', [])
+    if len(enable_coprs):
+        remote.run(args=['sudo', 'dnf', '-y', 'install', 'dnf-command(copr)'])
+        for copr in enable_coprs:
+            remote.run(args=['sudo', 'dnf', '-y', 'copr', 'enable', copr])
+
     # rpm does not force installation of a particular version of the project
     # packages, so we can put extra_system_packages together with the rest
     system_pkglist = config.get('extra_system_packages')
@@ -250,14 +260,14 @@ def _update_package_list_and_install(ctx, remote, rpm, config):
         rpm = _downgrade_packages(ctx, remote, rpm, pkg_version, config)
 
     if system_pkglist:
-        _retry_if_503_in_output(remote,
+        _retry_if_failures_are_recoverable(remote,
             args='{install_cmd} {rpms}'
                  .format(install_cmd=install_cmd, rpms=' '.join(rpm))
             )
     else:
         for cpack in rpm:
             if ldir:
-                _retry_if_503_in_output(remote,
+                _retry_if_failures_are_recoverable(remote,
                   args='''
                   if test -e {pkg} ; then
                     {remove_cmd} {pkg} ;
@@ -270,7 +280,7 @@ def _update_package_list_and_install(ctx, remote, rpm, config):
                              pkg=os.path.join(ldir, cpack),
                              cpack=cpack))
             else:
-                _retry_if_503_in_output(remote,
+                _retry_if_failures_are_recoverable(remote,
                     args='{install_cmd} {cpack}'
                          .format(install_cmd=install_cmd, cpack=cpack)
                     )
@@ -365,6 +375,8 @@ def _remove_sources_list(ctx, config, remote):
     if remote.os.name not in ['opensuse', 'sle']:
         _yum_unset_check_obsoletes(remote)
 
+    for copr in config.get('enable_coprs', []):
+        remote.run(args=['sudo', 'dnf', '-y', 'copr', 'disable', copr])
 
 def _upgrade_packages(ctx, config, remote, pkgs):
     """

teuthology/task/install/util.py

@@ -38,7 +38,7 @@ def get_flavor(config):
     Determine the flavor to use.
     """
     config = config or dict()
-    flavor = config.get('flavor', 'basic')
+    flavor = config.get('flavor', 'default')
 
     if config.get('path'):
         # local dir precludes any other flavors
@@ -81,11 +81,11 @@ def _ship_utilities(ctx):
     except IOError as e:
         log.info('Cannot ship supression file for valgrind: %s...', e.strerror)
 
-    FILES = ['daemon-helper', 'adjust-ulimits']
+    FILES = ['daemon-helper', 'adjust-ulimits', 'stdin-killer']
     destdir = '/usr/bin'
     for filename in FILES:
         log.info('Shipping %r...', filename)
-        src = os.path.join(os.path.dirname(__file__), filename)
+        src = os.path.join(os.path.dirname(__file__), 'bin', filename)
         dst = os.path.join(destdir, filename)
         filenames.append(dst)
         with open(src, 'rb') as f:

teuthology/task/internal/__init__.py

@@ -12,19 +12,21 @@ import shutil
 import time
 import yaml
 import subprocess
-
+import tempfile
+import re
 import humanfriendly
 
 import teuthology.lock.ops
-from teuthology import misc
-from teuthology.packaging import get_builder_project
+from teuthology import misc, packaging
 from teuthology import report
 from teuthology.config import config as teuth_config
 from teuthology.exceptions import ConfigError, VersionNotFoundError
 from teuthology.job_status import get_status, set_status
 from teuthology.orchestra import cluster, remote, run
 # the below import with noqa is to workaround run.py which does not support multilevel submodule import
-from teuthology.task.internal.redhat import setup_cdn_repo, setup_base_repo, setup_additional_repo, setup_stage_cdn  # noqa
+from teuthology.task.internal.redhat import (setup_cdn_repo, setup_base_repo,            # noqa
+                                             setup_additional_repo,                      # noqa
+                                             setup_stage_cdn, setup_container_registry)  # noqa
 
 log = logging.getLogger(__name__)
 
@@ -86,7 +88,7 @@ def check_packages(ctx, config):
     # We can only do this check if there are a defined sha1 and os_type
     # in the job config.
     if os_type and sha1:
-        package = get_builder_project()("ceph", ctx.config)
+        package = packaging.get_builder_project()("ceph", ctx.config)
         template = "Checking packages for os_type '{os}', " \
             "flavor '{flav}' and ceph hash '{ver}'"
         log.info(
@@ -270,7 +272,7 @@ def check_ceph_data(ctx, config):
         try:
             proc.wait()
         except run.CommandFailedError:
-            log.error('Host %s has stale /var/lib/ceph, check lock and nuke/cleanup.', proc.remote.shortname)
+            log.error('Host %s has stale /var/lib/ceph!', proc.remote.shortname)
             failed = True
     if failed:
         raise RuntimeError('Stale /var/lib/ceph detected, aborting.')
@@ -315,7 +317,29 @@ def fetch_binaries_for_coredumps(path, remote):
             # Parse file output to get program, Example output:
             # 1422917770.7450.core: ELF 64-bit LSB core file x86-64, version 1 (SYSV), SVR4-style, \
             # from 'radosgw --rgw-socket-path /home/ubuntu/cephtest/apache/tmp.client.0/fastcgi_soc'
-            dump_program = dump_out.split("from '")[1].split(' ')[0]
+            log.info(f' core looks like: {dump_out}')
+
+            if 'gzip' in dump_out:
+                try:
+                    log.info("core is compressed, try accessing gzip file ...")
+                    with gzip.open(dump_path, 'rb') as f_in, \
+                         tempfile.NamedTemporaryFile(mode='w+b') as f_out:
+                         shutil.copyfileobj(f_in, f_out)
+                         dump_info = subprocess.Popen(['file', f_out.name],
+                                                        stdout=subprocess.PIPE)
+                         dump_out = dump_info.communicate()[0].decode()
+                         log.info(f' core looks like: {dump_out}')
+                except Exception as e:
+                    log.info('Something went wrong while opening the compressed file')
+                    log.error(e)
+                    continue
+            try:
+                dump_program = re.findall("from '([^']+)'", dump_out)[0]
+                log.info(f' dump_program: {dump_program}')
+            except Exception as e:
+                log.info("core doesn't have the desired format, moving on ...")
+                log.error(e)
+                continue
 
             # Find path on remote server:
             remote_path = remote.sh(['which', dump_program]).rstrip()
@@ -441,9 +465,10 @@ def coredump(ctx, config):
     Stash a coredump of this system if an error occurs.
     """
     log.info('Enabling coredump saving...')
+    cluster = ctx.cluster.filter(lambda r: not r.is_container)
     archive_dir = misc.get_archive_dir(ctx)
     run.wait(
-        ctx.cluster.run(
+        cluster.run(
             args=[
                 'install', '-d', '-m0755', '--',
                 '{adir}/coredump'.format(adir=archive_dir),
@@ -462,11 +487,17 @@ def coredump(ctx, config):
     try:
         yield
     finally:
+        cluster = ctx.cluster.filter(lambda r: not r.is_container)
         run.wait(
-            ctx.cluster.run(
+            cluster.run(
                 args=[
                     'sudo', 'sysctl', '-w', 'kernel.core_pattern=core',
                     run.Raw('&&'),
+                    'sudo', 'bash', '-c',
+                    (f'for f in `find {archive_dir}/coredump -type f`; do '
+                     'file $f | grep -q systemd-sysusers && rm $f || true ; '
+                     'done'),
+                    run.Raw('&&'),
                     # don't litter the archive dir if there were no cores dumped
                     'rmdir',
                     '--ignore-fail-on-non-empty',
@@ -479,7 +510,7 @@ def coredump(ctx, config):
 
         # set status = 'fail' if the dir is still there = coredumps were
         # seen
-        for rem in ctx.cluster.remotes.keys():
+        for rem in cluster.remotes.keys():
             try:
                 rem.sh("test -e " + archive_dir + "/coredump")
             except run.CommandFailedError:

teuthology/task/internal/edit_sudoers.sh

@@ -0,0 +1,10 @@
+#! /bin/sh
+
+sudo vi -e /etc/sudoers <<EOF
+g/  requiretty/s// !requiretty/
+g/ !visiblepw/s//  visiblepw/
+w!
+q
+EOF
+exit
+

teuthology/task/internal/lock_machines.py

@@ -4,7 +4,6 @@ import logging
 import teuthology.lock.ops
 import teuthology.lock.query
 import teuthology.lock.util
-from teuthology.job_status import get_status
 
 log = logging.getLogger(__name__)
 
@@ -24,13 +23,7 @@ def lock_machines(ctx, config):
     try:
         yield
     finally:
-        # If both unlock_on_failure and nuke-on-error are set, don't unlock now
-        # because we're just going to nuke (and unlock) later.
-        unlock_on_failure = (
-                ctx.config.get('unlock_on_failure', False)
-                and not ctx.config.get('nuke-on-error', False)
-            )
-        if get_status(ctx.summary) == 'pass' or unlock_on_failure:
+        if ctx.config.get("unlock_on_failure", True):
             log.info('Unlocking machines...')
             for machine in ctx.config['targets'].keys():
-                teuthology.lock.ops.unlock_one(ctx, machine, ctx.owner, ctx.archive)
+                teuthology.lock.ops.unlock_one(machine, ctx.owner, ctx.archive)

teuthology/task/internal/redhat.py

@@ -49,7 +49,7 @@ def _subscribe_stage_cdn(remote):
     cdn_config = teuthconfig.get('cdn-config', dict())
     server_url = cdn_config.get('server-url', 'subscription.rhsm.stage.redhat.com:443/subscription')
     base_url = cdn_config.get('base-url', 'https://cdn.stage.redhat.com')
-    username = cdn_config.get('username', 'cephuser')
+    username = cdn_config.get('username')
     password = cdn_config.get('password')
     remote.run(
         args=[
@@ -88,6 +88,36 @@ def setup_cdn_repo(ctx, config):
         set_cdn_repo(ctx, config)
     yield
 
+@contextlib.contextmanager
+def setup_container_registry(ctx, config):
+    """
+     setup container registry if setup_container_registry in config
+
+     redhat:
+      setup_container_registry: <registry.io>   # registry-name
+    """
+    if ctx.config.get('redhat').get('setup_container_registry', None):
+        registry = ctx.config['redhat']['setup_container_registry']
+
+        # fetch credentials from teuth_config
+        creds = teuthconfig.get('registries', dict()).get(registry)
+        if not creds:
+            raise ConfigError("Registry not found....")
+
+        # container-tool login
+        for remote in ctx.cluster.remotes.keys():
+            container_tool = "podman"
+            if remote.os.version.startswith('7'):
+                container_tool = "docker"
+
+            remote.run(args=[
+                'sudo', container_tool,
+                'login', registry,
+                '--username', creds['username'],
+                '--password', creds['password'],
+                ]
+            )
+    yield
 
 @contextlib.contextmanager
 def setup_additional_repo(ctx, config):

teuthology/task/internal/syslog.py

@@ -22,12 +22,17 @@ def syslog(ctx, config):
         yield
         return
 
+    cluster = ctx.cluster.filter(lambda r: not r.is_container)
+    if not len(cluster.remotes.keys()):
+        yield
+        return
+
     log.info('Starting syslog monitoring...')
 
     archive_dir = misc.get_archive_dir(ctx)
     log_dir = '{adir}/syslog'.format(adir=archive_dir)
     run.wait(
-        ctx.cluster.run(
+        cluster.run(
             args=['mkdir', '-p', '-m0755', '--', log_dir],
             wait=False,
         )
@@ -43,7 +48,7 @@ def syslog(ctx, config):
     ]
     conf_fp = BytesIO('\n'.join(conf_lines).encode())
     try:
-        for rem in ctx.cluster.remotes.keys():
+        for rem in cluster.remotes.keys():
             log_context = 'system_u:object_r:var_log_t:s0'
             for log_path in (kern_log, misc_log):
                 rem.run(args=['install', '-m', '666', '/dev/null', log_path])
@@ -55,7 +60,7 @@ def syslog(ctx, config):
             )
             conf_fp.seek(0)
         run.wait(
-            ctx.cluster.run(
+            cluster.run(
                 args=[
                     'sudo',
                     'service',
@@ -70,10 +75,14 @@ def syslog(ctx, config):
 
         yield
     finally:
+        cluster = ctx.cluster.filter(lambda r: not r.is_container)
+        if not len(cluster.remotes.keys()):
+            return
+        
         log.info('Shutting down syslog monitoring...')
 
         run.wait(
-            ctx.cluster.run(
+            cluster.run(
                 args=[
                     'sudo',
                     'rm',
@@ -93,13 +102,13 @@ def syslog(ctx, config):
         # flush the file fully. oh well.
 
         log.info('Checking logs for errors...')
-        for rem in ctx.cluster.remotes.keys():
+        for rem in cluster.remotes.keys():
             log.debug('Checking %s', rem.name)
             stdout = rem.sh(
                 [
                     'egrep', '--binary-files=text',
                     '\\bBUG\\b|\\bINFO\\b|\\bDEADLOCK\\b',
-                    run.Raw('{adir}/syslog/*.log'.format(adir=archive_dir)),
+                    run.Raw(f'{archive_dir}/syslog/kern.log'),
                     run.Raw('|'),
                     'grep', '-v', 'task .* blocked for more than .* seconds',
                     run.Raw('|'),
@@ -152,7 +161,7 @@ def syslog(ctx, config):
 
         log.info('Compressing syslogs...')
         run.wait(
-            ctx.cluster.run(
+            cluster.run(
                 args=[
                     'find',
                     '{adir}/syslog'.format(adir=archive_dir),
@@ -169,5 +178,19 @@ def syslog(ctx, config):
                     '--',
                 ],
                 wait=False,
-            ),
+            )
+        )
+
+        log.info('Gathering journactl -b0...')
+        run.wait(
+            cluster.run(
+                args=[
+                    'sudo', 'journalctl', '-b0',
+                    run.Raw('|'),
+                    'gzip', '-9',
+                    run.Raw('>'),
+                    f'{archive_dir}/syslog/journalctl-b0.gz',
+                ],
+                wait=False,
+            )
         )