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

teuthology/misc.py

@@ -15,11 +15,14 @@ import time
 import yaml
 import json
 import re
+from sys import stdin
 import pprint
 import datetime
 
 from tarfile import ReadError
 
+from typing import Optional, TypeVar
+
 from teuthology.util.compat import urljoin, urlopen, HTTPError
 
 from netaddr.strategy.ipv4 import valid_str as _is_ipv4
@@ -48,9 +51,9 @@ def host_shortname(hostname):
     else:
         return hostname.split('.', 1)[0]
 
-def canonicalize_hostname(hostname, user='ubuntu'):
+def canonicalize_hostname(hostname, user: Optional[str] ='ubuntu'):
     hostname_expr = hostname_expr_templ.format(
-        lab_domain=config.lab_domain.replace('.', '\.'))
+        lab_domain=config.lab_domain.replace('.', r'\.'))
     match = re.match(hostname_expr, hostname)
     if _is_ipv4(hostname) or _is_ipv6(hostname):
         return "%s@%s" % (user, hostname)
@@ -80,7 +83,7 @@ def canonicalize_hostname(hostname, user='ubuntu'):
 def decanonicalize_hostname(hostname):
     lab_domain = ''
     if config.lab_domain:
-        lab_domain='\.' + config.lab_domain.replace('.', '\.')
+        lab_domain=r'\.' + config.lab_domain.replace('.', r'\.')
     hostname_expr = hostname_expr_templ.format(lab_domain=lab_domain)
     match = re.match(hostname_expr, hostname)
     if match:
@@ -106,31 +109,20 @@ def config_file(string):
     return config_dict
 
 
-class MergeConfig(argparse.Action):
-    """
-    Used by scripts to mergeg configurations.   (nuke, run, and
-    schedule, for example)
-    """
-    def __call__(self, parser, namespace, values, option_string=None):
-        """
-        Perform merges of all the day in the config dictionaries.
-        """
-        config_dict = getattr(namespace, self.dest)
-        for new in values:
-            deep_merge(config_dict, new)
-
-
-def merge_configs(config_paths):
+def merge_configs(config_paths) -> dict:
     """ Takes one or many paths to yaml config files and merges them
         together, returning the result.
     """
     conf_dict = dict()
     for conf_path in config_paths:
-        if not os.path.exists(conf_path):
+        if conf_path == "-":
+            partial_dict = yaml.safe_load(stdin)
+        elif not os.path.exists(conf_path):
             log.debug("The config path {0} does not exist, skipping.".format(conf_path))
             continue
-        with open(conf_path) as partial_file:
-            partial_dict = yaml.safe_load(partial_file)
+        else:
+            with open(conf_path) as partial_file:
+                partial_dict: dict = yaml.safe_load(partial_file)
         try:
             conf_dict = deep_merge(conf_dict, partial_dict)
         except Exception:
@@ -227,13 +219,13 @@ def get_ceph_binary_url(package=None,
         assert tag is None, "cannot set both sha1 and tag"
     else:
         # gitbuilder uses remote-style ref names for branches, mangled to
-        # have underscores instead of slashes; e.g. origin_master
+        # have underscores instead of slashes; e.g. origin_main
         if tag is not None:
             ref = tag
             assert branch is None, "cannot set both branch and tag"
         else:
             if branch is None:
-                branch = 'master'
+                branch = 'main'
             ref = branch
 
         sha1_url = urljoin(BASE, 'ref/{ref}/sha1'.format(ref=ref))
@@ -740,8 +732,8 @@ def pull_directory(remote, remotedir, localdir, write_to=copy_fileobj):
               remote.shortname, remotedir, localdir)
     if not os.path.exists(localdir):
         os.mkdir(localdir)
-    r = remote.get_tar_stream(remotedir, sudo=True)
-    tar = tarfile.open(mode='r|gz', fileobj=r.stdout)
+    r = remote.get_tar_stream(remotedir, sudo=True, compress=False)
+    tar = tarfile.open(mode='r|', fileobj=r.stdout)
     while True:
         ti = tar.next()
         if ti is None:
@@ -778,7 +770,7 @@ def pull_directory_tarball(remote, remotedir, localfile):
 
 
 def get_wwn_id_map(remote, devs):
-    log.warn("Entering get_wwn_id_map, a deprecated function that will be removed")
+    log.warning("Entering get_wwn_id_map, a deprecated function that will be removed")
     return dict((d, d) for d in devs)
 
 
@@ -797,33 +789,31 @@ def get_scratch_devices(remote):
     for dev in devs:
         if 'vda' in dev:
             devs.remove(dev)
-            log.warn("Removing root device: %s from device list" % dev)
+            log.warning("Removing root device: %s from device list" % dev)
 
     log.debug('devs={d}'.format(d=devs))
 
     retval = []
     for dev in devs:
-        try:
-            # FIXME: Split this into multiple calls.
-            remote.run(
-                args=[
-                    # node exists
-                    'stat',
-                    dev,
-                    run.Raw('&&'),
-                    # readable
-                    'sudo', 'dd', 'if=%s' % dev, 'of=/dev/null', 'count=1',
-                    run.Raw('&&'),
-                    # not mounted
-                    run.Raw('!'),
-                    'mount',
-                    run.Raw('|'),
-                    'grep', '-q', dev,
-                ]
-            )
+        dev_checks = [
+            [['stat', dev], "does not exist"],
+            [['sudo', 'dd', 'if=%s' % dev, 'of=/dev/null', 'count=1'], "is not readable"],
+            [
+                [run.Raw('!'), 'mount', run.Raw('|'), 'grep', '-v', 'devtmpfs', run.Raw('|'),
+                'grep', '-q', dev],
+                "is in use"
+            ],
+        ]
+        for args, msg in dev_checks:
+            try:
+                remote.run(args=args)
+            except CommandFailedError:
+                log.debug(f"get_scratch_devices: {dev} {msg}")
+                break
+        else:
             retval.append(dev)
-        except CommandFailedError:
-            log.debug("get_scratch_devices: %s is in use" % dev)
+            continue
+        break
     return retval
 
 
@@ -995,7 +985,8 @@ def replace_all_with_clients(cluster, config):
     return norm_config
 
 
-def deep_merge(a, b):
+DeepMerge = TypeVar('DeepMerge')
+def deep_merge(a: DeepMerge, b: DeepMerge) -> DeepMerge:
     """
     Deep Merge.  If a and b are both lists, all elements in b are
     added into a.  If a and b are both dictionaries, elements in b are
@@ -1003,10 +994,10 @@ def deep_merge(a, b):
     :param a: object items will be merged into
     :param b: object items will be merged from
     """
-    if a is None:
-        return b
     if b is None:
         return a
+    if a is None:
+        return deep_merge(b.__class__(), b)
     if isinstance(a, list):
         assert isinstance(b, list)
         a.extend(b)
@@ -1014,10 +1005,7 @@ def deep_merge(a, b):
     if isinstance(a, dict):
         assert isinstance(b, dict)
         for (k, v) in b.items():
-            if k in a:
-                a[k] = deep_merge(a[k], v)
-            else:
-                a[k] = v
+            a[k] = deep_merge(a.get(k), v)
         return a
     return b
 
@@ -1096,7 +1084,8 @@ def ssh_keyscan(hostnames, _raise=True):
     for hostname in hostnames:
         with safe_while(
             sleep=1,
-            tries=5 if _raise else 1,
+            tries=15 if _raise else 1,
+            increment=1,
             _raise=_raise,
             action="ssh_keyscan " + hostname,
         ) as proceed:
@@ -1109,7 +1098,7 @@ def ssh_keyscan(hostnames, _raise=True):
         missing = set(hostnames) - set(keys_dict.keys())
         msg = "Unable to scan these host keys: %s" % ' '.join(missing)
         if not _raise:
-            log.warn(msg)
+            log.warning(msg)
         else:
             raise RuntimeError(msg)
     return keys_dict
@@ -1122,7 +1111,7 @@ def _ssh_keyscan(hostname):
     :param hostname: The hostname
     :returns: The host key
     """
-    args = ['ssh-keyscan', '-T', '1', '-t', 'rsa', hostname]
+    args = ['ssh-keyscan', '-T', '1', hostname]
     p = subprocess.Popen(
         args=args,
         stdout=subprocess.PIPE,
@@ -1134,9 +1123,12 @@ def _ssh_keyscan(hostname):
         line = line.strip()
         if line and not line.startswith('#'):
             log.error(line)
+    keys = list()
     for line in p.stdout:
         host, key = line.strip().decode().split(' ', 1)
-        return key
+        keys.append(key)
+    if len(keys) > 0:
+        return sorted(keys)[0]
 
 
 def ssh_keyscan_wait(hostname):
@@ -1177,29 +1169,19 @@ def stop_daemons_of_type(ctx, type_, cluster='ceph'):
 def get_system_type(remote, distro=False, version=False):
     """
     If distro, return distro.
-    If version, return version (lsb_release -rs)
+    If version, return version
     If both, return both.
     If neither, return 'deb' or 'rpm' if distro is known to be one of those
-    Finally, if unknown, return the unfiltered distro (from lsb_release -is)
     """
-    system_value = remote.sh('sudo lsb_release -is').strip()
-    log.debug("System to be installed: %s" % system_value)
     if version:
-        version = remote.sh('sudo lsb_release -rs').strip()
+        version = remote.os.version
     if distro and version:
-        return system_value.lower(), version
+        return remote.os.name, version
     if distro:
-        return system_value.lower()
+        return remote.os.name
     if version:
         return version
-    if system_value in ['Ubuntu', 'Debian']:
-        return "deb"
-    if system_value in ['CentOS', 'Fedora', 'RedHatEnterpriseServer',
-                        'RedHatEnterprise',
-                        'CentOSStream',
-                        'openSUSE', 'openSUSE project', 'SUSE', 'SUSE LINUX']:
-        return "rpm"
-    return system_value
+    return remote.os.package_type
 
 def get_pkg_type(os_type):
     if os_type in ('centos', 'fedora', 'opensuse', 'rhel', 'sle'):
@@ -1308,7 +1290,7 @@ def sh(command, log_limit=1024, cwd=None, env=None):
         for line in proc.stdout:
             line = line.decode()
             lines.append(line)
-            line = line.strip()
+            line = line.rstrip()
             if len(line) > log_limit:
                 truncated = True
                 log.debug(line[:log_limit] +
@@ -1336,6 +1318,8 @@ def add_remote_path(ctx, local_dir, remote_dir):
     Add key/value pair (local_dir: remote_dir) to job's info.yaml.
     These key/value pairs are read to archive them in case of job timeout.
     """
+    if ctx.archive is None:
+        return
     with open(os.path.join(ctx.archive, 'info.yaml'), 'r+') as info_file:
         info_yaml = yaml.safe_load(info_file)
         info_file.seek(0)
@@ -1351,6 +1335,8 @@ def archive_logs(ctx, remote_path, log_path):
     Archive directories from all nodes in a cliuster. It pulls all files in
     remote_path dir to job's archive dir under log_path dir.
     """
+    if ctx.archive is None:
+        return
     path = os.path.join(ctx.archive, 'remote')
     os.makedirs(path, exist_ok=True)
     for remote in ctx.cluster.remotes.keys():
@@ -1370,7 +1356,7 @@ def compress_logs(ctx, remote_dir):
     run.wait(
         ctx.cluster.run(
             args=(f"sudo find {remote_dir} -name *.log -print0 | "
-                  f"sudo xargs -0 --no-run-if-empty -- gzip --"),
+                  f"sudo xargs --max-args=1 --max-procs=0 --verbose -0 --no-run-if-empty -- gzip -5 --verbose --"),
             wait=False,
         ),
     )

teuthology/nuke/__init__.py

@@ -1,361 +1,20 @@
-import argparse
-import datetime
-import json
 import logging
-import os
-import subprocess
-
-import yaml
-
-import teuthology
-from teuthology import provision
-from teuthology.lock.ops import unlock_one
-from teuthology.lock.query import is_vm, list_locks, \
-    find_stale_locks, get_status
-from teuthology.lock.util import locked_since_seconds
-from teuthology.nuke.actions import (
-    check_console, clear_firewall, shutdown_daemons, remove_installed_packages,
-    reboot, remove_osd_mounts, remove_osd_tmpfs, kill_hadoop,
-    remove_ceph_packages, synch_clocks, unlock_firmware_repo,
-    remove_configuration_files, undo_multipath, reset_syslog_dir,
-    remove_ceph_data, remove_testing_tree, remove_yum_timedhosts,
-    kill_valgrind,
-)
-from teuthology.config import config, FakeNamespace
-from teuthology.misc import (
-    canonicalize_hostname, config_file, decanonicalize_hostname, merge_configs,
-    get_user, sh
-)
-from teuthology.openstack import OpenStack, OpenStackInstance, enforce_json_dictionary
-from teuthology.orchestra.remote import Remote
-from teuthology.parallel import parallel
-from teuthology.task.internal import check_lock, add_remotes, connect
 
 log = logging.getLogger(__name__)
 
 
-def openstack_volume_id(volume):
-    return (volume.get('ID') or volume['id'])
-
-
-def openstack_volume_name(volume):
-    return (volume.get('Display Name') or
-            volume.get('display_name') or
-            volume.get('Name') or
-            volume.get('name') or "")
-
-
-def stale_openstack(ctx):
-    targets = dict(map(lambda i: (i['ID'], i),
-                       OpenStack.list_instances()))
-    nodes = list_locks(keyed_by_name=True, locked=True)
-    stale_openstack_instances(ctx, targets, nodes)
-    stale_openstack_nodes(ctx, targets, nodes)
-    stale_openstack_volumes(ctx, OpenStack.list_volumes())
-    if not ctx.dry_run:
-        openstack_remove_again()
-
-#
-# A delay, in seconds, that is significantly longer than
-# any kind of OpenStack server creation / deletion / etc.
-#
-OPENSTACK_DELAY = 30 * 60
-
-
-def stale_openstack_instances(ctx, instances, locked_nodes):
-    for (instance_id, instance) in instances.items():
-        i = OpenStackInstance(instance_id)
-        if not i.exists():
-            log.debug("stale-openstack: {instance} disappeared, ignored"
-                      .format(instance=instance_id))
-            continue
-        if (i.get_created() >
-                config['max_job_time'] + OPENSTACK_DELAY):
-            log.info(
-                "stale-openstack: destroying instance {instance}"
-                " because it was created {created} seconds ago"
-                " which is older than"
-                " max_job_time {max_job_time} + {delay}"
-                .format(instance=i['name'],
-                        created=i.get_created(),
-                        max_job_time=config['max_job_time'],
-                        delay=OPENSTACK_DELAY))
-            if not ctx.dry_run:
-                i.destroy()
-            continue
-        name = canonicalize_hostname(i['name'], user=None)
-        if i.get_created() > OPENSTACK_DELAY and name not in locked_nodes:
-            log.info("stale-openstack: destroying instance {instance}"
-                     " because it was created {created} seconds ago"
-                     " is older than {delay}s and it is not locked"
-                     .format(instance=i['name'],
-                             created=i.get_created(),
-                             delay=OPENSTACK_DELAY))
-            if not ctx.dry_run:
-                i.destroy()
-            continue
-        log.debug("stale-openstack: instance " + i['name'] + " OK")
-
-
-def openstack_delete_volume(id):
-    OpenStack().run("volume delete " + id + " || true")
-
-
-def stale_openstack_volumes(ctx, volumes):
-    now = datetime.datetime.now()
-    for volume in volumes:
-        volume_id = openstack_volume_id(volume)
-        try:
-            volume = json.loads(OpenStack().run("volume show -f json " +
-                                                volume_id))
-        except subprocess.CalledProcessError:
-            log.debug("stale-openstack: {id} disappeared, ignored"
-                      .format(id=volume_id))
-            continue
-        volume_name = openstack_volume_name(volume)
-        enforce_json_dictionary(volume)
-        created_at = datetime.datetime.strptime(
-            volume['created_at'], '%Y-%m-%dT%H:%M:%S.%f')
-        created = (now - created_at).total_seconds()
-        if created > config['max_job_time'] + OPENSTACK_DELAY:
-            log.info(
-                "stale-openstack: destroying volume {volume}({id})"
-                " because it was created {created} seconds ago"
-                " which is older than"
-                " max_job_time {max_job_time} + {delay}"
-                .format(volume=volume_name,
-                        id=volume_id,
-                        created=created,
-                        max_job_time=config['max_job_time'],
-                        delay=OPENSTACK_DELAY))
-            if not ctx.dry_run:
-                openstack_delete_volume(volume_id)
-            continue
-        log.debug("stale-openstack: volume " + volume_id + " OK")
-
-
-def stale_openstack_nodes(ctx, instances, locked_nodes):
-    names = set([ i['Name'] for i in instances.values() ])
-    for (name, node) in locked_nodes.items():
-        name = decanonicalize_hostname(name)
-        if node['machine_type'] != 'openstack':
-            continue
-        if (name not in names and
-                locked_since_seconds(node) > OPENSTACK_DELAY):
-            log.info("stale-openstack: unlocking node {name} unlocked"
-                     " because it was created {created}"
-                     " seconds ago which is older than {delay}"
-                     " and it has no instance"
-                     .format(name=name,
-                             created=locked_since_seconds(node),
-                             delay=OPENSTACK_DELAY))
-            if not ctx.dry_run:
-                unlock_one(ctx, name, node['locked_by'])
-            continue
-        log.debug("stale-openstack: node " + name + " OK")
-
-
-def openstack_remove_again():
+# This is being kept because ceph.git/qa/tasks/cephfs/filesystem.py references it.
+def clear_firewall(ctx):
     """
-    Volumes and servers with REMOVE-ME in the name are leftover
-    that failed to be removed. It is not uncommon for a failed removal
-    to succeed later on.
+    Remove any iptables rules created by teuthology.  These rules are
+    identified by containing a comment with 'teuthology' in it.  Non-teuthology
+    firewall rules are unaffected.
     """
-    sh("""
-    openstack server list --name REMOVE-ME --column ID --format value |
-    xargs --no-run-if-empty --max-args 1 -P20 openstack server delete --wait
-    true
-    """)
-    volumes = json.loads(OpenStack().run("volume list -f json --long"))
-    remove_me = [openstack_volume_id(v) for v in volumes
-                 if 'REMOVE-ME' in openstack_volume_name(v)]
-    for i in remove_me:
-        log.info("Trying to remove stale volume %s" % i)
-        openstack_delete_volume(i)
-
-
-def main(args):
-    ctx = FakeNamespace(args)
-    if ctx.verbose:
-        teuthology.log.setLevel(logging.DEBUG)
-
-    info = {}
-    if ctx.archive:
-        ctx.config = config_file(ctx.archive + '/config.yaml')
-        ifn = os.path.join(ctx.archive, 'info.yaml')
-        if os.path.exists(ifn):
-            with open(ifn, 'r') as fd:
-                info = yaml.safe_load(fd.read())
-        if not ctx.pid:
-            ctx.pid = info.get('pid')
-            if not ctx.pid:
-                ctx.pid = int(open(ctx.archive + '/pid').read().rstrip('\n'))
-        if not ctx.owner:
-            ctx.owner = info.get('owner')
-            if not ctx.owner:
-                ctx.owner = open(ctx.archive + '/owner').read().rstrip('\n')
-
-    if ctx.targets:
-        ctx.config = merge_configs(ctx.targets)
-
-    if ctx.stale:
-        stale_nodes = find_stale_locks(ctx.owner)
-        targets = dict()
-        for node in stale_nodes:
-            targets[node['name']] = node['ssh_pub_key']
-        ctx.config = dict(targets=targets)
-
-    if ctx.stale_openstack:
-        stale_openstack(ctx)
-        return
-
-    log.info(
-        '\n  '.join(
-            ['targets:', ] + yaml.safe_dump(
-                ctx.config['targets'],
-                default_flow_style=False).splitlines()))
-
-    if ctx.dry_run:
-        log.info("Not actually nuking anything since --dry-run was passed")
-        return
-
-    if ctx.owner is None:
-        ctx.owner = get_user()
-
-    if ctx.pid:
-        if ctx.archive:
-            log.info('Killing teuthology process at pid %d', ctx.pid)
-            os.system('grep -q %s /proc/%d/cmdline && sudo kill %d' % (
-                ctx.archive,
-                ctx.pid,
-                ctx.pid))
-        else:
-            subprocess.check_call(["kill", "-9", str(ctx.pid)])
-
-    nuke(ctx, ctx.unlock, ctx.synch_clocks, ctx.noipmi, ctx.keep_logs, not ctx.no_reboot)
-
-
-def nuke(ctx, should_unlock, sync_clocks=True, noipmi=False, keep_logs=False, should_reboot=True):
-    if 'targets' not in ctx.config:
-        return
-    total_unnuked = {}
-    targets = dict(ctx.config['targets'])
-    if ctx.name:
-        log.info('Checking targets against current locks')
-        locks = list_locks()
-        # Remove targets who's description doesn't match archive name.
-        for lock in locks:
-            for target in targets:
-                if target == lock['name']:
-                    if ctx.name not in lock['description']:
-                        del ctx.config['targets'][lock['name']]
-                        log.info(
-                            "Not nuking %s because description doesn't match",
-                            lock['name'])
-    with parallel() as p:
-        for target, hostkey in ctx.config['targets'].items():
-            p.spawn(
-                nuke_one,
-                ctx,
-                {target: hostkey},
-                should_unlock,
-                sync_clocks,
-                ctx.config.get('check-locks', True),
-                noipmi,
-                keep_logs,
-                should_reboot,
-            )
-        for unnuked in p:
-            if unnuked:
-                total_unnuked.update(unnuked)
-    if total_unnuked:
-        log.error('Could not nuke the following targets:\n' +
-                  '\n  '.join(['targets:', ] +
-                              yaml.safe_dump(
-                                  total_unnuked,
-                                  default_flow_style=False).splitlines()))
-
-
-def nuke_one(ctx, target, should_unlock, synch_clocks,
-             check_locks, noipmi, keep_logs, should_reboot):
-    ret = None
-    ctx = argparse.Namespace(
-        config=dict(targets=target),
-        owner=ctx.owner,
-        check_locks=check_locks,
-        synch_clocks=synch_clocks,
-        teuthology_config=config.to_dict(),
-        name=ctx.name,
-        noipmi=noipmi,
+    log.info("Clearing teuthology firewall rules...")
+    ctx.cluster.run(
+        args=[
+            "sudo", "sh", "-c",
+            "iptables-save | grep -v teuthology | iptables-restore"
+        ],
     )
-    try:
-        nuke_helper(ctx, should_unlock, keep_logs, should_reboot)
-    except Exception:
-        log.exception('Could not nuke %s' % target)
-        # not re-raising the so that parallel calls aren't killed
-        ret = target
-    else:
-        if should_unlock:
-            unlock_one(ctx, list(target.keys())[0], ctx.owner)
-    return ret
-
-
-def nuke_helper(ctx, should_unlock, keep_logs, should_reboot):
-    # ensure node is up with ipmi
-    (target,) = ctx.config['targets'].keys()
-    host = target.split('@')[-1]
-    shortname = host.split('.')[0]
-    if should_unlock:
-        if is_vm(shortname):
-            return
-    log.debug('shortname: %s' % shortname)
-    if ctx.check_locks:
-        # does not check to ensure if the node is 'up'
-        # we want to be able to nuke a downed node
-        check_lock.check_lock(ctx, None, check_up=False)
-    status = get_status(host)
-    if status['machine_type'] in provision.fog.get_types():
-        remote = Remote(host)
-        remote.console.power_off()
-        return
-    elif status['machine_type'] in provision.pelagos.get_types():
-        provision.pelagos.park_node(host)
-        return
-
-    if (not ctx.noipmi and 'ipmi_user' in config and
-            'vpm' not in shortname):
-        try:
-            check_console(host)
-        except Exception:
-            log.exception('')
-            log.info("Will attempt to connect via SSH")
-            remote = Remote(host)
-            remote.connect()
-    add_remotes(ctx, None)
-    connect(ctx, None)
-    clear_firewall(ctx)
-    shutdown_daemons(ctx)
-    kill_valgrind(ctx)
-    # Try to remove packages before reboot
-    remove_installed_packages(ctx)
-    remotes = ctx.cluster.remotes.keys()
-    if should_reboot:
-        reboot(ctx, remotes)
-    # shutdown daemons again incase of startup
-    shutdown_daemons(ctx)
-    remove_osd_mounts(ctx)
-    remove_osd_tmpfs(ctx)
-    kill_hadoop(ctx)
-    remove_ceph_packages(ctx)
-    synch_clocks(remotes)
-    unlock_firmware_repo(ctx)
-    remove_configuration_files(ctx)
-    undo_multipath(ctx)
-    reset_syslog_dir(ctx)
-    remove_ceph_data(ctx)
-    if not keep_logs:
-        remove_testing_tree(ctx)
-    remove_yum_timedhosts(ctx)
-    # Once again remove packages after reboot
-    remove_installed_packages(ctx)
-    log.info('Installed packages removed.')
+    log.info("Cleared teuthology firewall rules.")