swift 2.33.0__py2.py3-none-any.whl → 2.34.0__py2.py3-none-any.whl

swift/common/utils/__init__.py

@@ -24,9 +24,7 @@ import collections
 import errno
 import fcntl
 import grp
-import hashlib
 import json
-import operator
 import os
 import pwd
 import re
@@ -37,7 +35,7 @@ import time
 import uuid
 import functools
 import email.parser
-from random import random, shuffle
+from random import shuffle
 from contextlib import contextmanager, closing
 import ctypes
 import ctypes.util
@@ -49,7 +47,6 @@ from tempfile import gettempdir, mkstemp, NamedTemporaryFile
 import glob
 import itertools
 import stat
-import datetime
 
 import eventlet
 import eventlet.debug
@@ -64,25 +61,16 @@ except ImportError:
     import pkg_resources
 from eventlet import GreenPool, sleep, Timeout
 from eventlet.event import Event
-from eventlet.green import socket, threading
+from eventlet.green import socket
 import eventlet.hubs
 import eventlet.queue
-import codecs
-utf8_decoder = codecs.getdecoder('utf-8')
-utf8_encoder = codecs.getencoder('utf-8')
 import six
-if six.PY2:
-    from eventlet.green import httplib as green_http_client
-else:
-    from eventlet.green.http import client as green_http_client
-    utf16_decoder = codecs.getdecoder('utf-16')
-    utf16_encoder = codecs.getencoder('utf-16')
+
 from six.moves import cPickle as pickle
-from six.moves import configparser
 from six.moves.configparser import (ConfigParser, NoSectionError,
-                                    NoOptionError, RawConfigParser)
-from six.moves import range, http_client
-from six.moves.urllib.parse import quote as _quote, unquote
+                                    NoOptionError)
+from six.moves import range
+from six.moves.urllib.parse import unquote
 from six.moves.urllib.parse import urlparse
 from six.moves import UserList
 
@@ -93,6 +81,53 @@ from swift.common.linkat import linkat
 
 # For backwards compatability with 3rd party middlewares
 from swift.common.registry import register_swift_info, get_swift_info  # noqa
+
+from .base import (  # noqa
+    md5, get_valid_utf8_str, quote, split_path)
+from swift.common.utils.logs import (   # noqa
+    SysLogHandler,  # t.u.helpers.setup_servers monkey patch is sketch
+    logging_monkey_patch,
+    get_logger,
+    PrefixLoggerAdapter,
+    LogLevelFilter,
+    NullLogger,
+    capture_stdio,
+    SwiftLogFormatter,
+    SwiftLoggerAdapter,
+    LogAdapter,
+    LoggerFileObject,
+    PipeMutex,
+    NoopMutex,
+    ThreadSafeSysLogHandler,
+    StrAnonymizer,
+    get_log_line,
+    StrFormatTime,
+    LogStringFormatter,
+    get_policy_index,
+    LOG_LINE_DEFAULT_FORMAT,
+    NOTICE,
+)
+from swift.common.utils.config import ( # noqa
+    TRUE_VALUES,
+    NicerInterpolation,
+    config_true_value,
+    append_underscore,
+    non_negative_float,
+    non_negative_int,
+    config_positive_int_value,
+    config_float_value,
+    config_auto_int_value,
+    config_percent_value,
+    config_request_node_count_value,
+    config_fallocate_value,
+    config_read_prefixed_options,
+    config_read_reseller_options,
+    parse_prefixed_conf,
+    affinity_locality_predicate,
+    affinity_key_function,
+    readconf,
+    read_conf_dir,
+)
 from swift.common.utils.libc import (  # noqa
     F_SETPIPE_SZ,
     load_libc_function,
@@ -124,11 +159,9 @@ from swift.common.utils.ipaddrs import (  # noqa
     parse_socket_string,
     whataremyips,
 )
-from logging.handlers import SysLogHandler
+from swift.common.statsd_client import StatsdClient # noqa
 import logging
 
-NOTICE = 25
-
 # These are lazily pulled from libc elsewhere
 _sys_fallocate = None
 
@@ -164,12 +197,6 @@ RESERVED_STR = u'\x00'
 RESERVED = '\x00'
 
 
-LOG_LINE_DEFAULT_FORMAT = '{remote_addr} - - [{time.d}/{time.b}/{time.Y}' \
-                          ':{time.H}:{time.M}:{time.S} +0000] ' \
-                          '"{method} {path}" {status} {content_length} ' \
-                          '"{referer}" "{txn_id}" "{user_agent}" ' \
-                          '{trans_time:.4f} "{additional_info}" {pid} ' \
-                          '{policy_index}'
 DEFAULT_LOCK_TIMEOUT = 10
 # this is coupled with object-server.conf's network_chunk_size; if someone is
 # running that unreasonably small they may find this number inefficient, but in
@@ -280,199 +307,6 @@ def backward(f, blocksize=4096):
     yield last_row
 
 
-# Used when reading config values
-TRUE_VALUES = {'true', '1', 'yes', 'on', 't', 'y'}
-
-
-def non_negative_float(value):
-    """
-    Check that the value casts to a float and is non-negative.
-
-    :param value: value to check
-    :raises ValueError: if the value cannot be cast to a float or is negative.
-    :return: a float
-    """
-    try:
-        value = float(value)
-        if value < 0:
-            raise ValueError
-    except (TypeError, ValueError):
-        raise ValueError('Value must be a non-negative float number, not "%s".'
-                         % value)
-    return value
-
-
-def non_negative_int(value):
-    """
-    Check that the value casts to an int and is a whole number.
-
-    :param value: value to check
-    :raises ValueError: if the value cannot be cast to an int or does not
-        represent a whole number.
-    :return: an int
-    """
-    int_value = int(value)
-    if int_value != non_negative_float(value):
-        raise ValueError
-    return int_value
-
-
-def config_true_value(value):
-    """
-    Returns True if the value is either True or a string in TRUE_VALUES.
-    Returns False otherwise.
-    """
-    return value is True or \
-        (isinstance(value, six.string_types) and value.lower() in TRUE_VALUES)
-
-
-def config_positive_int_value(value):
-    """
-    Returns positive int value if it can be cast by int() and it's an
-    integer > 0. (not including zero) Raises ValueError otherwise.
-    """
-    try:
-        result = int(value)
-        if result < 1:
-            raise ValueError()
-    except (TypeError, ValueError):
-        raise ValueError(
-            'Config option must be an positive int number, not "%s".' % value)
-    return result
-
-
-def config_float_value(value, minimum=None, maximum=None):
-    try:
-        val = float(value)
-        if minimum is not None and val < minimum:
-            raise ValueError()
-        if maximum is not None and val > maximum:
-            raise ValueError()
-        return val
-    except (TypeError, ValueError):
-        min_ = ', greater than %s' % minimum if minimum is not None else ''
-        max_ = ', less than %s' % maximum if maximum is not None else ''
-        raise ValueError('Config option must be a number%s%s, not "%s".' %
-                         (min_, max_, value))
-
-
-def config_auto_int_value(value, default):
-    """
-    Returns default if value is None or 'auto'.
-    Returns value as an int or raises ValueError otherwise.
-    """
-    if value is None or \
-       (isinstance(value, six.string_types) and value.lower() == 'auto'):
-        return default
-    try:
-        value = int(value)
-    except (TypeError, ValueError):
-        raise ValueError('Config option must be an integer or the '
-                         'string "auto", not "%s".' % value)
-    return value
-
-
-def config_percent_value(value):
-    try:
-        return config_float_value(value, 0, 100) / 100.0
-    except ValueError as err:
-        raise ValueError("%s: %s" % (str(err), value))
-
-
-def config_request_node_count_value(value):
-    try:
-        value_parts = value.lower().split()
-        rnc_value = int(value_parts[0])
-    except (ValueError, AttributeError):
-        pass
-    else:
-        if len(value_parts) == 1:
-            return lambda replicas: rnc_value
-        elif (len(value_parts) == 3 and
-              value_parts[1] == '*' and
-              value_parts[2] == 'replicas'):
-            return lambda replicas: rnc_value * replicas
-    raise ValueError(
-        'Invalid request_node_count value: %r' % value)
-
-
-def append_underscore(prefix):
-    if prefix and not prefix.endswith('_'):
-        prefix += '_'
-    return prefix
-
-
-def config_read_reseller_options(conf, defaults):
-    """
-    Read reseller_prefix option and associated options from configuration
-
-    Reads the reseller_prefix option, then reads options that may be
-    associated with a specific reseller prefix. Reads options such that an
-    option without a prefix applies to all reseller prefixes unless an option
-    has an explicit prefix.
-
-    :param conf: the configuration
-    :param defaults: a dict of default values. The key is the option
-                     name. The value is either an array of strings or a string
-    :return: tuple of an array of reseller prefixes and a dict of option values
-    """
-    reseller_prefix_opt = conf.get('reseller_prefix', 'AUTH').split(',')
-    reseller_prefixes = []
-    for prefix in [pre.strip() for pre in reseller_prefix_opt if pre.strip()]:
-        if prefix == "''":
-            prefix = ''
-        prefix = append_underscore(prefix)
-        if prefix not in reseller_prefixes:
-            reseller_prefixes.append(prefix)
-    if len(reseller_prefixes) == 0:
-        reseller_prefixes.append('')
-
-    # Get prefix-using config options
-    associated_options = {}
-    for prefix in reseller_prefixes:
-        associated_options[prefix] = dict(defaults)
-        associated_options[prefix].update(
-            config_read_prefixed_options(conf, '', defaults))
-        prefix_name = prefix if prefix != '' else "''"
-        associated_options[prefix].update(
-            config_read_prefixed_options(conf, prefix_name, defaults))
-    return reseller_prefixes, associated_options
-
-
-def config_read_prefixed_options(conf, prefix_name, defaults):
-    """
-    Read prefixed options from configuration
-
-    :param conf: the configuration
-    :param prefix_name: the prefix (including, if needed, an underscore)
-    :param defaults: a dict of default values. The dict supplies the
-                     option name and type (string or comma separated string)
-    :return: a dict containing the options
-    """
-    params = {}
-    for option_name in defaults.keys():
-        value = conf.get('%s%s' % (prefix_name, option_name))
-        if value:
-            if isinstance(defaults.get(option_name), list):
-                params[option_name] = []
-                for role in value.lower().split(','):
-                    params[option_name].append(role.strip())
-            else:
-                params[option_name] = value.strip()
-    return params
-
-
-def logging_monkey_patch():
-    # explicitly patch the logging lock
-    logging._lock = logging.threading.RLock()
-    # setup notice level logging
-    logging.addLevelName(NOTICE, 'NOTICE')
-    SysLogHandler.priority_map['NOTICE'] = 'notice'
-    # Trying to log threads while monkey-patched can lead to deadlocks; see
-    # https://bugs.launchpad.net/swift/+bug/1895739
-    logging.logThreads = 0
-
-
 def eventlet_monkey_patch():
     """
     Install the appropriate Eventlet monkey patches.
@@ -505,171 +339,6 @@ def generate_trans_id(trans_id_suffix):
         uuid.uuid4().hex[:21], int(time.time()), quote(trans_id_suffix))
 
 
-def get_policy_index(req_headers, res_headers):
-    """
-    Returns the appropriate index of the storage policy for the request from
-    a proxy server
-
-    :param req_headers: dict of the request headers.
-    :param res_headers: dict of the response headers.
-
-    :returns: string index of storage policy, or None
-    """
-    header = 'X-Backend-Storage-Policy-Index'
-    policy_index = res_headers.get(header, req_headers.get(header))
-    if isinstance(policy_index, six.binary_type) and not six.PY2:
-        policy_index = policy_index.decode('ascii')
-    return str(policy_index) if policy_index is not None else None
-
-
-class LogStringFormatter(string.Formatter):
-    def __init__(self, default='', quote=False):
-        super(LogStringFormatter, self).__init__()
-        self.default = default
-        self.quote = quote
-
-    def format_field(self, value, spec):
-        if not value:
-            return self.default
-        else:
-            log = super(LogStringFormatter, self).format_field(value, spec)
-            if self.quote:
-                return quote(log, ':/{}')
-            else:
-                return log
-
-
-class StrAnonymizer(str):
-    """
-    Class that permits to get a string anonymized or simply quoted.
-    """
-
-    def __new__(cls, data, method, salt):
-        method = method.lower()
-        if method not in (hashlib.algorithms if six.PY2 else
-                          hashlib.algorithms_guaranteed):
-            raise ValueError('Unsupported hashing method: %r' % method)
-        s = str.__new__(cls, data or '')
-        s.method = method
-        s.salt = salt
-        return s
-
-    @property
-    def anonymized(self):
-        if not self:
-            return self
-        else:
-            if self.method == 'md5':
-                h = md5(usedforsecurity=False)
-            else:
-                h = getattr(hashlib, self.method)()
-            if self.salt:
-                h.update(six.b(self.salt))
-            h.update(six.b(self))
-            return '{%s%s}%s' % ('S' if self.salt else '', self.method.upper(),
-                                 h.hexdigest())
-
-
-class StrFormatTime(object):
-    """
-    Class that permits to get formats or parts of a time.
-    """
-
-    def __init__(self, ts):
-        self.time = ts
-        self.time_struct = time.gmtime(ts)
-
-    def __str__(self):
-        return "%.9f" % self.time
-
-    def __getattr__(self, attr):
-        if attr not in ['a', 'A', 'b', 'B', 'c', 'd', 'H',
-                        'I', 'j', 'm', 'M', 'p', 'S', 'U',
-                        'w', 'W', 'x', 'X', 'y', 'Y', 'Z']:
-            raise ValueError(("The attribute %s is not a correct directive "
-                              "for time.strftime formater.") % attr)
-        return datetime.datetime(*self.time_struct[:-2],
-                                 tzinfo=UTC).strftime('%' + attr)
-
-    @property
-    def asctime(self):
-        return time.asctime(self.time_struct)
-
-    @property
-    def datetime(self):
-        return time.strftime('%d/%b/%Y/%H/%M/%S', self.time_struct)
-
-    @property
-    def iso8601(self):
-        return time.strftime('%Y-%m-%dT%H:%M:%S', self.time_struct)
-
-    @property
-    def ms(self):
-        return self.__str__().split('.')[1][:3]
-
-    @property
-    def us(self):
-        return self.__str__().split('.')[1][:6]
-
-    @property
-    def ns(self):
-        return self.__str__().split('.')[1]
-
-    @property
-    def s(self):
-        return self.__str__().split('.')[0]
-
-
-def get_log_line(req, res, trans_time, additional_info, fmt,
-                 anonymization_method, anonymization_salt):
-    """
-    Make a line for logging that matches the documented log line format
-    for backend servers.
-
-    :param req: the request.
-    :param res: the response.
-    :param trans_time: the time the request took to complete, a float.
-    :param additional_info: a string to log at the end of the line
-
-    :returns: a properly formatted line for logging.
-    """
-
-    policy_index = get_policy_index(req.headers, res.headers)
-    if req.path.startswith('/'):
-        disk, partition, account, container, obj = split_path(req.path, 0, 5,
-                                                              True)
-    else:
-        disk, partition, account, container, obj = (None, ) * 5
-    replacements = {
-        'remote_addr': StrAnonymizer(req.remote_addr, anonymization_method,
-                                     anonymization_salt),
-        'time': StrFormatTime(time.time()),
-        'method': req.method,
-        'path': StrAnonymizer(req.path, anonymization_method,
-                              anonymization_salt),
-        'disk': disk,
-        'partition': partition,
-        'account': StrAnonymizer(account, anonymization_method,
-                                 anonymization_salt),
-        'container': StrAnonymizer(container, anonymization_method,
-                                   anonymization_salt),
-        'object': StrAnonymizer(obj, anonymization_method,
-                                anonymization_salt),
-        'status': res.status.split()[0],
-        'content_length': res.content_length,
-        'referer': StrAnonymizer(req.referer, anonymization_method,
-                                 anonymization_salt),
-        'txn_id': req.headers.get('x-trans-id'),
-        'user_agent': StrAnonymizer(req.user_agent, anonymization_method,
-                                    anonymization_salt),
-        'trans_time': trans_time,
-        'additional_info': additional_info,
-        'pid': os.getpid(),
-        'policy_index': policy_index,
-    }
-    return LogStringFormatter(default='-').format(fmt, **replacements)
-
-
 def get_trans_id_time(trans_id):
     if len(trans_id) >= 34 and \
        trans_id.startswith('tx') and trans_id[23] == '-':
@@ -680,25 +349,6 @@ def get_trans_id_time(trans_id):
     return None
 
 
-def config_fallocate_value(reserve_value):
-    """
-    Returns fallocate reserve_value as an int or float.
-    Returns is_percent as a boolean.
-    Returns a ValueError on invalid fallocate value.
-    """
-    try:
-        if str(reserve_value[-1:]) == '%':
-            reserve_value = float(reserve_value[:-1])
-            is_percent = True
-        else:
-            reserve_value = int(reserve_value)
-            is_percent = False
-    except ValueError:
-        raise ValueError('Error: %s is an invalid value for fallocate'
-                         '_reserve.' % reserve_value)
-    return reserve_value, is_percent
-
-
 class FileLikeIter(object):
 
     def __init__(self, iterable):
@@ -1130,53 +780,6 @@ def link_fd_to_path(fd, target_path, dirs_created=0, retries=2, fsync=True):
             dirpath = os.path.dirname(dirpath)
 
 
-def split_path(path, minsegs=1, maxsegs=None, rest_with_last=False):
-    """
-    Validate and split the given HTTP request path.
-
-    **Examples**::
-
-        ['a'] = split_path('/a')
-        ['a', None] = split_path('/a', 1, 2)
-        ['a', 'c'] = split_path('/a/c', 1, 2)
-        ['a', 'c', 'o/r'] = split_path('/a/c/o/r', 1, 3, True)
-
-    :param path: HTTP Request path to be split
-    :param minsegs: Minimum number of segments to be extracted
-    :param maxsegs: Maximum number of segments to be extracted
-    :param rest_with_last: If True, trailing data will be returned as part
-                           of last segment.  If False, and there is
-                           trailing data, raises ValueError.
-    :returns: list of segments with a length of maxsegs (non-existent
-              segments will return as None)
-    :raises ValueError: if given an invalid path
-    """
-    if not maxsegs:
-        maxsegs = minsegs
-    if minsegs > maxsegs:
-        raise ValueError('minsegs > maxsegs: %d > %d' % (minsegs, maxsegs))
-    if rest_with_last:
-        segs = path.split('/', maxsegs)
-        minsegs += 1
-        maxsegs += 1
-        count = len(segs)
-        if (segs[0] or count < minsegs or count > maxsegs or
-                '' in segs[1:minsegs]):
-            raise ValueError('Invalid path: %s' % quote(path))
-    else:
-        minsegs += 1
-        maxsegs += 1
-        segs = path.split('/', maxsegs)
-        count = len(segs)
-        if (segs[0] or count < minsegs or count > maxsegs + 1 or
-                '' in segs[1:minsegs] or
-                (count == maxsegs + 1 and segs[maxsegs])):
-            raise ValueError('Invalid path: %s' % quote(path))
-    segs = segs[1:maxsegs]
-    segs.extend([None] * (maxsegs - 1 - len(segs)))
-    return segs
-
-
 def validate_device_partition(device, partition):
     """
     Validate that a device and a partition are valid and won't lead to
@@ -1251,260 +854,6 @@ class GreenthreadSafeIterator(object):
     __next__ = next
 
 
-class NullLogger(object):
-    """A no-op logger for eventlet wsgi."""
-
-    def write(self, *args):
-        # "Logs" the args to nowhere
-        pass
-
-    def exception(self, *args):
-        pass
-
-    def critical(self, *args):
-        pass
-
-    def error(self, *args):
-        pass
-
-    def warning(self, *args):
-        pass
-
-    def info(self, *args):
-        pass
-
-    def debug(self, *args):
-        pass
-
-    def log(self, *args):
-        pass
-
-
-class LoggerFileObject(object):
-
-    # Note: this is greenthread-local storage
-    _cls_thread_local = threading.local()
-
-    def __init__(self, logger, log_type='STDOUT'):
-        self.logger = logger
-        self.log_type = log_type
-
-    def write(self, value):
-        # We can get into a nasty situation when logs are going to syslog
-        # and syslog dies.
-        #
-        # It's something like this:
-        #
-        # (A) someone logs something
-        #
-        # (B) there's an exception in sending to /dev/log since syslog is
-        #     not working
-        #
-        # (C) logging takes that exception and writes it to stderr (see
-        #     logging.Handler.handleError)
-        #
-        # (D) stderr was replaced with a LoggerFileObject at process start,
-        #     so the LoggerFileObject takes the provided string and tells
-        #     its logger to log it (to syslog, naturally).
-        #
-        # Then, steps B through D repeat until we run out of stack.
-        if getattr(self._cls_thread_local, 'already_called_write', False):
-            return
-
-        self._cls_thread_local.already_called_write = True
-        try:
-            value = value.strip()
-            if value:
-                if 'Connection reset by peer' in value:
-                    self.logger.error(
-                        '%s: Connection reset by peer', self.log_type)
-                else:
-                    self.logger.error('%(type)s: %(value)s',
-                                      {'type': self.log_type, 'value': value})
-        finally:
-            self._cls_thread_local.already_called_write = False
-
-    def writelines(self, values):
-        if getattr(self._cls_thread_local, 'already_called_writelines', False):
-            return
-
-        self._cls_thread_local.already_called_writelines = True
-        try:
-            self.logger.error('%(type)s: %(value)s',
-                              {'type': self.log_type,
-                               'value': '#012'.join(values)})
-        finally:
-            self._cls_thread_local.already_called_writelines = False
-
-    def close(self):
-        pass
-
-    def flush(self):
-        pass
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        raise IOError(errno.EBADF, 'Bad file descriptor')
-    __next__ = next
-
-    def read(self, size=-1):
-        raise IOError(errno.EBADF, 'Bad file descriptor')
-
-    def readline(self, size=-1):
-        raise IOError(errno.EBADF, 'Bad file descriptor')
-
-    def tell(self):
-        return 0
-
-    def xreadlines(self):
-        return self
-
-
-class StatsdClient(object):
-    def __init__(self, host, port, base_prefix='', tail_prefix='',
-                 default_sample_rate=1, sample_rate_factor=1, logger=None):
-        self._host = host
-        self._port = port
-        self._base_prefix = base_prefix
-        self._set_prefix(tail_prefix)
-        self._default_sample_rate = default_sample_rate
-        self._sample_rate_factor = sample_rate_factor
-        self.random = random
-        self.logger = logger
-
-        # Determine if host is IPv4 or IPv6
-        addr_info, self._sock_family = self._determine_sock_family(host, port)
-
-        # NOTE: we use the original host value, not the DNS-resolved one
-        # because if host is a hostname, we don't want to cache the DNS
-        # resolution for the entire lifetime of this process.  Let standard
-        # name resolution caching take effect.  This should help operators use
-        # DNS trickery if they want.
-        if addr_info is not None:
-            # addr_info is a list of 5-tuples with the following structure:
-            #     (family, socktype, proto, canonname, sockaddr)
-            # where sockaddr is the only thing of interest to us, and we only
-            # use the first result.  We want to use the originally supplied
-            # host (see note above) and the remainder of the variable-length
-            # sockaddr: IPv4 has (address, port) while IPv6 has (address,
-            # port, flow info, scope id).
-            sockaddr = addr_info[0][-1]
-            self._target = (host,) + (sockaddr[1:])
-        else:
-            self._target = (host, port)
-
-    def _determine_sock_family(self, host, port):
-        addr_info = sock_family = None
-        try:
-            addr_info = socket.getaddrinfo(host, port, socket.AF_INET)
-            sock_family = socket.AF_INET
-        except socket.gaierror:
-            try:
-                addr_info = socket.getaddrinfo(host, port, socket.AF_INET6)
-                sock_family = socket.AF_INET6
-            except socket.gaierror:
-                # Don't keep the server from starting from what could be a
-                # transient DNS failure.  Any hostname will get re-resolved as
-                # necessary in the .sendto() calls.
-                # However, we don't know if we're IPv4 or IPv6 in this case, so
-                # we assume legacy IPv4.
-                sock_family = socket.AF_INET
-        return addr_info, sock_family
-
-    def _set_prefix(self, tail_prefix):
-        """
-        Modifies the prefix that is added to metric names. The resulting prefix
-        is the concatenation of the component parts `base_prefix` and
-        `tail_prefix`. Only truthy components are included. Each included
-        component is followed by a period, e.g.::
-
-            <base_prefix>.<tail_prefix>.
-            <tail_prefix>.
-            <base_prefix>.
-            <the empty string>
-
-        Note: this method is expected to be called from the constructor only,
-        but exists to provide backwards compatible functionality for the
-        deprecated set_prefix() method.
-
-        :param tail_prefix: The new value of tail_prefix
-        """
-        if tail_prefix and self._base_prefix:
-            self._prefix = '.'.join([self._base_prefix, tail_prefix, ''])
-        elif tail_prefix:
-            self._prefix = tail_prefix + '.'
-        elif self._base_prefix:
-            self._prefix = self._base_prefix + '.'
-        else:
-            self._prefix = ''
-
-    def set_prefix(self, tail_prefix):
-        """
-        This method is deprecated; use the ``tail_prefix`` argument of the
-        constructor when instantiating the class instead.
-        """
-        warnings.warn(
-            'set_prefix() is deprecated; use the ``tail_prefix`` argument of '
-            'the constructor when instantiating the class instead.',
-            DeprecationWarning, stacklevel=2
-        )
-        self._set_prefix(tail_prefix)
-
-    def _send(self, m_name, m_value, m_type, sample_rate):
-        if sample_rate is None:
-            sample_rate = self._default_sample_rate
-        sample_rate = sample_rate * self._sample_rate_factor
-        parts = ['%s%s:%s' % (self._prefix, m_name, m_value), m_type]
-        if sample_rate < 1:
-            if self.random() < sample_rate:
-                parts.append('@%s' % (sample_rate,))
-            else:
-                return
-        if six.PY3:
-            parts = [part.encode('utf-8') for part in parts]
-        # Ideally, we'd cache a sending socket in self, but that
-        # results in a socket getting shared by multiple green threads.
-        with closing(self._open_socket()) as sock:
-            try:
-                return sock.sendto(b'|'.join(parts), self._target)
-            except IOError as err:
-                if self.logger:
-                    self.logger.warning(
-                        'Error sending UDP message to %(target)r: %(err)s',
-                        {'target': self._target, 'err': err})
-
-    def _open_socket(self):
-        return socket.socket(self._sock_family, socket.SOCK_DGRAM)
-
-    def update_stats(self, m_name, m_value, sample_rate=None):
-        return self._send(m_name, m_value, 'c', sample_rate)
-
-    def increment(self, metric, sample_rate=None):
-        return self.update_stats(metric, 1, sample_rate)
-
-    def decrement(self, metric, sample_rate=None):
-        return self.update_stats(metric, -1, sample_rate)
-
-    def _timing(self, metric, timing_ms, sample_rate):
-        # This method was added to disagregate timing metrics when testing
-        return self._send(metric, round(timing_ms, 4), 'ms', sample_rate)
-
-    def timing(self, metric, timing_ms, sample_rate=None):
-        return self._timing(metric, timing_ms, sample_rate)
-
-    def timing_since(self, metric, orig_time, sample_rate=None):
-        return self._timing(metric, (time.time() - orig_time) * 1000,
-                            sample_rate)
-
-    def transfer_rate(self, metric, elapsed_time, byte_xfer, sample_rate=None):
-        if byte_xfer:
-            return self.timing(metric,
-                               elapsed_time * 1000 / byte_xfer * 1000,
-                               sample_rate)
-
-
 def timing_stats(**dec_kwargs):
     """
     Returns a decorator that logs timing events or errors for public methods in
@@ -1557,467 +906,6 @@ def memcached_timing_stats(**dec_kwargs):
     return decorating_func
 
 
-class SwiftLoggerAdapter(logging.LoggerAdapter):
-    """
-    A logging.LoggerAdapter subclass that also passes through StatsD method
-    calls.
-
-    Like logging.LoggerAdapter, you have to subclass this and override the
-    process() method to accomplish anything useful.
-    """
-
-    @property
-    def name(self):
-        # py3 does this for us already; add it for py2
-        return self.logger.name
-
-    def update_stats(self, *a, **kw):
-        return self.logger.update_stats(*a, **kw)
-
-    def increment(self, *a, **kw):
-        return self.logger.increment(*a, **kw)
-
-    def decrement(self, *a, **kw):
-        return self.logger.decrement(*a, **kw)
-
-    def timing(self, *a, **kw):
-        return self.logger.timing(*a, **kw)
-
-    def timing_since(self, *a, **kw):
-        return self.logger.timing_since(*a, **kw)
-
-    def transfer_rate(self, *a, **kw):
-        return self.logger.transfer_rate(*a, **kw)
-
-    @property
-    def thread_locals(self):
-        return self.logger.thread_locals
-
-    @thread_locals.setter
-    def thread_locals(self, thread_locals):
-        self.logger.thread_locals = thread_locals
-
-    def exception(self, msg, *a, **kw):
-        # We up-call to exception() where stdlib uses error() so we can get
-        # some of the traceback suppression from LogAdapter, below
-        self.logger.exception(msg, *a, **kw)
-
-
-class PrefixLoggerAdapter(SwiftLoggerAdapter):
-    """
-    Adds an optional prefix to all its log messages. When the prefix has not
-    been set, messages are unchanged.
-    """
-
-    def set_prefix(self, prefix):
-        self.extra['prefix'] = prefix
-
-    def exception(self, msg, *a, **kw):
-        if 'prefix' in self.extra:
-            msg = self.extra['prefix'] + msg
-        super(PrefixLoggerAdapter, self).exception(msg, *a, **kw)
-
-    def process(self, msg, kwargs):
-        msg, kwargs = super(PrefixLoggerAdapter, self).process(msg, kwargs)
-        if 'prefix' in self.extra:
-            msg = self.extra['prefix'] + msg
-        return (msg, kwargs)
-
-
-# double inheritance to support property with setter
-class LogAdapter(logging.LoggerAdapter, object):
-    """
-    A Logger like object which performs some reformatting on calls to
-    :meth:`exception`.  Can be used to store a threadlocal transaction id and
-    client ip.
-    """
-
-    _cls_thread_local = threading.local()
-
-    def __init__(self, logger, server):
-        logging.LoggerAdapter.__init__(self, logger, {})
-        self.server = server
-        self.warn = self.warning
-
-    # There are a few properties needed for py35; see
-    # - https://bugs.python.org/issue31457
-    # - https://github.com/python/cpython/commit/1bbd482
-    # - https://github.com/python/cpython/commit/0b6a118
-    # - https://github.com/python/cpython/commit/ce9e625
-    def _log(self, level, msg, args, exc_info=None, extra=None,
-             stack_info=False):
-        """
-        Low-level log implementation, proxied to allow nested logger adapters.
-        """
-        return self.logger._log(
-            level,
-            msg,
-            args,
-            exc_info=exc_info,
-            extra=extra,
-            stack_info=stack_info,
-        )
-
-    @property
-    def manager(self):
-        return self.logger.manager
-
-    @manager.setter
-    def manager(self, value):
-        self.logger.manager = value
-
-    @property
-    def name(self):
-        return self.logger.name
-
-    @property
-    def txn_id(self):
-        if hasattr(self._cls_thread_local, 'txn_id'):
-            return self._cls_thread_local.txn_id
-
-    @txn_id.setter
-    def txn_id(self, value):
-        self._cls_thread_local.txn_id = value
-
-    @property
-    def client_ip(self):
-        if hasattr(self._cls_thread_local, 'client_ip'):
-            return self._cls_thread_local.client_ip
-
-    @client_ip.setter
-    def client_ip(self, value):
-        self._cls_thread_local.client_ip = value
-
-    @property
-    def thread_locals(self):
-        return (self.txn_id, self.client_ip)
-
-    @thread_locals.setter
-    def thread_locals(self, value):
-        self.txn_id, self.client_ip = value
-
-    def getEffectiveLevel(self):
-        return self.logger.getEffectiveLevel()
-
-    def process(self, msg, kwargs):
-        """
-        Add extra info to message
-        """
-        kwargs['extra'] = {'server': self.server, 'txn_id': self.txn_id,
-                           'client_ip': self.client_ip}
-        return msg, kwargs
-
-    def notice(self, msg, *args, **kwargs):
-        """
-        Convenience function for syslog priority LOG_NOTICE. The python
-        logging lvl is set to 25, just above info.  SysLogHandler is
-        monkey patched to map this log lvl to the LOG_NOTICE syslog
-        priority.
-        """
-        self.log(NOTICE, msg, *args, **kwargs)
-
-    def _exception(self, msg, *args, **kwargs):
-        logging.LoggerAdapter.exception(self, msg, *args, **kwargs)
-
-    def exception(self, msg, *args, **kwargs):
-        _junk, exc, _junk = sys.exc_info()
-        call = self.error
-        emsg = ''
-        if isinstance(exc, (http_client.BadStatusLine,
-                            green_http_client.BadStatusLine)):
-            # Use error(); not really exceptional
-            emsg = repr(exc)
-            # Note that on py3, we've seen a RemoteDisconnected error getting
-            # raised, which inherits from *both* BadStatusLine and OSError;
-            # we want it getting caught here
-        elif isinstance(exc, (OSError, socket.error)):
-            if exc.errno in (errno.EIO, errno.ENOSPC):
-                emsg = str(exc)
-            elif exc.errno == errno.ECONNREFUSED:
-                emsg = 'Connection refused'
-            elif exc.errno == errno.ECONNRESET:
-                emsg = 'Connection reset'
-            elif exc.errno == errno.EHOSTUNREACH:
-                emsg = 'Host unreachable'
-            elif exc.errno == errno.ENETUNREACH:
-                emsg = 'Network unreachable'
-            elif exc.errno == errno.ETIMEDOUT:
-                emsg = 'Connection timeout'
-            elif exc.errno == errno.EPIPE:
-                emsg = 'Broken pipe'
-            else:
-                call = self._exception
-        elif isinstance(exc, eventlet.Timeout):
-            emsg = exc.__class__.__name__
-            detail = '%ss' % exc.seconds
-            if hasattr(exc, 'created_at'):
-                detail += ' after %0.2fs' % (time.time() - exc.created_at)
-            emsg += ' (%s)' % detail
-            if isinstance(exc, swift.common.exceptions.MessageTimeout):
-                if exc.msg:
-                    emsg += ' %s' % exc.msg
-        else:
-            call = self._exception
-        call('%s: %s' % (msg, emsg), *args, **kwargs)
-
-    def set_statsd_prefix(self, prefix):
-        """
-        This method is deprecated. Callers should use the
-        ``statsd_tail_prefix`` argument of ``get_logger`` when instantiating a
-        logger.
-
-        The StatsD client prefix defaults to the "name" of the logger.  This
-        method may override that default with a specific value.  Currently used
-        in the proxy-server to differentiate the Account, Container, and Object
-        controllers.
-        """
-        warnings.warn(
-            'set_statsd_prefix() is deprecated; use the '
-            '``statsd_tail_prefix`` argument to ``get_logger`` instead.',
-            DeprecationWarning, stacklevel=2
-        )
-        if self.logger.statsd_client:
-            self.logger.statsd_client._set_prefix(prefix)
-
-    def statsd_delegate(statsd_func_name):
-        """
-        Factory to create methods which delegate to methods on
-        self.logger.statsd_client (an instance of StatsdClient).  The
-        created methods conditionally delegate to a method whose name is given
-        in 'statsd_func_name'.  The created delegate methods are a no-op when
-        StatsD logging is not configured.
-
-        :param statsd_func_name: the name of a method on StatsdClient.
-        """
-        func = getattr(StatsdClient, statsd_func_name)
-
-        @functools.wraps(func)
-        def wrapped(self, *a, **kw):
-            if getattr(self.logger, 'statsd_client'):
-                func = getattr(self.logger.statsd_client, statsd_func_name)
-                return func(*a, **kw)
-        return wrapped
-
-    update_stats = statsd_delegate('update_stats')
-    increment = statsd_delegate('increment')
-    decrement = statsd_delegate('decrement')
-    timing = statsd_delegate('timing')
-    timing_since = statsd_delegate('timing_since')
-    transfer_rate = statsd_delegate('transfer_rate')
-
-
-class SwiftLogFormatter(logging.Formatter):
-    """
-    Custom logging.Formatter will append txn_id to a log message if the
-    record has one and the message does not. Optionally it can shorten
-    overly long log lines.
-    """
-
-    def __init__(self, fmt=None, datefmt=None, max_line_length=0):
-        logging.Formatter.__init__(self, fmt=fmt, datefmt=datefmt)
-        self.max_line_length = max_line_length
-
-    def format(self, record):
-        if not hasattr(record, 'server'):
-            # Catch log messages that were not initiated by swift
-            # (for example, the keystone auth middleware)
-            record.server = record.name
-
-        # Included from Python's logging.Formatter and then altered slightly to
-        # replace \n with #012
-        record.message = record.getMessage()
-        if self._fmt.find('%(asctime)') >= 0:
-            record.asctime = self.formatTime(record, self.datefmt)
-        msg = (self._fmt % record.__dict__).replace('\n', '#012')
-        if record.exc_info:
-            # Cache the traceback text to avoid converting it multiple times
-            # (it's constant anyway)
-            if not record.exc_text:
-                record.exc_text = self.formatException(
-                    record.exc_info).replace('\n', '#012')
-        if record.exc_text:
-            if not msg.endswith('#012'):
-                msg = msg + '#012'
-            msg = msg + record.exc_text
-
-        if (hasattr(record, 'txn_id') and record.txn_id and
-                record.txn_id not in msg):
-            msg = "%s (txn: %s)" % (msg, record.txn_id)
-        if (hasattr(record, 'client_ip') and record.client_ip and
-                record.levelno != logging.INFO and
-                record.client_ip not in msg):
-            msg = "%s (client_ip: %s)" % (msg, record.client_ip)
-        if self.max_line_length > 0 and len(msg) > self.max_line_length:
-            if self.max_line_length < 7:
-                msg = msg[:self.max_line_length]
-            else:
-                approxhalf = (self.max_line_length - 5) // 2
-                msg = msg[:approxhalf] + " ... " + msg[-approxhalf:]
-        return msg
-
-
-class LogLevelFilter(object):
-    """
-    Drop messages for the logger based on level.
-
-    This is useful when dependencies log too much information.
-
-    :param level: All messages at or below this level are dropped
-                  (DEBUG < INFO < WARN < ERROR < CRITICAL|FATAL)
-                  Default: DEBUG
-    """
-
-    def __init__(self, level=logging.DEBUG):
-        self.level = level
-
-    def filter(self, record):
-        if record.levelno <= self.level:
-            return 0
-        return 1
-
-
-def get_logger(conf, name=None, log_to_console=False, log_route=None,
-               fmt="%(server)s: %(message)s", statsd_tail_prefix=None):
-    """
-    Get the current system logger using config settings.
-
-    **Log config and defaults**::
-
-        log_facility = LOG_LOCAL0
-        log_level = INFO
-        log_name = swift
-        log_max_line_length = 0
-        log_udp_host = (disabled)
-        log_udp_port = logging.handlers.SYSLOG_UDP_PORT
-        log_address = /dev/log
-        log_statsd_host = (disabled)
-        log_statsd_port = 8125
-        log_statsd_default_sample_rate = 1.0
-        log_statsd_sample_rate_factor = 1.0
-        log_statsd_metric_prefix = (empty-string)
-
-    :param conf: Configuration dict to read settings from
-    :param name: This value is used to populate the ``server`` field in the log
-                 format, as the prefix for statsd messages, and as the default
-                 value for ``log_route``; defaults to the ``log_name`` value in
-                 ``conf``, if it exists, or to 'swift'.
-    :param log_to_console: Add handler which writes to console on stderr
-    :param log_route: Route for the logging, not emitted to the log, just used
-                      to separate logging configurations; defaults to the value
-                      of ``name`` or whatever ``name`` defaults to. This value
-                      is used as the name attribute of the
-                      ``logging.LogAdapter`` that is returned.
-    :param fmt: Override log format
-    :param statsd_tail_prefix: tail prefix to pass to statsd client; if None
-        then the tail prefix defaults to the value of ``name``.
-    :return: an instance of ``LogAdapter``
-    """
-    # note: log_name is typically specified in conf (i.e. defined by
-    # operators), whereas log_route is typically hard-coded in callers of
-    # get_logger (i.e. defined by developers)
-    if not conf:
-        conf = {}
-    if name is None:
-        name = conf.get('log_name', 'swift')
-    if not log_route:
-        log_route = name
-    logger = logging.getLogger(log_route)
-    logger.propagate = False
-    # all new handlers will get the same formatter
-    formatter = SwiftLogFormatter(
-        fmt=fmt, max_line_length=int(conf.get('log_max_line_length', 0)))
-
-    # get_logger will only ever add one SysLog Handler to a logger
-    if not hasattr(get_logger, 'handler4logger'):
-        get_logger.handler4logger = {}
-    if logger in get_logger.handler4logger:
-        logger.removeHandler(get_logger.handler4logger[logger])
-
-    # facility for this logger will be set by last call wins
-    facility = getattr(SysLogHandler, conf.get('log_facility', 'LOG_LOCAL0'),
-                       SysLogHandler.LOG_LOCAL0)
-    udp_host = conf.get('log_udp_host')
-    if udp_host:
-        udp_port = int(conf.get('log_udp_port',
-                                logging.handlers.SYSLOG_UDP_PORT))
-        handler = ThreadSafeSysLogHandler(address=(udp_host, udp_port),
-                                          facility=facility)
-    else:
-        log_address = conf.get('log_address', '/dev/log')
-        handler = None
-        try:
-            mode = os.stat(log_address).st_mode
-            if stat.S_ISSOCK(mode):
-                handler = ThreadSafeSysLogHandler(address=log_address,
-                                                  facility=facility)
-        except (OSError, socket.error) as e:
-            # If either /dev/log isn't a UNIX socket or it does not exist at
-            # all then py2 would raise an error
-            if e.errno not in [errno.ENOTSOCK, errno.ENOENT]:
-                raise
-        if handler is None:
-            # fallback to default UDP
-            handler = ThreadSafeSysLogHandler(facility=facility)
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    get_logger.handler4logger[logger] = handler
-
-    # setup console logging
-    if log_to_console or hasattr(get_logger, 'console_handler4logger'):
-        # remove pre-existing console handler for this logger
-        if not hasattr(get_logger, 'console_handler4logger'):
-            get_logger.console_handler4logger = {}
-        if logger in get_logger.console_handler4logger:
-            logger.removeHandler(get_logger.console_handler4logger[logger])
-
-        console_handler = logging.StreamHandler(sys.__stderr__)
-        console_handler.setFormatter(formatter)
-        logger.addHandler(console_handler)
-        get_logger.console_handler4logger[logger] = console_handler
-
-    # set the level for the logger
-    logger.setLevel(
-        getattr(logging, conf.get('log_level', 'INFO').upper(), logging.INFO))
-
-    # Setup logger with a StatsD client if so configured
-    statsd_host = conf.get('log_statsd_host')
-    if statsd_host:
-        statsd_port = int(conf.get('log_statsd_port', 8125))
-        base_prefix = conf.get('log_statsd_metric_prefix', '')
-        default_sample_rate = float(conf.get(
-            'log_statsd_default_sample_rate', 1))
-        sample_rate_factor = float(conf.get(
-            'log_statsd_sample_rate_factor', 1))
-        if statsd_tail_prefix is None:
-            statsd_tail_prefix = name
-        statsd_client = StatsdClient(statsd_host, statsd_port, base_prefix,
-                                     statsd_tail_prefix, default_sample_rate,
-                                     sample_rate_factor, logger=logger)
-        logger.statsd_client = statsd_client
-    else:
-        logger.statsd_client = None
-
-    adapted_logger = LogAdapter(logger, name)
-    other_handlers = conf.get('log_custom_handlers', None)
-    if other_handlers:
-        log_custom_handlers = [s.strip() for s in other_handlers.split(',')
-                               if s.strip()]
-        for hook in log_custom_handlers:
-            try:
-                mod, fnc = hook.rsplit('.', 1)
-                logger_hook = getattr(__import__(mod, fromlist=[fnc]), fnc)
-                logger_hook(conf, name, log_to_console, log_route, fmt,
-                            logger, adapted_logger)
-            except (AttributeError, ImportError):
-                print('Error calling custom handler [%s]' % hook,
-                      file=sys.stderr)
-            except ValueError:
-                print('Invalid custom handler format [%s]' % hook,
-                      file=sys.stderr)
-
-    return adapted_logger
-
-
 def get_hub():
     """
     Checks whether poll is available and falls back
@@ -2095,43 +983,6 @@ def clean_up_daemon_hygiene():
     os.umask(0o22)  # ensure files are created with the correct privileges
 
 
-def capture_stdio(logger, **kwargs):
-    """
-    Log unhandled exceptions, close stdio, capture stdout and stderr.
-
-    param logger: Logger object to use
-    """
-    # log uncaught exceptions
-    sys.excepthook = lambda * exc_info: \
-        logger.critical('UNCAUGHT EXCEPTION', exc_info=exc_info)
-
-    # collect stdio file desc not in use for logging
-    stdio_files = [sys.stdin, sys.stdout, sys.stderr]
-    console_fds = [h.stream.fileno() for _junk, h in getattr(
-        get_logger, 'console_handler4logger', {}).items()]
-    stdio_files = [f for f in stdio_files if f.fileno() not in console_fds]
-
-    with open(os.devnull, 'r+b') as nullfile:
-        # close stdio (excludes fds open for logging)
-        for f in stdio_files:
-            # some platforms throw an error when attempting an stdin flush
-            try:
-                f.flush()
-            except IOError:
-                pass
-
-            try:
-                os.dup2(nullfile.fileno(), f.fileno())
-            except OSError:
-                pass
-
-    # redirect stdio
-    if kwargs.pop('capture_stdout', True):
-        sys.stdout = LoggerFileObject(logger)
-    if kwargs.pop('capture_stderr', True):
-        sys.stderr = LoggerFileObject(logger, 'STDERR')
-
-
 def parse_options(parser=None, once=False, test_config=False, test_args=None):
     """Parse standard swift server/daemon options with optparse.OptionParser.
 
@@ -2518,119 +1369,6 @@ def cache_from_env(env, allow_none=False):
     return item_from_env(env, 'swift.cache', allow_none)
 
 
-def read_conf_dir(parser, conf_dir):
-    conf_files = []
-    for f in os.listdir(conf_dir):
-        if f.endswith('.conf') and not f.startswith('.'):
-            conf_files.append(os.path.join(conf_dir, f))
-    return parser.read(sorted(conf_files))
-
-
-if six.PY2:
-    NicerInterpolation = None  # just don't cause ImportErrors over in wsgi.py
-else:
-    class NicerInterpolation(configparser.BasicInterpolation):
-        def before_get(self, parser, section, option, value, defaults):
-            if '%(' not in value:
-                return value
-            return super(NicerInterpolation, self).before_get(
-                parser, section, option, value, defaults)
-
-
-def readconf(conf_path, section_name=None, log_name=None, defaults=None,
-             raw=False):
-    """
-    Read config file(s) and return config items as a dict
-
-    :param conf_path: path to config file/directory, or a file-like object
-                     (hasattr readline)
-    :param section_name: config section to read (will return all sections if
-                     not defined)
-    :param log_name: name to be used with logging (will use section_name if
-                     not defined)
-    :param defaults: dict of default values to pre-populate the config with
-    :returns: dict of config items
-    :raises ValueError: if section_name does not exist
-    :raises IOError: if reading the file failed
-    """
-    if defaults is None:
-        defaults = {}
-    if raw:
-        c = RawConfigParser(defaults)
-    else:
-        if six.PY2:
-            c = ConfigParser(defaults)
-        else:
-            # In general, we haven't really thought much about interpolation
-            # in configs. Python's default ConfigParser has always supported
-            # it, though, so *we* got it "for free". Unfortunatley, since we
-            # "supported" interpolation, we have to assume there are
-            # deployments in the wild that use it, and try not to break them.
-            # So, do what we can to mimic the py2 behavior of passing through
-            # values like "1%" (which we want to support for
-            # fallocate_reserve).
-            c = ConfigParser(defaults, interpolation=NicerInterpolation())
-    c.optionxform = str  # Don't lower-case keys
-
-    if hasattr(conf_path, 'readline'):
-        if hasattr(conf_path, 'seek'):
-            conf_path.seek(0)
-        if six.PY2:
-            c.readfp(conf_path)
-        else:
-            c.read_file(conf_path)
-    else:
-        if os.path.isdir(conf_path):
-            # read all configs in directory
-            success = read_conf_dir(c, conf_path)
-        else:
-            success = c.read(conf_path)
-        if not success:
-            raise IOError("Unable to read config from %s" %
-                          conf_path)
-    if section_name:
-        if c.has_section(section_name):
-            conf = dict(c.items(section_name))
-        else:
-            raise ValueError(
-                "Unable to find %(section)s config section in %(conf)s" %
-                {'section': section_name, 'conf': conf_path})
-        if "log_name" not in conf:
-            if log_name is not None:
-                conf['log_name'] = log_name
-            else:
-                conf['log_name'] = section_name
-    else:
-        conf = {}
-        for s in c.sections():
-            conf.update({s: dict(c.items(s))})
-        if 'log_name' not in conf:
-            conf['log_name'] = log_name
-    conf['__file__'] = conf_path
-    return conf
-
-
-def parse_prefixed_conf(conf_file, prefix):
-    """
-    Search the config file for any common-prefix sections and load those
-    sections to a dict mapping the after-prefix reference to options.
-
-    :param conf_file: the file name of the config to parse
-    :param prefix: the common prefix of the sections
-    :return: a dict mapping policy reference -> dict of policy options
-    :raises ValueError: if a policy config section has an invalid name
-    """
-
-    ret_config = {}
-    all_conf = readconf(conf_file)
-    for section, options in all_conf.items():
-        if not section.startswith(prefix):
-            continue
-        target_ref = section[len(prefix):]
-        ret_config[target_ref] = options
-    return ret_config
-
-
 def write_pickle(obj, dest, tmp=None, pickle_protocol=0):
     """
     Ensure that a pickle file gets written to disk.  The file
@@ -2920,13 +1658,19 @@ class AbstractRateLimiter(object):
             running_time < (current time - rate_buffer ms) to allow an initial
             burst.
         """
-        self.max_rate = max_rate
-        self.rate_buffer_ms = rate_buffer * self.clock_accuracy
+        self.set_max_rate(max_rate)
+        self.set_rate_buffer(rate_buffer)
         self.burst_after_idle = burst_after_idle
         self.running_time = running_time
+
+    def set_max_rate(self, max_rate):
+        self.max_rate = max_rate
         self.time_per_incr = (self.clock_accuracy / self.max_rate
                               if self.max_rate else 0)
 
+    def set_rate_buffer(self, rate_buffer):
+        self.rate_buffer_ms = rate_buffer * self.clock_accuracy
+
     def _sleep(self, seconds):
         # subclasses should override to implement a sleep
         raise NotImplementedError
@@ -3255,112 +1999,6 @@ def validate_sync_to(value, allowed_sync_hosts, realms_conf):
     return (None, value, None, None)
 
 
-def affinity_key_function(affinity_str):
-    """Turns an affinity config value into a function suitable for passing to
-    sort(). After doing so, the array will be sorted with respect to the given
-    ordering.
-
-    For example, if affinity_str is "r1=1, r2z7=2, r2z8=2", then the array
-    will be sorted with all nodes from region 1 (r1=1) first, then all the
-    nodes from region 2 zones 7 and 8 (r2z7=2 and r2z8=2), then everything
-    else.
-
-    Note that the order of the pieces of affinity_str is irrelevant; the
-    priority values are what comes after the equals sign.
-
-    If affinity_str is empty or all whitespace, then the resulting function
-    will not alter the ordering of the nodes.
-
-    :param affinity_str: affinity config value, e.g. "r1z2=3"
-                         or "r1=1, r2z1=2, r2z2=2"
-    :returns: single-argument function
-    :raises ValueError: if argument invalid
-    """
-    affinity_str = affinity_str.strip()
-
-    if not affinity_str:
-        return lambda x: 0
-
-    priority_matchers = []
-    pieces = [s.strip() for s in affinity_str.split(',')]
-    for piece in pieces:
-        # matches r<number>=<number> or r<number>z<number>=<number>
-        match = re.match(r"r(\d+)(?:z(\d+))?=(\d+)$", piece)
-        if match:
-            region, zone, priority = match.groups()
-            region = int(region)
-            priority = int(priority)
-            zone = int(zone) if zone else None
-
-            matcher = {'region': region, 'priority': priority}
-            if zone is not None:
-                matcher['zone'] = zone
-            priority_matchers.append(matcher)
-        else:
-            raise ValueError("Invalid affinity value: %r" % affinity_str)
-
-    priority_matchers.sort(key=operator.itemgetter('priority'))
-
-    def keyfn(ring_node):
-        for matcher in priority_matchers:
-            if (matcher['region'] == ring_node['region']
-                and ('zone' not in matcher
-                     or matcher['zone'] == ring_node['zone'])):
-                return matcher['priority']
-        return 4294967296  # 2^32, i.e. "a big number"
-    return keyfn
-
-
-def affinity_locality_predicate(write_affinity_str):
-    """
-    Turns a write-affinity config value into a predicate function for nodes.
-    The returned value will be a 1-arg function that takes a node dictionary
-    and returns a true value if it is "local" and a false value otherwise. The
-    definition of "local" comes from the affinity_str argument passed in here.
-
-    For example, if affinity_str is "r1, r2z2", then only nodes where region=1
-    or where (region=2 and zone=2) are considered local.
-
-    If affinity_str is empty or all whitespace, then the resulting function
-    will consider everything local
-
-    :param write_affinity_str: affinity config value, e.g. "r1z2"
-        or "r1, r2z1, r2z2"
-    :returns: single-argument function, or None if affinity_str is empty
-    :raises ValueError: if argument invalid
-    """
-    affinity_str = write_affinity_str.strip()
-
-    if not affinity_str:
-        return None
-
-    matchers = []
-    pieces = [s.strip() for s in affinity_str.split(',')]
-    for piece in pieces:
-        # matches r<number> or r<number>z<number>
-        match = re.match(r"r(\d+)(?:z(\d+))?$", piece)
-        if match:
-            region, zone = match.groups()
-            region = int(region)
-            zone = int(zone) if zone else None
-
-            matcher = {'region': region}
-            if zone is not None:
-                matcher['zone'] = zone
-            matchers.append(matcher)
-        else:
-            raise ValueError("Invalid write-affinity value: %r" % affinity_str)
-
-    def is_local(ring_node):
-        for matcher in matchers:
-            if (matcher['region'] == ring_node['region']
-                and ('zone' not in matcher
-                     or matcher['zone'] == ring_node['zone'])):
-                return True
-        return False
-    return is_local
-
-
 def get_remote_client(req):
     # remote host for zeus
     client = req.headers.get('x-cluster-client-ip')
@@ -3616,30 +2254,6 @@ def rsync_module_interpolation(template, device):
     return module
 
 
-def get_valid_utf8_str(str_or_unicode):
-    """
-    Get valid parts of utf-8 str from str, unicode and even invalid utf-8 str
-
-    :param str_or_unicode: a string or an unicode which can be invalid utf-8
-    """
-    if six.PY2:
-        if isinstance(str_or_unicode, six.text_type):
-            (str_or_unicode, _len) = utf8_encoder(str_or_unicode, 'replace')
-        (valid_unicode_str, _len) = utf8_decoder(str_or_unicode, 'replace')
-    else:
-        # Apparently under py3 we need to go to utf-16 to collapse surrogates?
-        if isinstance(str_or_unicode, six.binary_type):
-            try:
-                (str_or_unicode, _len) = utf8_decoder(str_or_unicode,
-                                                      'surrogatepass')
-            except UnicodeDecodeError:
-                (str_or_unicode, _len) = utf8_decoder(str_or_unicode,
-                                                      'replace')
-        (str_or_unicode, _len) = utf16_encoder(str_or_unicode, 'surrogatepass')
-        (valid_unicode_str, _len) = utf16_decoder(str_or_unicode, 'replace')
-    return valid_unicode_str.encode('utf-8')
-
-
 class Everything(object):
     """
     A container that contains everything. If "e" is an instance of
@@ -3720,9 +2334,36 @@ class ClosingIterator(object):
         if not self.closed:
             for wrapped in self.closeables:
                 close_if_possible(wrapped)
+            # clear it out so they get GC'ed
+            self.closeables = []
+            self.wrapped_iter = iter([])
             self.closed = True
 
 
+class ClosingMapper(ClosingIterator):
+    """
+    A closing iterator that yields the result of ``function`` as it is applied
+    to each item of ``iterable``.
+
+    Note that while this behaves similarly to the built-in ``map`` function,
+    ``other_closeables`` does not have the same semantic as the ``iterables``
+    argument of ``map``.
+
+    :param function: a function that will be called with each item of
+        ``iterable`` before yielding its result.
+    :param iterable: iterator to wrap.
+    :param other_closeables: other resources to attempt to close.
+    """
+    __slots__ = ('func',)
+
+    def __init__(self, function, iterable, other_closeables=None):
+        self.func = function
+        super(ClosingMapper, self).__init__(iterable, other_closeables)
+
+    def _get_next_item(self):
+        return self.func(super(ClosingMapper, self)._get_next_item())
+
+
 class CloseableChain(ClosingIterator):
     """
     Like itertools.chain, but with a close method that will attempt to invoke
@@ -4172,16 +2813,6 @@ def clean_content_type(value):
     return value
 
 
-def quote(value, safe='/'):
-    """
-    Patched version of urllib.quote that encodes utf-8 strings before quoting
-    """
-    quoted = _quote(get_valid_utf8_str(value), safe)
-    if isinstance(value, six.binary_type):
-        quoted = quoted.encode('utf-8')
-    return quoted
-
-
 def get_expirer_container(x_delete_at, expirer_divisor, acc, cont, obj):
     """
     Returns an expiring object container name for given X-Delete-At and
@@ -4564,27 +3195,6 @@ def parse_content_disposition(header):
     return header, attributes
 
 
-try:
-    _test_md5 = hashlib.md5(usedforsecurity=False)  # nosec
-
-    def md5(string=b'', usedforsecurity=True):
-        """Return an md5 hashlib object using usedforsecurity parameter
-
-        For python distributions that support the usedforsecurity keyword
-        parameter, this passes the parameter through as expected.
-        See https://bugs.python.org/issue9216
-        """
-        return hashlib.md5(string, usedforsecurity=usedforsecurity)  # nosec
-except TypeError:
-    def md5(string=b'', usedforsecurity=True):
-        """Return an md5 hashlib object without usedforsecurity parameter
-
-        For python distributions that do not yet support this keyword
-        parameter, we drop the parameter
-        """
-        return hashlib.md5(string)  # nosec
-
-
 class NamespaceOuterBound(object):
     """
     A custom singleton type to be subclassed for the outer bounds of
@@ -5975,162 +4585,6 @@ def load_pkg_resource(group, uri):
     return entry_points[0].load()
 
 
-class PipeMutex(object):
-    """
-    Mutex using a pipe. Works across both greenlets and real threads, even
-    at the same time.
-    """
-
-    def __init__(self):
-        self.rfd, self.wfd = os.pipe()
-
-        # You can't create a pipe in non-blocking mode; you must set it
-        # later.
-        rflags = fcntl.fcntl(self.rfd, fcntl.F_GETFL)
-        fcntl.fcntl(self.rfd, fcntl.F_SETFL, rflags | os.O_NONBLOCK)
-        os.write(self.wfd, b'-')  # start unlocked
-
-        self.owner = None
-        self.recursion_depth = 0
-
-        # Usually, it's an error to have multiple greenthreads all waiting
-        # to read the same file descriptor. It's often a sign of inadequate
-        # concurrency control; for example, if you have two greenthreads
-        # trying to use the same memcache connection, they'll end up writing
-        # interleaved garbage to the socket or stealing part of each others'
-        # responses.
-        #
-        # In this case, we have multiple greenthreads waiting on the same
-        # file descriptor by design. This lets greenthreads in real thread A
-        # wait with greenthreads in real thread B for the same mutex.
-        # Therefore, we must turn off eventlet's multiple-reader detection.
-        #
-        # It would be better to turn off multiple-reader detection for only
-        # our calls to trampoline(), but eventlet does not support that.
-        eventlet.debug.hub_prevent_multiple_readers(False)
-
-    def acquire(self, blocking=True):
-        """
-        Acquire the mutex.
-
-        If called with blocking=False, returns True if the mutex was
-        acquired and False if it wasn't. Otherwise, blocks until the mutex
-        is acquired and returns True.
-
-        This lock is recursive; the same greenthread may acquire it as many
-        times as it wants to, though it must then release it that many times
-        too.
-        """
-        current_greenthread_id = id(eventlet.greenthread.getcurrent())
-        if self.owner == current_greenthread_id:
-            self.recursion_depth += 1
-            return True
-
-        while True:
-            try:
-                # If there is a byte available, this will read it and remove
-                # it from the pipe. If not, this will raise OSError with
-                # errno=EAGAIN.
-                os.read(self.rfd, 1)
-                self.owner = current_greenthread_id
-                return True
-            except OSError as err:
-                if err.errno != errno.EAGAIN:
-                    raise
-
-                if not blocking:
-                    return False
-
-                # Tell eventlet to suspend the current greenthread until
-                # self.rfd becomes readable. This will happen when someone
-                # else writes to self.wfd.
-                eventlet.hubs.trampoline(self.rfd, read=True)
-
-    def release(self):
-        """
-        Release the mutex.
-        """
-        current_greenthread_id = id(eventlet.greenthread.getcurrent())
-        if self.owner != current_greenthread_id:
-            raise RuntimeError("cannot release un-acquired lock")
-
-        if self.recursion_depth > 0:
-            self.recursion_depth -= 1
-            return
-
-        self.owner = None
-        os.write(self.wfd, b'X')
-
-    def close(self):
-        """
-        Close the mutex. This releases its file descriptors.
-
-        You can't use a mutex after it's been closed.
-        """
-        if self.wfd is not None:
-            os.close(self.rfd)
-            self.rfd = None
-            os.close(self.wfd)
-            self.wfd = None
-        self.owner = None
-        self.recursion_depth = 0
-
-    def __del__(self):
-        # We need this so we don't leak file descriptors. Otherwise, if you
-        # call get_logger() and don't explicitly dispose of it by calling
-        # logger.logger.handlers[0].lock.close() [1], the pipe file
-        # descriptors are leaked.
-        #
-        # This only really comes up in tests. Swift processes tend to call
-        # get_logger() once and then hang on to it until they exit, but the
-        # test suite calls get_logger() a lot.
-        #
-        # [1] and that's a completely ridiculous thing to expect callers to
-        # do, so nobody does it and that's okay.
-        self.close()
-
-
-class NoopMutex(object):
-    """
-    "Mutex" that doesn't lock anything.
-
-    We only allow our syslog logging to be configured via UDS or UDP, neither
-    of which have the message-interleaving trouble you'd expect from TCP or
-    file handlers.
-    """
-
-    def __init__(self):
-        # Usually, it's an error to have multiple greenthreads all waiting
-        # to write to the same file descriptor. It's often a sign of inadequate
-        # concurrency control; for example, if you have two greenthreads
-        # trying to use the same memcache connection, they'll end up writing
-        # interleaved garbage to the socket or stealing part of each others'
-        # responses.
-        #
-        # In this case, we have multiple greenthreads waiting on the same
-        # (logging) file descriptor by design. So, similar to the PipeMutex,
-        # we must turn off eventlet's multiple-waiter detection.
-        #
-        # It would be better to turn off multiple-reader detection for only
-        # the logging socket fd, but eventlet does not support that.
-        eventlet.debug.hub_prevent_multiple_readers(False)
-
-    def acquire(self, blocking=True):
-        pass
-
-    def release(self):
-        pass
-
-
-class ThreadSafeSysLogHandler(SysLogHandler):
-    def createLock(self):
-        if config_true_value(os.environ.get(
-                'SWIFT_NOOP_LOGGING_MUTEX') or 'true'):
-            self.lock = NoopMutex()
-        else:
-            self.lock = PipeMutex()
-
-
 def round_robin_iter(its):
     """
     Takes a list of iterators, yield an element from each in a round-robin
@@ -6432,6 +4886,14 @@ class Watchdog(object):
         if self._run_gth is None:
             self._run_gth = eventlet.spawn(self.run)
 
+    def kill(self):
+        """
+        Stop the watchdog greenthread.
+        """
+        if self._run_gth is not None:
+            self._run_gth.kill()
+            self._run_gth = None
+
     def run(self):
         while True:
             self._run()