swift 2.32.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,
@@ -114,6 +149,7 @@ from swift.common.utils.timestamp import (  # noqa
     EPOCH,
     last_modified_date_to_timestamp,
     normalize_delete_at_timestamp,
+    UTC,
 )
 from swift.common.utils.ipaddrs import (  # noqa
     is_valid_ip,
@@ -123,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
 
@@ -163,13 +197,12 @@ 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
+# the more likely case they've increased the value to optimize high througput
+# transfers this will still cut off the transfer after the first chunk.
+DEFAULT_DRAIN_LIMIT = 65536
 
 
 class InvalidHashPathConfigError(ValueError):
@@ -274,199 +307,6 @@ def backward(f, blocksize=4096):
     yield last_row
 
 
-# Used when reading config values
-TRUE_VALUES = set(('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.
@@ -499,187 +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 _UTC(datetime.tzinfo):
-    """
-    A tzinfo class for datetime objects that returns a 0 timedelta (UTC time)
-    """
-
-    def dst(self, dt):
-        return datetime.timedelta(0)
-    utcoffset = dst
-
-    def tzname(self, dt):
-        return 'UTC'
-
-
-UTC = _UTC()
-
-
-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] == '-':
@@ -690,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):
@@ -830,13 +470,14 @@ class FileLikeIter(object):
         self.closed = True
 
 
-def fs_has_free_space(fs_path, space_needed, is_percent):
+def fs_has_free_space(fs_path_or_fd, space_needed, is_percent):
     """
     Check to see whether or not a filesystem has the given amount of space
     free. Unlike fallocate(), this does not reserve any space.
 
-    :param fs_path: path to a file or directory on the filesystem; typically
-        the path to the filesystem's mount point
+    :param fs_path_or_fd: path to a file or directory on the filesystem, or an
+        open file descriptor; if a directory, typically the path to the
+        filesystem's mount point
 
     :param space_needed: minimum bytes or percentage of free space
 
@@ -849,7 +490,10 @@ def fs_has_free_space(fs_path, space_needed, is_percent):
 
     :raises OSError: if fs_path does not exist
     """
-    st = os.statvfs(fs_path)
+    if isinstance(fs_path_or_fd, int):
+        st = os.fstatvfs(fs_path_or_fd)
+    else:
+        st = os.statvfs(fs_path_or_fd)
     free_bytes = st.f_frsize * st.f_bavail
     if is_percent:
         size_bytes = st.f_frsize * st.f_blocks
@@ -1136,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
@@ -1257,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, timing_ms, '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
@@ -1537,517 +880,30 @@ def timing_stats(**dec_kwargs):
             else:
                 ctrl.logger.timing_since(method + '.errors.timing',
                                          start_time, **dec_kwargs)
-            return resp
-
-        return _timing_stats
-    return decorating_func
-
-
-def memcached_timing_stats(**dec_kwargs):
-    """
-    Returns a decorator that logs timing events or errors for public methods in
-    MemcacheRing class, such as memcached set, get and etc.
-    """
-    def decorating_func(func):
-        method = func.__name__
-
-        @functools.wraps(func)
-        def _timing_stats(cache, *args, **kwargs):
-            start_time = time.time()
-            result = func(cache, *args, **kwargs)
-            cache.logger.timing_since(
-                'memcached.' + method + '.timing', start_time, **dec_kwargs)
-            return result
-
-        return _timing_stats
-    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 get_metric_name(self, metric):
-        # subclasses may override this method to annotate the metric name
-        return metric
-
-    def update_stats(self, metric, *a, **kw):
-        return self.logger.update_stats(self.get_metric_name(metric), *a, **kw)
-
-    def increment(self, metric, *a, **kw):
-        return self.logger.increment(self.get_metric_name(metric), *a, **kw)
-
-    def decrement(self, metric, *a, **kw):
-        return self.logger.decrement(self.get_metric_name(metric), *a, **kw)
-
-    def timing(self, metric, *a, **kw):
-        return self.logger.timing(self.get_metric_name(metric), *a, **kw)
-
-    def timing_since(self, metric, *a, **kw):
-        return self.logger.timing_since(self.get_metric_name(metric), *a, **kw)
-
-    def transfer_rate(self, metric, *a, **kw):
-        return self.logger.transfer_rate(
-            self.get_metric_name(metric), *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)
-
-
-class MetricsPrefixLoggerAdapter(SwiftLoggerAdapter):
-    """
-    Adds a prefix to all Statsd metrics' names.
-    """
-
-    def __init__(self, logger, extra, metric_prefix):
-        """
-        :param logger: an instance of logging.Logger
-        :param extra: a dict-like object
-        :param metric_prefix: A prefix that will be added to the start of each
-            metric name such that the metric name is transformed to:
-            ``<metric_prefix>.<metric name>``. Note that the logger's
-            StatsdClient also adds its configured prefix to metric names.
-        """
-        super(MetricsPrefixLoggerAdapter, self).__init__(logger, extra)
-        self.metric_prefix = metric_prefix
-
-    def get_metric_name(self, metric):
-        return '%s.%s' % (self.metric_prefix, metric)
-
-
-# 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)
+            return resp
 
-    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)
+        return _timing_stats
+    return decorating_func
 
-    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)
+def memcached_timing_stats(**dec_kwargs):
+    """
+    Returns a decorator that logs timing events or errors for public methods in
+    MemcacheRing class, such as memcached set, get and etc.
+    """
+    def decorating_func(func):
+        method = 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)
+        def _timing_stats(cache, *args, **kwargs):
+            start_time = time.time()
+            result = func(cache, *args, **kwargs)
+            cache.logger.timing_since(
+                'memcached.' + method + '.timing', start_time, **dec_kwargs)
+            return result
 
-    return adapted_logger
+        return _timing_stats
+    return decorating_func
 
 
 def get_hub():
@@ -2127,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.
 
@@ -2550,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
@@ -2952,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
@@ -3287,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')
@@ -3425,7 +2031,7 @@ def put_recon_cache_entry(cache_entry, key, item):
 
     If ``item`` is an empty dict then any existing ``key`` in ``cache_entry``
     will be deleted. Similarly if ``item`` is a dict and any of its values are
-    empty dicts then the corrsponsing key will be deleted from the nested dict
+    empty dicts then the corresponding key will be deleted from the nested dict
     in ``cache_entry``.
 
     We use nested recon cache entries when the object auditor
@@ -3648,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
@@ -3704,27 +2286,93 @@ def csv_append(csv_string, item):
         return item
 
 
-class CloseableChain(object):
+class ClosingIterator(object):
     """
-    Like itertools.chain, but with a close method that will attempt to invoke
-    its sub-iterators' close methods, if any.
+    Wrap another iterator and close it, if possible, on completion/exception.
+
+    If other closeable objects are given then they will also be closed when
+    this iterator is closed.
+
+    This is particularly useful for ensuring a generator properly closes its
+    resources, even if the generator was never started.
+
+    This class may be subclassed to override the behavior of
+    ``_get_next_item``.
+
+    :param iterable: iterator to wrap.
+    :param other_closeables: other resources to attempt to close.
     """
+    __slots__ = ('closeables', 'wrapped_iter', 'closed')
 
-    def __init__(self, *iterables):
-        self.iterables = iterables
-        self.chained_iter = itertools.chain(*self.iterables)
+    def __init__(self, iterable, other_closeables=None):
+        self.closeables = [iterable]
+        if other_closeables:
+            self.closeables.extend(other_closeables)
+        # this is usually, but not necessarily, the same object
+        self.wrapped_iter = iter(iterable)
+        self.closed = False
 
     def __iter__(self):
         return self
 
+    def _get_next_item(self):
+        return next(self.wrapped_iter)
+
     def __next__(self):
-        return next(self.chained_iter)
+        try:
+            return self._get_next_item()
+        except Exception:
+            # note: if wrapped_iter is a generator then the exception
+            # already caused it to exit (without raising a GeneratorExit)
+            # but we still need to close any other closeables.
+            self.close()
+            raise
 
     next = __next__  # py2
 
     def close(self):
-        for it in self.iterables:
-            close_if_possible(it)
+        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
+    its sub-iterators' close methods, if any.
+    """
+
+    def __init__(self, *iterables):
+        chained_iter = itertools.chain(*iterables)
+        super(CloseableChain, self).__init__(chained_iter, iterables)
 
 
 def reiterate(iterable):
@@ -4040,7 +2688,7 @@ def closing_if_possible(maybe_closable):
         close_if_possible(maybe_closable)
 
 
-def drain_and_close(response_or_app_iter):
+def drain_and_close(response_or_app_iter, read_limit=None):
     """
     Drain and close a swob or WSGI response.
 
@@ -4050,9 +2698,26 @@ def drain_and_close(response_or_app_iter):
     app_iter = getattr(response_or_app_iter, 'app_iter', response_or_app_iter)
     if app_iter is None:  # for example, if we used the Response.body property
         return
-    for _chunk in app_iter:
-        pass
-    close_if_possible(app_iter)
+    bytes_read = 0
+    with closing_if_possible(app_iter):
+        for chunk in app_iter:
+            bytes_read += len(chunk)
+            if read_limit is not None and bytes_read >= read_limit:
+                break
+
+
+def friendly_close(resp):
+    """
+    Close a swob or WSGI response and maybe drain it.
+
+    It's basically free to "read" a HEAD or HTTPException response - the bytes
+    are probably already in our network buffers.  For a larger response we
+    could possibly burn a lot of CPU/network trying to drain an un-used
+    response.  This method will read up to DEFAULT_DRAIN_LIMIT bytes to avoid
+    logging a 499 in the proxy when it would otherwise be easy to just throw
+    away the small/empty body.
+    """
+    return drain_and_close(resp, read_limit=DEFAULT_DRAIN_LIMIT)
 
 
 _rfc_token = r'[^()<>@,;:\"/\[\]?={}\x00-\x20\x7f]+'
@@ -4148,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
@@ -4396,6 +3051,47 @@ def document_iters_to_multipart_byteranges(ranges_iter, boundary):
     yield terminator
 
 
+class StringAlong(ClosingIterator):
+    """
+    This iterator wraps and iterates over a first iterator until it stops, and
+    then iterates a second iterator, expecting it to stop immediately. This
+    "stringing along" of the second iterator is useful when the exit of the
+    second iterator must be delayed until the first iterator has stopped. For
+    example, when the second iterator has already yielded its item(s) but
+    has resources that mustn't be garbage collected until the first iterator
+    has stopped.
+
+    The second iterator is expected to have no more items and raise
+    StopIteration when called. If this is not the case then
+    ``unexpected_items_func`` is called.
+
+    :param iterable: a first iterator that is wrapped and iterated.
+    :param other_iter: a second iterator that is stopped once the first
+        iterator has stopped.
+    :param unexpected_items_func: a no-arg function that will be called if the
+        second iterator is found to have remaining items.
+    """
+    __slots__ = ('other_iter', 'unexpected_items_func')
+
+    def __init__(self, iterable, other_iter, unexpected_items_func):
+        super(StringAlong, self).__init__(iterable, [other_iter])
+        self.other_iter = other_iter
+        self.unexpected_items_func = unexpected_items_func
+
+    def _get_next_item(self):
+        try:
+            return super(StringAlong, self)._get_next_item()
+        except StopIteration:
+            try:
+                next(self.other_iter)
+            except StopIteration:
+                pass
+            else:
+                self.unexpected_items_func()
+            finally:
+                raise
+
+
 def document_iters_to_http_response_body(ranges_iter, boundary, multipart,
                                          logger):
     """
@@ -4445,20 +3141,11 @@ def document_iters_to_http_response_body(ranges_iter, boundary, multipart,
         # ranges_iter has a finally block that calls close_swift_conn, and
         # so if that finally block fires before we read response_body_iter,
         # there's nothing there.
-        def string_along(useful_iter, useless_iter_iter, logger):
-            with closing_if_possible(useful_iter):
-                for x in useful_iter:
-                    yield x
-
-            try:
-                next(useless_iter_iter)
-            except StopIteration:
-                pass
-            else:
-                logger.warning(
-                    "More than one part in a single-part response?")
-
-        return string_along(response_body_iter, ranges_iter, logger)
+        result = StringAlong(
+            response_body_iter, ranges_iter,
+            lambda: logger.warning(
+                "More than one part in a single-part response?"))
+        return result
 
 
 def multipart_byteranges_to_document_iters(input_file, boundary,
@@ -4508,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
@@ -4562,13 +3228,14 @@ class Namespace(object):
     A Namespace encapsulates parameters that define a range of the object
     namespace.
 
-    :param name: the name of the ``Namespace``.
+    :param name: the name of the ``Namespace``; this SHOULD take the form of a
+        path to a container i.e. <account_name>/<container_name>.
     :param lower: the lower bound of object names contained in the namespace;
         the lower bound *is not* included in the namespace.
     :param upper: the upper bound of object names contained in the namespace;
         the upper bound *is* included in the namespace.
     """
-    __slots__ = ('_lower', '_upper', 'name')
+    __slots__ = ('_lower', '_upper', '_name')
 
     @functools.total_ordering
     class MaxBound(NamespaceOuterBound):
@@ -4588,9 +3255,14 @@ class Namespace(object):
     def __init__(self, name, lower, upper):
         self._lower = Namespace.MIN
         self._upper = Namespace.MAX
+        # We deliberately do not validate that the name has the form 'a/c'
+        # because we want Namespace instantiation to be fast. Namespaces are
+        # typically created using state that has previously been serialized
+        # from a ShardRange instance, and the ShardRange will have validated
+        # the name format.
+        self._name = self._encode(name)
         self.lower = lower
         self.upper = upper
-        self.name = name
 
     def __iter__(self):
         yield 'name', str(self.name)
@@ -4618,7 +3290,7 @@ class Namespace(object):
     def __gt__(self, other):
         # a Namespace is greater than other if its entire namespace is greater
         # than other; if other is another Namespace that implies that this
-        # Namespace's lower must be less greater than or equal to the other
+        # Namespace's lower must be greater than or equal to the other
         # Namespace's upper
         if self.lower == Namespace.MIN:
             return False
@@ -4663,6 +3335,21 @@ class Namespace(object):
             raise TypeError('must be a string type')
         return self._encode(bound)
 
+    @property
+    def account(self):
+        return self._name.split('/')[0]
+
+    @property
+    def container(self):
+        # note: this may raise an IndexError if name does not have the expected
+        # form 'a/c'; that is a deliberate trade-off against the overhead of
+        # validating the name every time a Namespace is instantiated.
+        return self._name.split('/')[1]
+
+    @property
+    def name(self):
+        return self._name
+
     @property
     def lower(self):
         return self._lower
@@ -4988,7 +3675,7 @@ class ShardRange(Namespace):
     range record and the most recent version of an attribute should be
     persisted.
 
-    :param name: the name of the shard range; this should take the form of a
+    :param name: the name of the shard range; this MUST take the form of a
         path to a container i.e. <account_name>/<container_name>.
     :param timestamp: a timestamp that represents the time at which the
         shard range's ``lower``, ``upper`` or ``deleted`` attributes were
@@ -5046,7 +3733,6 @@ class ShardRange(Namespace):
     CLEAVING_STATES = SHRINKING_STATES + SHARDING_STATES
 
     __slots__ = (
-        'account', 'container',
         '_timestamp', '_meta_timestamp', '_state_timestamp', '_epoch',
         '_deleted', '_state', '_count', '_bytes',
         '_tombstones', '_reported')
@@ -5057,12 +3743,12 @@ class ShardRange(Namespace):
                  deleted=False, state=None, state_timestamp=None, epoch=None,
                  reported=False, tombstones=-1, **kwargs):
         super(ShardRange, self).__init__(name=name, lower=lower, upper=upper)
-        self.account = self.container = self._timestamp = \
-            self._meta_timestamp = self._state_timestamp = self._epoch = None
+        self._validate_name(self.name)
+        self._timestamp = self._meta_timestamp = self._state_timestamp = \
+            self._epoch = None
         self._deleted = False
         self._state = None
 
-        self.name = name
         self.timestamp = timestamp
         self.deleted = deleted
         self.object_count = object_count
@@ -5076,11 +3762,18 @@ class ShardRange(Namespace):
 
     @classmethod
     def sort_key(cls, sr):
+        return cls.sort_key_order(sr.name, sr.lower, sr.upper, sr.state)
+
+    @staticmethod
+    def sort_key_order(name, lower, upper, state):
+        # Use Namespace.MaxBound() for upper bound '', this will allow this
+        # record to be sorted correctly by upper.
+        upper = upper if upper else Namespace.MaxBound()
         # defines the sort order for shard ranges
         # note if this ever changes to *not* sort by upper first then it breaks
         # a key assumption for bisect, which is used by utils.find_namespace
         # with shard ranges.
-        return sr.upper, sr.state, sr.lower, sr.name
+        return upper, state, lower, name
 
     def is_child_of(self, parent):
         """
@@ -5221,16 +3914,24 @@ class ShardRange(Namespace):
 
     @property
     def name(self):
-        return '%s/%s' % (self.account, self.container)
-
-    @name.setter
-    def name(self, path):
-        path = self._encode(path)
-        if not path or len(path.split('/')) != 2 or not all(path.split('/')):
+        return self._name
+
+    @staticmethod
+    def _validate_name(name):
+        # Validate the name format is 'a/c'. The ShardRange class is typically
+        # used when shard state is created (e.g. by the sharder or
+        # swift-manage-shard-ranges), but it is not typically used in
+        # performance sensitive paths (e.g. listing namespaces), so we can
+        # afford the overhead of being more defensive here.
+        if not name or len(name.split('/')) != 2 or not all(name.split('/')):
             raise ValueError(
                 "Name must be of the form '<account>/<container>', got %r" %
-                path)
-        self.account, self.container = path.split('/')
+                name)
+        return name
+
+    @name.setter
+    def name(self, name):
+        self._name = self._validate_name(self._encode(name))
 
     @property
     def timestamp(self):
@@ -5533,7 +4234,7 @@ class ShardRangeList(UserList):
     def __getitem__(self, index):
         # workaround for py3 - not needed for py2.7,py3.8
         result = self.data[index]
-        return ShardRangeList(result) if type(result) == list else result
+        return ShardRangeList(result) if type(result) is list else result
 
     @property
     def lower(self):
@@ -5884,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
@@ -6228,17 +4773,28 @@ def get_db_files(db_path):
     return sorted(results)
 
 
-def systemd_notify(logger=None):
+def systemd_notify(logger=None, msg=b"READY=1"):
     """
-    Notify the service manager that started this process, if it is
-    systemd-compatible, that this process correctly started. To do so,
-    it communicates through a Unix socket stored in environment variable
-    NOTIFY_SOCKET. More information can be found in systemd documentation:
+    Send systemd-compatible notifications.
+
+    Notify the service manager that started this process, if it has set the
+    NOTIFY_SOCKET environment variable. For example, systemd will set this
+    when the unit has ``Type=notify``. More information can be found in
+    systemd documentation:
     https://www.freedesktop.org/software/systemd/man/sd_notify.html
 
+    Common messages include::
+
+       READY=1
+       RELOADING=1
+       STOPPING=1
+       STATUS=<some string>
+
     :param logger: a logger object
+    :param msg: the message to send
     """
-    msg = b'READY=1'
+    if not isinstance(msg, bytes):
+        msg = msg.encode('utf8')
     notify_socket = os.getenv('NOTIFY_SOCKET')
     if notify_socket:
         if notify_socket.startswith('@'):
@@ -6249,7 +4805,6 @@ def systemd_notify(logger=None):
             try:
                 sock.connect(notify_socket)
                 sock.sendall(msg)
-                del os.environ['NOTIFY_SOCKET']
             except EnvironmentError:
                 if logger:
                     logger.debug("Systemd notification failed", exc_info=True)
@@ -6320,7 +4875,7 @@ class Watchdog(object):
         :param key: timeout id, as returned by start()
         """
         try:
-            del(self._timeouts[key])
+            del self._timeouts[key]
         except KeyError:
             pass
 
@@ -6331,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()
@@ -6385,7 +4948,7 @@ class WatchdogTimeout(object):
         self.watchdog.stop(self.key)
 
 
-class CooperativeIterator(object):
+class CooperativeIterator(ClosingIterator):
     """
     Wrapper to make a deliberate periodic call to ``sleep()`` while iterating
     over wrapped iterator, providing an opportunity to switch greenthreads.
@@ -6405,26 +4968,20 @@ class CooperativeIterator(object):
 
     :param iterable: iterator to wrap.
     :param period: number of items yielded from this iterator between calls to
-        ``sleep()``.
+        ``sleep()``; a negative value or 0 mean that cooperative sleep will be
+        disabled.
     """
-    __slots__ = ('period', 'count', 'wrapped_iter')
+    __slots__ = ('period', 'count')
 
     def __init__(self, iterable, period=5):
-        self.wrapped_iter = iterable
+        super(CooperativeIterator, self).__init__(iterable)
         self.count = 0
-        self.period = period
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        if self.count >= self.period:
-            self.count = 0
-            sleep()
-        self.count += 1
-        return next(self.wrapped_iter)
-
-    __next__ = next
-
-    def close(self):
-        close_if_possible(self.wrapped_iter)
+        self.period = max(0, period or 0)
+
+    def _get_next_item(self):
+        if self.period:
+            if self.count >= self.period:
+                self.count = 0
+                sleep()
+            self.count += 1
+        return super(CooperativeIterator, self)._get_next_item()