swift 2.31.1__py2.py3-none-any.whl → 2.32.1__py2.py3-none-any.whl

swift/common/{utils.py → utils/__init__.py}

@@ -26,7 +26,6 @@ import fcntl
 import grp
 import hashlib
 import json
-import math
 import operator
 import os
 import pwd
@@ -37,7 +36,6 @@ import sys
 import time
 import uuid
 import functools
-import platform
 import email.parser
 from random import random, shuffle
 from contextlib import contextmanager, closing
@@ -69,7 +67,6 @@ from eventlet.event import Event
 from eventlet.green import socket, threading
 import eventlet.hubs
 import eventlet.queue
-import netifaces
 import codecs
 utf8_decoder = codecs.getdecoder('utf-8')
 utf8_encoder = codecs.getencoder('utf-8')
@@ -89,36 +86,50 @@ from six.moves.urllib.parse import quote as _quote, unquote
 from six.moves.urllib.parse import urlparse
 from six.moves import UserList
 
-from swift import gettext_ as _
 import swift.common.exceptions
 from swift.common.http import is_server_error
 from swift.common.header_key_dict import HeaderKeyDict
 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
-
-# logging doesn't import patched as cleanly as one would like
+from swift.common.registry import register_swift_info, get_swift_info  # noqa
+from swift.common.utils.libc import (  # noqa
+    F_SETPIPE_SZ,
+    load_libc_function,
+    drop_buffer_cache,
+    get_md5_socket,
+    modify_priority,
+    _LibcWrapper,
+)
+from swift.common.utils.timestamp import (  # noqa
+    NORMAL_FORMAT,
+    INTERNAL_FORMAT,
+    SHORT_FORMAT,
+    MAX_OFFSET,
+    PRECISION,
+    Timestamp,
+    encode_timestamps,
+    decode_timestamps,
+    normalize_timestamp,
+    EPOCH,
+    last_modified_date_to_timestamp,
+    normalize_delete_at_timestamp,
+)
+from swift.common.utils.ipaddrs import (  # noqa
+    is_valid_ip,
+    is_valid_ipv4,
+    is_valid_ipv6,
+    expand_ipv6,
+    parse_socket_string,
+    whataremyips,
+)
 from logging.handlers import SysLogHandler
 import logging
-logging.thread = eventlet.green.thread
-logging.threading = eventlet.green.threading
-logging._lock = logging.threading.RLock()
-# setup notice level logging
+
 NOTICE = 25
-logging.addLevelName(NOTICE, 'NOTICE')
-SysLogHandler.priority_map['NOTICE'] = 'notice'
 
 # These are lazily pulled from libc elsewhere
 _sys_fallocate = None
-_posix_fadvise = None
-_libc_socket = None
-_libc_bind = None
-_libc_accept = None
-# see man -s 2 setpriority
-_libc_setpriority = None
-# see man -s 2 syscall
-_posix_syscall = None
 
 # If set to non-zero, fallocate routines will fail based on free space
 # available being at or below this amount, in bytes.
@@ -131,56 +142,6 @@ FALLOCATE_IS_PERCENT = False
 FALLOC_FL_KEEP_SIZE = 1
 FALLOC_FL_PUNCH_HOLE = 2
 
-# from /usr/src/linux-headers-*/include/uapi/linux/resource.h
-PRIO_PROCESS = 0
-
-
-# /usr/include/x86_64-linux-gnu/asm/unistd_64.h defines syscalls there
-# are many like it, but this one is mine, see man -s 2 ioprio_set
-def NR_ioprio_set():
-    """Give __NR_ioprio_set value for your system."""
-    architecture = os.uname()[4]
-    arch_bits = platform.architecture()[0]
-    # check if supported system, now support x86_64 and AArch64
-    if architecture == 'x86_64' and arch_bits == '64bit':
-        return 251
-    elif architecture == 'aarch64' and arch_bits == '64bit':
-        return 30
-    raise OSError("Swift doesn't support ionice priority for %s %s" %
-                  (architecture, arch_bits))
-
-
-# this syscall integer probably only works on x86_64 linux systems, you
-# can check if it's correct on yours with something like this:
-"""
-#include <stdio.h>
-#include <sys/syscall.h>
-
-int main(int argc, const char* argv[]) {
-    printf("%d\n", __NR_ioprio_set);
-    return 0;
-}
-"""
-
-# this is the value for "which" that says our who value will be a pid
-# pulled out of /usr/src/linux-headers-*/include/linux/ioprio.h
-IOPRIO_WHO_PROCESS = 1
-
-
-IO_CLASS_ENUM = {
-    'IOPRIO_CLASS_RT': 1,
-    'IOPRIO_CLASS_BE': 2,
-    'IOPRIO_CLASS_IDLE': 3,
-}
-
-# the IOPRIO_PRIO_VALUE "macro" is also pulled from
-# /usr/src/linux-headers-*/include/linux/ioprio.h
-IOPRIO_CLASS_SHIFT = 13
-
-
-def IOPRIO_PRIO_VALUE(class_, data):
-    return (((class_) << IOPRIO_CLASS_SHIFT) | data)
-
 
 # Used by hash_path to offer a bit more security when generating hashes for
 # paths. It simply appends this value to all paths; guessing the hash a path
@@ -194,13 +155,8 @@ SWIFT_CONF_FILE = '/etc/swift/swift.conf'
 # about them. We ask anyway just in case that ever gets fixed.
 #
 # The values were copied from the Linux 3.x kernel headers.
-AF_ALG = getattr(socket, 'AF_ALG', 38)
-F_SETPIPE_SZ = getattr(fcntl, 'F_SETPIPE_SZ', 1031)
 O_TMPFILE = getattr(os, 'O_TMPFILE', 0o20000000 | os.O_DIRECTORY)
 
-# Used by the parse_socket_string() function to validate IPv6 addresses
-IPV6_RE = re.compile(r"^\[(?P<address>.*)\](:(?P<port>[0-9]+))?$")
-
 MD5_OF_EMPTY_STRING = 'd41d8cd98f00b204e9800998ecf8427e'
 RESERVED_BYTE = b'\x00'
 RESERVED_STR = u'\x00'
@@ -500,6 +456,17 @@ def config_read_prefixed_options(conf, prefix_name, defaults):
     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.
@@ -510,13 +477,14 @@ def eventlet_monkey_patch():
     #         if thread is monkey-patched.
     eventlet.patcher.monkey_patch(all=False, socket=True, select=True,
                                   thread=True)
-    # Trying to log threads while monkey-patched can lead to deadlocks; see
-    # https://bugs.launchpad.net/swift/+bug/1895739
-    logging.logThreads = 0
 
 
-def noop_libc_function(*args):
-    return 0
+def monkey_patch():
+    """
+    Apply all swift monkey patching consistently in one place.
+    """
+    eventlet_monkey_patch()
+    logging_monkey_patch()
 
 
 def validate_configuration():
@@ -526,39 +494,6 @@ def validate_configuration():
         sys.exit("Error: %s" % e)
 
 
-def load_libc_function(func_name, log_error=True,
-                       fail_if_missing=False, errcheck=False):
-    """
-    Attempt to find the function in libc, otherwise return a no-op func.
-
-    :param func_name: name of the function to pull from libc.
-    :param log_error: log an error when a function can't be found
-    :param fail_if_missing: raise an exception when a function can't be found.
-                            Default behavior is to return a no-op function.
-    :param errcheck: boolean, if true install a wrapper on the function
-                     to check for a return values of -1 and call
-                     ctype.get_errno and raise an OSError
-    """
-    try:
-        libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
-        func = getattr(libc, func_name)
-    except AttributeError:
-        if fail_if_missing:
-            raise
-        if log_error:
-            logging.warning(_("Unable to locate %s in libc.  Leaving as a "
-                            "no-op."), func_name)
-        return noop_libc_function
-    if errcheck:
-        def _errcheck(result, f, args):
-            if result == -1:
-                errcode = ctypes.get_errno()
-                raise OSError(errcode, os.strerror(errcode))
-            return result
-        func.errcheck = _errcheck
-    return func
-
-
 def generate_trans_id(trans_id_suffix):
     return 'tx%s-%010x%s' % (
         uuid.uuid4().hex[:21], int(time.time()), quote(trans_id_suffix))
@@ -585,6 +520,7 @@ 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
@@ -923,53 +859,6 @@ def fs_has_free_space(fs_path, space_needed, is_percent):
         return free_bytes >= space_needed
 
 
-class _LibcWrapper(object):
-    """
-    A callable object that forwards its calls to a C function from libc.
-
-    These objects are lazy. libc will not be checked until someone tries to
-    either call the function or check its availability.
-
-    _LibcWrapper objects have an "available" property; if true, then libc
-    has the function of that name. If false, then calls will fail with a
-    NotImplementedError.
-    """
-    def __init__(self, func_name):
-        self._func_name = func_name
-        self._func_handle = None
-        self._loaded = False
-
-    def _ensure_loaded(self):
-        if not self._loaded:
-            func_name = self._func_name
-            try:
-                # Keep everything in this try-block in local variables so
-                # that a typo in self.some_attribute_name doesn't raise a
-                # spurious AttributeError.
-                func_handle = load_libc_function(
-                    func_name, fail_if_missing=True)
-                self._func_handle = func_handle
-            except AttributeError:
-                # We pass fail_if_missing=True to load_libc_function and
-                # then ignore the error. It's weird, but otherwise we have
-                # to check if self._func_handle is noop_libc_function, and
-                # that's even weirder.
-                pass
-            self._loaded = True
-
-    @property
-    def available(self):
-        self._ensure_loaded()
-        return bool(self._func_handle)
-
-    def __call__(self, *args):
-        if self.available:
-            return self._func_handle(*args)
-        else:
-            raise NotImplementedError(
-                "No function %r found in libc" % self._func_name)
-
-
 _fallocate_enabled = True
 _fallocate_warned_about_missing = False
 _sys_fallocate = _LibcWrapper('fallocate')
@@ -1036,8 +925,8 @@ def fallocate(fd, size, offset=0):
         # but just once per process, and then do nothing.
         global _fallocate_warned_about_missing
         if not _fallocate_warned_about_missing:
-            logging.warning(_("Unable to locate fallocate, posix_fallocate in "
-                              "libc.  Leaving as a no-op."))
+            logging.warning("Unable to locate fallocate, posix_fallocate in "
+                            "libc.  Leaving as a no-op.")
             _fallocate_warned_about_missing = True
         return
 
@@ -1121,410 +1010,14 @@ def fsync_dir(dirpath):
         if err.errno == errno.ENOTDIR:
             # Raise error if someone calls fsync_dir on a non-directory
             raise
-        logging.warning(_('Unable to perform fsync() on directory %(dir)s:'
-                          ' %(err)s'),
+        logging.warning('Unable to perform fsync() on directory %(dir)s:'
+                        ' %(err)s',
                         {'dir': dirpath, 'err': os.strerror(err.errno)})
     finally:
         if dirfd:
             os.close(dirfd)
 
 
-def drop_buffer_cache(fd, offset, length):
-    """
-    Drop 'buffer' cache for the given range of the given file.
-
-    :param fd: file descriptor
-    :param offset: start offset
-    :param length: length
-    """
-    global _posix_fadvise
-    if _posix_fadvise is None:
-        _posix_fadvise = load_libc_function('posix_fadvise64')
-    # 4 means "POSIX_FADV_DONTNEED"
-    ret = _posix_fadvise(fd, ctypes.c_uint64(offset),
-                         ctypes.c_uint64(length), 4)
-    if ret != 0:
-        logging.warning("posix_fadvise64(%(fd)s, %(offset)s, %(length)s, 4) "
-                        "-> %(ret)s", {'fd': fd, 'offset': offset,
-                                       'length': length, 'ret': ret})
-
-
-NORMAL_FORMAT = "%016.05f"
-INTERNAL_FORMAT = NORMAL_FORMAT + '_%016x'
-SHORT_FORMAT = NORMAL_FORMAT + '_%x'
-MAX_OFFSET = (16 ** 16) - 1
-PRECISION = 1e-5
-# Setting this to True will cause the internal format to always display
-# extended digits - even when the value is equivalent to the normalized form.
-# This isn't ideal during an upgrade when some servers might not understand
-# the new time format - but flipping it to True works great for testing.
-FORCE_INTERNAL = False  # or True
-
-
-@functools.total_ordering
-class Timestamp(object):
-    """
-    Internal Representation of Swift Time.
-
-    The normalized form of the X-Timestamp header looks like a float
-    with a fixed width to ensure stable string sorting - normalized
-    timestamps look like "1402464677.04188"
-
-    To support overwrites of existing data without modifying the original
-    timestamp but still maintain consistency a second internal offset vector
-    is append to the normalized timestamp form which compares and sorts
-    greater than the fixed width float format but less than a newer timestamp.
-    The internalized format of timestamps looks like
-    "1402464677.04188_0000000000000000" - the portion after the underscore is
-    the offset and is a formatted hexadecimal integer.
-
-    The internalized form is not exposed to clients in responses from
-    Swift.  Normal client operations will not create a timestamp with an
-    offset.
-
-    The Timestamp class in common.utils supports internalized and
-    normalized formatting of timestamps and also comparison of timestamp
-    values.  When the offset value of a Timestamp is 0 - it's considered
-    insignificant and need not be represented in the string format; to
-    support backwards compatibility during a Swift upgrade the
-    internalized and normalized form of a Timestamp with an
-    insignificant offset are identical.  When a timestamp includes an
-    offset it will always be represented in the internalized form, but
-    is still excluded from the normalized form.  Timestamps with an
-    equivalent timestamp portion (the float part) will compare and order
-    by their offset.  Timestamps with a greater timestamp portion will
-    always compare and order greater than a Timestamp with a lesser
-    timestamp regardless of it's offset.  String comparison and ordering
-    is guaranteed for the internalized string format, and is backwards
-    compatible for normalized timestamps which do not include an offset.
-    """
-
-    def __init__(self, timestamp, offset=0, delta=0, check_bounds=True):
-        """
-        Create a new Timestamp.
-
-        :param timestamp: time in seconds since the Epoch, may be any of:
-
-            * a float or integer
-            * normalized/internalized string
-            * another instance of this class (offset is preserved)
-
-        :param offset: the second internal offset vector, an int
-        :param delta: deca-microsecond difference from the base timestamp
-                      param, an int
-        """
-        if isinstance(timestamp, bytes):
-            timestamp = timestamp.decode('ascii')
-        if isinstance(timestamp, six.string_types):
-            base, base_offset = timestamp.partition('_')[::2]
-            self.timestamp = float(base)
-            if '_' in base_offset:
-                raise ValueError('invalid literal for int() with base 16: '
-                                 '%r' % base_offset)
-            if base_offset:
-                self.offset = int(base_offset, 16)
-            else:
-                self.offset = 0
-        else:
-            self.timestamp = float(timestamp)
-            self.offset = getattr(timestamp, 'offset', 0)
-        # increment offset
-        if offset >= 0:
-            self.offset += offset
-        else:
-            raise ValueError('offset must be non-negative')
-        if self.offset > MAX_OFFSET:
-            raise ValueError('offset must be smaller than %d' % MAX_OFFSET)
-        self.raw = int(round(self.timestamp / PRECISION))
-        # add delta
-        if delta:
-            self.raw = self.raw + delta
-            if self.raw <= 0:
-                raise ValueError(
-                    'delta must be greater than %d' % (-1 * self.raw))
-            self.timestamp = float(self.raw * PRECISION)
-        if check_bounds:
-            if self.timestamp < 0:
-                raise ValueError('timestamp cannot be negative')
-            if self.timestamp >= 10000000000:
-                raise ValueError('timestamp too large')
-
-    @classmethod
-    def now(cls, offset=0, delta=0):
-        return cls(time.time(), offset=offset, delta=delta)
-
-    def __repr__(self):
-        return INTERNAL_FORMAT % (self.timestamp, self.offset)
-
-    def __str__(self):
-        raise TypeError('You must specify which string format is required')
-
-    def __float__(self):
-        return self.timestamp
-
-    def __int__(self):
-        return int(self.timestamp)
-
-    def __nonzero__(self):
-        return bool(self.timestamp or self.offset)
-
-    def __bool__(self):
-        return self.__nonzero__()
-
-    @property
-    def normal(self):
-        return NORMAL_FORMAT % self.timestamp
-
-    @property
-    def internal(self):
-        if self.offset or FORCE_INTERNAL:
-            return INTERNAL_FORMAT % (self.timestamp, self.offset)
-        else:
-            return self.normal
-
-    @property
-    def short(self):
-        if self.offset or FORCE_INTERNAL:
-            return SHORT_FORMAT % (self.timestamp, self.offset)
-        else:
-            return self.normal
-
-    @property
-    def isoformat(self):
-        """
-        Get an isoformat string representation of the 'normal' part of the
-        Timestamp with microsecond precision and no trailing timezone, for
-        example::
-
-            1970-01-01T00:00:00.000000
-
-        :return: an isoformat string
-        """
-        t = float(self.normal)
-        if six.PY3:
-            # On Python 3, round manually using ROUND_HALF_EVEN rounding
-            # method, to use the same rounding method than Python 2. Python 3
-            # used a different rounding method, but Python 3.4.4 and 3.5.1 use
-            # again ROUND_HALF_EVEN as Python 2.
-            # See https://bugs.python.org/issue23517
-            frac, t = math.modf(t)
-            us = round(frac * 1e6)
-            if us >= 1000000:
-                t += 1
-                us -= 1000000
-            elif us < 0:
-                t -= 1
-                us += 1000000
-            dt = datetime.datetime.utcfromtimestamp(t)
-            dt = dt.replace(microsecond=us)
-        else:
-            dt = datetime.datetime.utcfromtimestamp(t)
-
-        isoformat = dt.isoformat()
-        # python isoformat() doesn't include msecs when zero
-        if len(isoformat) < len("1970-01-01T00:00:00.000000"):
-            isoformat += ".000000"
-        return isoformat
-
-    @classmethod
-    def from_isoformat(cls, date_string):
-        """
-        Parse an isoformat string representation of time to a Timestamp object.
-
-        :param date_string: a string formatted as per an Timestamp.isoformat
-            property.
-        :return: an instance of  this class.
-        """
-        start = datetime.datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%S.%f")
-        delta = start - EPOCH
-        # This calculation is based on Python 2.7's Modules/datetimemodule.c,
-        # function delta_to_microseconds(), but written in Python.
-        return cls(delta.total_seconds())
-
-    def ceil(self):
-        """
-        Return the 'normal' part of the timestamp rounded up to the nearest
-        integer number of seconds.
-
-        This value should be used whenever the second-precision Last-Modified
-        time of a resource is required.
-
-        :return: a float value with second precision.
-        """
-        return math.ceil(float(self))
-
-    def __eq__(self, other):
-        if other is None:
-            return False
-        if not isinstance(other, Timestamp):
-            try:
-                other = Timestamp(other, check_bounds=False)
-            except ValueError:
-                return False
-        return self.internal == other.internal
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __lt__(self, other):
-        if other is None:
-            return False
-        if not isinstance(other, Timestamp):
-            other = Timestamp(other, check_bounds=False)
-        if other.timestamp < 0:
-            return False
-        if other.timestamp >= 10000000000:
-            return True
-        return self.internal < other.internal
-
-    def __hash__(self):
-        return hash(self.internal)
-
-    def __invert__(self):
-        if self.offset:
-            raise ValueError('Cannot invert timestamps with offsets')
-        return Timestamp((999999999999999 - self.raw) * PRECISION)
-
-
-def encode_timestamps(t1, t2=None, t3=None, explicit=False):
-    """
-    Encode up to three timestamps into a string. Unlike a Timestamp object, the
-    encoded string does NOT used fixed width fields and consequently no
-    relative chronology of the timestamps can be inferred from lexicographic
-    sorting of encoded timestamp strings.
-
-    The format of the encoded string is:
-        <t1>[<+/-><t2 - t1>[<+/-><t3 - t2>]]
-
-    i.e. if t1 = t2 = t3 then just the string representation of t1 is returned,
-    otherwise the time offsets for t2 and t3 are appended. If explicit is True
-    then the offsets for t2 and t3 are always appended even if zero.
-
-    Note: any offset value in t1 will be preserved, but offsets on t2 and t3
-    are not preserved. In the anticipated use cases for this method (and the
-    inverse decode_timestamps method) the timestamps passed as t2 and t3 are
-    not expected to have offsets as they will be timestamps associated with a
-    POST request. In the case where the encoding is used in a container objects
-    table row, t1 could be the PUT or DELETE time but t2 and t3 represent the
-    content type and metadata times (if different from the data file) i.e.
-    correspond to POST timestamps. In the case where the encoded form is used
-    in a .meta file name, t1 and t2 both correspond to POST timestamps.
-    """
-    form = '{0}'
-    values = [t1.short]
-    if t2 is not None:
-        t2_t1_delta = t2.raw - t1.raw
-        explicit = explicit or (t2_t1_delta != 0)
-        values.append(t2_t1_delta)
-        if t3 is not None:
-            t3_t2_delta = t3.raw - t2.raw
-            explicit = explicit or (t3_t2_delta != 0)
-            values.append(t3_t2_delta)
-        if explicit:
-            form += '{1:+x}'
-            if t3 is not None:
-                form += '{2:+x}'
-    return form.format(*values)
-
-
-def decode_timestamps(encoded, explicit=False):
-    """
-    Parses a string of the form generated by encode_timestamps and returns
-    a tuple of the three component timestamps. If explicit is False, component
-    timestamps that are not explicitly encoded will be assumed to have zero
-    delta from the previous component and therefore take the value of the
-    previous component. If explicit is True, component timestamps that are
-    not explicitly encoded will be returned with value None.
-    """
-    # TODO: some tests, e.g. in test_replicator, put float timestamps values
-    # into container db's, hence this defensive check, but in real world
-    # this may never happen.
-    if not isinstance(encoded, six.string_types):
-        ts = Timestamp(encoded)
-        return ts, ts, ts
-
-    parts = []
-    signs = []
-    pos_parts = encoded.split('+')
-    for part in pos_parts:
-        # parse time components and their signs
-        # e.g. x-y+z --> parts = [x, y, z] and signs = [+1, -1, +1]
-        neg_parts = part.split('-')
-        parts = parts + neg_parts
-        signs = signs + [1] + [-1] * (len(neg_parts) - 1)
-    t1 = Timestamp(parts[0])
-    t2 = t3 = None
-    if len(parts) > 1:
-        t2 = t1
-        delta = signs[1] * int(parts[1], 16)
-        # if delta = 0 we want t2 = t3 = t1 in order to
-        # preserve any offset in t1 - only construct a distinct
-        # timestamp if there is a non-zero delta.
-        if delta:
-            t2 = Timestamp((t1.raw + delta) * PRECISION)
-    elif not explicit:
-        t2 = t1
-    if len(parts) > 2:
-        t3 = t2
-        delta = signs[2] * int(parts[2], 16)
-        if delta:
-            t3 = Timestamp((t2.raw + delta) * PRECISION)
-    elif not explicit:
-        t3 = t2
-    return t1, t2, t3
-
-
-def normalize_timestamp(timestamp):
-    """
-    Format a timestamp (string or numeric) into a standardized
-    xxxxxxxxxx.xxxxx (10.5) format.
-
-    Note that timestamps using values greater than or equal to November 20th,
-    2286 at 17:46 UTC will use 11 digits to represent the number of
-    seconds.
-
-    :param timestamp: unix timestamp
-    :returns: normalized timestamp as a string
-    """
-    return Timestamp(timestamp).normal
-
-
-EPOCH = datetime.datetime(1970, 1, 1)
-
-
-def last_modified_date_to_timestamp(last_modified_date_str):
-    """
-    Convert a last modified date (like you'd get from a container listing,
-    e.g. 2014-02-28T23:22:36.698390) to a float.
-    """
-    return Timestamp.from_isoformat(last_modified_date_str)
-
-
-def normalize_delete_at_timestamp(timestamp, high_precision=False):
-    """
-    Format a timestamp (string or numeric) into a standardized
-    xxxxxxxxxx (10) or xxxxxxxxxx.xxxxx (10.5) format.
-
-    Note that timestamps less than 0000000000 are raised to
-    0000000000 and values greater than November 20th, 2286 at
-    17:46:39 UTC will be capped at that date and time, resulting in
-    no return value exceeding 9999999999.99999 (or 9999999999 if
-    using low-precision).
-
-    This cap is because the expirer is already working through a
-    sorted list of strings that were all a length of 10. Adding
-    another digit would mess up the sort and cause the expirer to
-    break from processing early. By 2286, this problem will need to
-    be fixed, probably by creating an additional .expiring_objects
-    account to work from with 11 (or more) digit container names.
-
-    :param timestamp: unix timestamp
-    :returns: normalized timestamp as a string
-    """
-    fmt = '%016.5f' if high_precision else '%010d'
-    return fmt % min(max(0, float(timestamp)), 9999999999.99999)
-
-
 def mkdirs(path):
     """
     Ensures the path is a directory or makes it if not. Errors if the path
@@ -1715,6 +1208,7 @@ class RateLimitedIterator(object):
                         this many elements; default is 0 (rate limit
                         immediately)
     """
+
     def __init__(self, iterable, elements_per_second, limit_after=0,
                  ratelimit_if=lambda _junk: True):
         self.iterator = iter(iterable)
@@ -1749,6 +1243,7 @@ class GreenthreadSafeIterator(object):
     an error like "ValueError: generator already executing". By wrapping calls
     to next() with a mutex, we avoid that error.
     """
+
     def __init__(self, unsafe_iterable):
         self.unsafe_iter = iter(unsafe_iterable)
         self.semaphore = eventlet.semaphore.Semaphore(value=1)
@@ -1828,9 +1323,9 @@ class LoggerFileObject(object):
             if value:
                 if 'Connection reset by peer' in value:
                     self.logger.error(
-                        _('%s: Connection reset by peer'), self.log_type)
+                        '%s: Connection reset by peer', self.log_type)
                 else:
-                    self.logger.error(_('%(type)s: %(value)s'),
+                    self.logger.error('%(type)s: %(value)s',
                                       {'type': self.log_type, 'value': value})
         finally:
             self._cls_thread_local.already_called_write = False
@@ -1841,7 +1336,7 @@ class LoggerFileObject(object):
 
         self._cls_thread_local.already_called_writelines = True
         try:
-            self.logger.error(_('%(type)s: %(value)s'),
+            self.logger.error('%(type)s: %(value)s',
                               {'type': self.log_type,
                                'value': '#012'.join(values)})
         finally:
@@ -1886,21 +1381,7 @@ class StatsdClient(object):
         self.logger = logger
 
         # Determine if host is IPv4 or IPv6
-        addr_info = None
-        try:
-            addr_info = socket.getaddrinfo(host, port, socket.AF_INET)
-            self._sock_family = socket.AF_INET
-        except socket.gaierror:
-            try:
-                addr_info = socket.getaddrinfo(host, port, socket.AF_INET6)
-                self._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.
-                self._sock_family = socket.AF_INET
+        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
@@ -1920,6 +1401,24 @@ class StatsdClient(object):
         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
@@ -1979,7 +1478,7 @@ class StatsdClient(object):
             except IOError as err:
                 if self.logger:
                     self.logger.warning(
-                        _('Error sending UDP message to %(target)r: %(err)s'),
+                        'Error sending UDP message to %(target)r: %(err)s',
                         {'target': self._target, 'err': err})
 
     def _open_socket(self):
@@ -1994,12 +1493,16 @@ class StatsdClient(object):
     def decrement(self, metric, sample_rate=None):
         return self.update_stats(metric, -1, sample_rate)
 
-    def timing(self, metric, timing_ms, sample_rate=None):
+    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)
+        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:
@@ -2068,6 +1571,12 @@ class SwiftLoggerAdapter(logging.LoggerAdapter):
     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
@@ -2110,6 +1619,7 @@ 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
 
@@ -2129,6 +1639,7 @@ 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
@@ -2244,31 +1755,36 @@ class LogAdapter(logging.LoggerAdapter, object):
         _junk, exc, _junk = sys.exc_info()
         call = self.error
         emsg = ''
-        if isinstance(exc, (OSError, socket.error)):
+        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')
+                emsg = 'Connection refused'
             elif exc.errno == errno.ECONNRESET:
-                emsg = _('Connection reset')
+                emsg = 'Connection reset'
             elif exc.errno == errno.EHOSTUNREACH:
-                emsg = _('Host unreachable')
+                emsg = 'Host unreachable'
             elif exc.errno == errno.ENETUNREACH:
-                emsg = _('Network unreachable')
+                emsg = 'Network unreachable'
             elif exc.errno == errno.ETIMEDOUT:
-                emsg = _('Connection timeout')
+                emsg = 'Connection timeout'
             elif exc.errno == errno.EPIPE:
-                emsg = _('Broken pipe')
+                emsg = 'Broken pipe'
             else:
                 call = self._exception
-        elif isinstance(exc, (http_client.BadStatusLine,
-                              green_http_client.BadStatusLine)):
-            # Use error(); not really exceptional
-            emsg = '%s: %s' % (exc.__class__.__name__, exc.line)
         elif isinstance(exc, eventlet.Timeout):
             emsg = exc.__class__.__name__
-            if hasattr(exc, 'seconds'):
-                emsg += ' (%ss)' % exc.seconds
+            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
@@ -2305,13 +1821,13 @@ class LogAdapter(logging.LoggerAdapter, object):
 
         :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'):
-                return func(self.logger.statsd_client, *a, **kw)
+                func = getattr(self.logger.statsd_client, statsd_func_name)
+                return func(*a, **kw)
         return wrapped
 
     update_stats = statsd_delegate('update_stats')
@@ -2382,6 +1898,7 @@ class LogLevelFilter(object):
                   (DEBUG < INFO < WARN < ERROR < CRITICAL|FATAL)
                   Default: DEBUG
     """
+
     def __init__(self, level=logging.DEBUG):
         self.level = level
 
@@ -2618,7 +2135,7 @@ def capture_stdio(logger, **kwargs):
     """
     # log uncaught exceptions
     sys.excepthook = lambda * exc_info: \
-        logger.critical(_('UNCAUGHT EXCEPTION'), exc_info=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]
@@ -2647,11 +2164,13 @@ def capture_stdio(logger, **kwargs):
         sys.stderr = LoggerFileObject(logger, 'STDERR')
 
 
-def parse_options(parser=None, once=False, test_args=None):
+def parse_options(parser=None, once=False, test_config=False, test_args=None):
     """Parse standard swift server/daemon options with optparse.OptionParser.
 
     :param parser: OptionParser to use. If not sent one will be created.
     :param once: Boolean indicating the "once" option is available
+    :param test_config: Boolean indicating the "test-config" option is
+                        available
     :param test_args: Override sys.argv; used in testing
 
     :returns: Tuple of (config, options); config is an absolute path to the
@@ -2666,18 +2185,23 @@ def parse_options(parser=None, once=False, test_args=None):
     if once:
         parser.add_option("-o", "--once", default=False, action="store_true",
                           help="only run one pass of daemon")
+    if test_config:
+        parser.add_option("-t", "--test-config",
+                          default=False, action="store_true",
+                          help="exit after loading and validating config; "
+                               "do not run the daemon")
 
     # if test_args is None, optparse will use sys.argv[:1]
     options, args = parser.parse_args(args=test_args)
 
     if not args:
         parser.print_usage()
-        print(_("Error: missing config path argument"))
+        print("Error: missing config path argument")
         sys.exit(1)
     config = os.path.abspath(args.pop(0))
     if not os.path.exists(config):
         parser.print_usage()
-        print(_("Error: unable to locate %s") % config)
+        print("Error: unable to locate %s" % config)
         sys.exit(1)
 
     extra_args = []
@@ -2694,125 +2218,6 @@ def parse_options(parser=None, once=False, test_args=None):
     return config, options
 
 
-def is_valid_ip(ip):
-    """
-    Return True if the provided ip is a valid IP-address
-    """
-    return is_valid_ipv4(ip) or is_valid_ipv6(ip)
-
-
-def is_valid_ipv4(ip):
-    """
-    Return True if the provided ip is a valid IPv4-address
-    """
-    try:
-        socket.inet_pton(socket.AF_INET, ip)
-    except socket.error:  # not a valid IPv4 address
-        return False
-    return True
-
-
-def is_valid_ipv6(ip):
-    """
-    Returns True if the provided ip is a valid IPv6-address
-    """
-    try:
-        socket.inet_pton(socket.AF_INET6, ip)
-    except socket.error:  # not a valid IPv6 address
-        return False
-    return True
-
-
-def expand_ipv6(address):
-    """
-    Expand ipv6 address.
-    :param address: a string indicating valid ipv6 address
-    :returns: a string indicating fully expanded ipv6 address
-
-    """
-    packed_ip = socket.inet_pton(socket.AF_INET6, address)
-    return socket.inet_ntop(socket.AF_INET6, packed_ip)
-
-
-def whataremyips(ring_ip=None):
-    """
-    Get "our" IP addresses ("us" being the set of services configured by
-    one `*.conf` file). If our REST listens on a specific address, return it.
-    Otherwise, if listen on '0.0.0.0' or '::' return all addresses, including
-    the loopback.
-
-    :param str ring_ip: Optional ring_ip/bind_ip from a config file; may be
-                        IP address or hostname.
-    :returns: list of Strings of ip addresses
-    """
-    if ring_ip:
-        # See if bind_ip is '0.0.0.0'/'::'
-        try:
-            _, _, _, _, sockaddr = socket.getaddrinfo(
-                ring_ip, None, 0, socket.SOCK_STREAM, 0,
-                socket.AI_NUMERICHOST)[0]
-            if sockaddr[0] not in ('0.0.0.0', '::'):
-                return [ring_ip]
-        except socket.gaierror:
-            pass
-
-    addresses = []
-    for interface in netifaces.interfaces():
-        try:
-            iface_data = netifaces.ifaddresses(interface)
-            for family in iface_data:
-                if family not in (netifaces.AF_INET, netifaces.AF_INET6):
-                    continue
-                for address in iface_data[family]:
-                    addr = address['addr']
-
-                    # If we have an ipv6 address remove the
-                    # %ether_interface at the end
-                    if family == netifaces.AF_INET6:
-                        addr = expand_ipv6(addr.split('%')[0])
-                    addresses.append(addr)
-        except ValueError:
-            pass
-    return addresses
-
-
-def parse_socket_string(socket_string, default_port):
-    """
-    Given a string representing a socket, returns a tuple of (host, port).
-    Valid strings are DNS names, IPv4 addresses, or IPv6 addresses, with an
-    optional port. If an IPv6 address is specified it **must** be enclosed in
-    [], like *[::1]* or *[::1]:11211*. This follows the accepted prescription
-    for `IPv6 host literals`_.
-
-    Examples::
-
-        server.org
-        server.org:1337
-        127.0.0.1:1337
-        [::1]:1337
-        [::1]
-
-    .. _IPv6 host literals: https://tools.ietf.org/html/rfc3986#section-3.2.2
-    """
-    port = default_port
-    # IPv6 addresses must be between '[]'
-    if socket_string.startswith('['):
-        match = IPV6_RE.match(socket_string)
-        if not match:
-            raise ValueError("Invalid IPv6 address: %s" % socket_string)
-        host = match.group('address')
-        port = match.group('port') or port
-    else:
-        if ':' in socket_string:
-            tokens = socket_string.split(':')
-            if len(tokens) > 2:
-                raise ValueError("IPv6 addresses must be between '[]'")
-            host, port = tokens
-        else:
-            host = socket_string
-    return (host, port)
-
-
 def select_ip_port(node_dict, use_replication=False):
     """
     Get the ip address and port that should be used for the given
@@ -3197,6 +2602,7 @@ def readconf(conf_path, section_name=None, log_name=None, defaults=None,
             # 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'):
@@ -3212,14 +2618,14 @@ def readconf(conf_path, section_name=None, log_name=None, defaults=None,
         else:
             success = c.read(conf_path)
         if not success:
-            raise IOError(_("Unable to read config from %s") %
+            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") %
+                "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:
@@ -3449,7 +2855,7 @@ def audit_location_generator(devices, datadir, suffix='',
                 error_counter['unmounted'].append(device)
             if logger:
                 logger.warning(
-                    _('Skipping %s as it is not mounted'), device)
+                    'Skipping %s as it is not mounted', device)
             continue
         if hook_pre_device:
             hook_pre_device(os.path.join(devices, device))
@@ -3462,7 +2868,7 @@ def audit_location_generator(devices, datadir, suffix='',
                 error_counter.setdefault('unlistable_partitions', [])
                 error_counter['unlistable_partitions'].append(datadir_path)
             if logger:
-                logger.warning(_('Skipping %(datadir)s because %(err)s'),
+                logger.warning('Skipping %(datadir)s because %(err)s',
                                {'datadir': datadir_path, 'err': e})
             continue
         if partitions_filter:
@@ -3660,6 +3066,9 @@ class ContextPool(GreenPool):
         return self
 
     def __exit__(self, type, value, traceback):
+        self.close()
+
+    def close(self):
         for coro in list(self.coroutines_running):
             coro.kill()
 
@@ -3682,6 +3091,7 @@ class GreenAsyncPile(object):
 
     Correlating results with jobs (if necessary) is left to the caller.
     """
+
     def __init__(self, size_or_pool):
         """
         :param size_or_pool: thread pool size or a pool to use
@@ -3775,6 +3185,7 @@ class StreamingPile(GreenAsyncPile):
     When used as a context manager, has the same worker-killing properties as
     :class:`ContextPool`.
     """
+
     def __init__(self, size):
         """:param size: number of worker threads to use"""
         self.pool = ContextPool(size)
@@ -3840,16 +3251,16 @@ def validate_sync_to(value, allowed_sync_hosts, realms_conf):
         data = value[2:].split('/')
         if len(data) != 4:
             return (
-                _('Invalid X-Container-Sync-To format %r') % orig_value,
+                'Invalid X-Container-Sync-To format %r' % orig_value,
                 None, None, None)
         realm, cluster, account, container = data
         realm_key = realms_conf.key(realm)
         if not realm_key:
-            return (_('No realm key for %r') % realm, None, None, None)
+            return ('No realm key for %r' % realm, None, None, None)
         endpoint = realms_conf.endpoint(realm, cluster)
         if not endpoint:
             return (
-                _('No cluster endpoint for %(realm)r %(cluster)r')
+                'No cluster endpoint for %(realm)r %(cluster)r'
                 % {'realm': realm, 'cluster': cluster},
                 None, None, None)
         return (
@@ -3859,19 +3270,19 @@ def validate_sync_to(value, allowed_sync_hosts, realms_conf):
     p = urlparse(value)
     if p.scheme not in ('http', 'https'):
         return (
-            _('Invalid scheme %r in X-Container-Sync-To, must be "//", '
-              '"http", or "https".') % p.scheme,
+            'Invalid scheme %r in X-Container-Sync-To, must be "//", '
+            '"http", or "https".' % p.scheme,
             None, None, None)
     if not p.path:
-        return (_('Path required in X-Container-Sync-To'), None, None, None)
+        return ('Path required in X-Container-Sync-To', None, None, None)
     if p.params or p.query or p.fragment:
         return (
-            _('Params, queries, and fragments not allowed in '
-              'X-Container-Sync-To'),
+            'Params, queries, and fragments not allowed in '
+            'X-Container-Sync-To',
             None, None, None)
     if p.hostname not in allowed_sync_hosts:
         return (
-            _('Invalid host %r in X-Container-Sync-To') % p.hostname,
+            'Invalid host %r in X-Container-Sync-To' % p.hostname,
             None, None, None)
     return (None, value, None, None)
 
@@ -4266,6 +3677,7 @@ class Everything(object):
     A container that contains everything. If "e" is an instance of
     Everything, then "x in e" is true for all x.
     """
+
     def __contains__(self, element):
         return True
 
@@ -4297,6 +3709,7 @@ class CloseableChain(object):
     Like itertools.chain, but with a close method that will attempt to invoke
     its sub-iterators' close methods, if any.
     """
+
     def __init__(self, *iterables):
         self.iterables = iterables
         self.chained_iter = itertools.chain(*self.iterables)
@@ -4340,6 +3753,7 @@ class InputProxy(object):
     File-like object that counts bytes read.
     To be swapped in for wsgi.input for accounting purposes.
     """
+
     def __init__(self, wsgi_input):
         """
         :param wsgi_input: file-like object to wrap the functionality of
@@ -4481,6 +3895,7 @@ class Spliterator(object):
     "l"  # shorter than requested; this can happen with the last iterator
 
     """
+
     def __init__(self, source_iterable):
         self.input_iterator = iter(source_iterable)
         self.leftovers = None
@@ -4722,7 +4137,7 @@ def override_bytes_from_content_type(listing_dict, logger=None):
             listing_dict['bytes'] = int(swift_bytes)
         except ValueError:
             if logger:
-                logger.exception(_("Invalid swift_bytes"))
+                logger.exception("Invalid swift_bytes")
 
 
 def clean_content_type(value):
@@ -5041,7 +4456,7 @@ def document_iters_to_http_response_body(ranges_iter, boundary, multipart,
                 pass
             else:
                 logger.warning(
-                    _("More than one part in a single-part response?"))
+                    "More than one part in a single-part response?")
 
         return string_along(response_body_iter, ranges_iter, logger)
 
@@ -5093,87 +4508,6 @@ def parse_content_disposition(header):
     return header, attributes
 
 
-class sockaddr_alg(ctypes.Structure):
-    _fields_ = [("salg_family", ctypes.c_ushort),
-                ("salg_type", ctypes.c_ubyte * 14),
-                ("salg_feat", ctypes.c_uint),
-                ("salg_mask", ctypes.c_uint),
-                ("salg_name", ctypes.c_ubyte * 64)]
-
-
-_bound_md5_sockfd = None
-
-
-def get_md5_socket():
-    """
-    Get an MD5 socket file descriptor. One can MD5 data with it by writing it
-    to the socket with os.write, then os.read the 16 bytes of the checksum out
-    later.
-
-    NOTE: It is the caller's responsibility to ensure that os.close() is
-    called on the returned file descriptor. This is a bare file descriptor,
-    not a Python object. It doesn't close itself.
-    """
-
-    # Linux's AF_ALG sockets work like this:
-    #
-    # First, initialize a socket with socket() and bind(). This tells the
-    # socket what algorithm to use, as well as setting up any necessary bits
-    # like crypto keys. Of course, MD5 doesn't need any keys, so it's just the
-    # algorithm name.
-    #
-    # Second, to hash some data, get a second socket by calling accept() on
-    # the first socket. Write data to the socket, then when finished, read the
-    # checksum from the socket and close it. This lets you checksum multiple
-    # things without repeating all the setup code each time.
-    #
-    # Since we only need to bind() one socket, we do that here and save it for
-    # future re-use. That way, we only use one file descriptor to get an MD5
-    # socket instead of two, and we also get to save some syscalls.
-
-    global _bound_md5_sockfd
-    global _libc_socket
-    global _libc_bind
-    global _libc_accept
-
-    if _libc_accept is None:
-        _libc_accept = load_libc_function('accept', fail_if_missing=True)
-    if _libc_socket is None:
-        _libc_socket = load_libc_function('socket', fail_if_missing=True)
-    if _libc_bind is None:
-        _libc_bind = load_libc_function('bind', fail_if_missing=True)
-
-    # Do this at first call rather than at import time so that we don't use a
-    # file descriptor on systems that aren't using any MD5 sockets.
-    if _bound_md5_sockfd is None:
-        sockaddr_setup = sockaddr_alg(
-            AF_ALG,
-            (ord('h'), ord('a'), ord('s'), ord('h'), 0),
-            0, 0,
-            (ord('m'), ord('d'), ord('5'), 0))
-        hash_sockfd = _libc_socket(ctypes.c_int(AF_ALG),
-                                   ctypes.c_int(socket.SOCK_SEQPACKET),
-                                   ctypes.c_int(0))
-        if hash_sockfd < 0:
-            raise IOError(ctypes.get_errno(),
-                          "Failed to initialize MD5 socket")
-
-        bind_result = _libc_bind(ctypes.c_int(hash_sockfd),
-                                 ctypes.pointer(sockaddr_setup),
-                                 ctypes.c_int(ctypes.sizeof(sockaddr_alg)))
-        if bind_result < 0:
-            os.close(hash_sockfd)
-            raise IOError(ctypes.get_errno(), "Failed to bind MD5 socket")
-
-        _bound_md5_sockfd = hash_sockfd
-
-    md5_sockfd = _libc_accept(ctypes.c_int(_bound_md5_sockfd), None, 0)
-    if md5_sockfd < 0:
-        raise IOError(ctypes.get_errno(), "Failed to accept MD5 socket")
-
-    return md5_sockfd
-
-
 try:
     _test_md5 = hashlib.md5(usedforsecurity=False)  # nosec
 
@@ -5195,19 +4529,19 @@ except TypeError:
         return hashlib.md5(string)  # nosec
 
 
-class ShardRangeOuterBound(object):
+class NamespaceOuterBound(object):
     """
     A custom singleton type to be subclassed for the outer bounds of
-    ShardRanges.
+    Namespaces.
     """
     _singleton = None
 
     def __new__(cls):
-        if cls is ShardRangeOuterBound:
-            raise TypeError('ShardRangeOuterBound is an abstract class; '
+        if cls is NamespaceOuterBound:
+            raise TypeError('NamespaceOuterBound is an abstract class; '
                             'only subclasses should be instantiated')
         if cls._singleton is None:
-            cls._singleton = super(ShardRangeOuterBound, cls).__new__(cls)
+            cls._singleton = super(NamespaceOuterBound, cls).__new__(cls)
         return cls._singleton
 
     def __str__(self):
@@ -5222,47 +4556,360 @@ class ShardRangeOuterBound(object):
     __nonzero__ = __bool__
 
 
-class ShardName(object):
+@functools.total_ordering
+class Namespace(object):
     """
-    Encapsulates the components of a shard name.
+    A Namespace encapsulates parameters that define a range of the object
+    namespace.
 
-    Instances of this class would typically be constructed via the create() or
-    parse() class methods.
+    :param name: the name of the ``Namespace``.
+    :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')
 
-    Shard names have the form:
+    @functools.total_ordering
+    class MaxBound(NamespaceOuterBound):
+        # singleton for maximum bound
+        def __ge__(self, other):
+            return True
 
-        <account>/<root_container>-<parent_container_hash>-<timestamp>-<index>
+    @functools.total_ordering
+    class MinBound(NamespaceOuterBound):
+        # singleton for minimum bound
+        def __le__(self, other):
+            return True
 
-    Note: some instances of :class:`~swift.common.utils.ShardRange` have names
-    that will NOT parse as a :class:`~swift.common.utils.ShardName`; e.g. a
-    root container's own shard range will have a name format of
-    <account>/<root_container> which will raise ValueError if passed to parse.
-    """
-    def __init__(self, account, root_container,
-                 parent_container_hash,
-                 timestamp,
-                 index):
-        self.account = self._validate(account)
-        self.root_container = self._validate(root_container)
-        self.parent_container_hash = self._validate(parent_container_hash)
-        self.timestamp = Timestamp(timestamp)
-        self.index = int(index)
+    MIN = MinBound()
+    MAX = MaxBound()
 
-    @classmethod
-    def _validate(cls, arg):
-        if arg is None:
-            raise ValueError('arg must not be None')
-        return arg
+    def __init__(self, name, lower, upper):
+        self._lower = Namespace.MIN
+        self._upper = Namespace.MAX
+        self.lower = lower
+        self.upper = upper
+        self.name = name
 
-    def __str__(self):
-        return '%s/%s-%s-%s-%s' % (self.account,
-                                   self.root_container,
-                                   self.parent_container_hash,
-                                   self.timestamp.internal,
-                                   self.index)
+    def __iter__(self):
+        yield 'name', str(self.name)
+        yield 'lower', self.lower_str
+        yield 'upper', self.upper_str
 
-    @classmethod
-    def hash_container_name(cls, container_name):
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(
+            '%s=%r' % prop for prop in self))
+
+    def __lt__(self, other):
+        # a Namespace is less than other if its entire namespace is less than
+        # other; if other is another Namespace that implies that this
+        # Namespace's upper must be less than or equal to the other
+        # Namespace's lower
+        if self.upper == Namespace.MAX:
+            return False
+        if isinstance(other, Namespace):
+            return self.upper <= other.lower
+        elif other is None:
+            return True
+        else:
+            return self.upper < self._encode(other)
+
+    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 upper
+        if self.lower == Namespace.MIN:
+            return False
+        if isinstance(other, Namespace):
+            return self.lower >= other.upper
+        elif other is None:
+            return False
+        else:
+            return self.lower >= self._encode(other)
+
+    def __eq__(self, other):
+        # test for equality of range bounds only
+        if not isinstance(other, Namespace):
+            return False
+        return self.lower == other.lower and self.upper == other.upper
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __contains__(self, item):
+        # test if the given item is within the namespace
+        if item == '':
+            return False
+        item = self._encode_bound(item)
+        return self.lower < item <= self.upper
+
+    @classmethod
+    def _encode(cls, value):
+        if six.PY2 and isinstance(value, six.text_type):
+            return value.encode('utf-8')
+        if six.PY3 and isinstance(value, six.binary_type):
+            # This should never fail -- the value should always be coming from
+            # valid swift paths, which means UTF-8
+            return value.decode('utf-8')
+        return value
+
+    def _encode_bound(self, bound):
+        if isinstance(bound, NamespaceOuterBound):
+            return bound
+        if not (isinstance(bound, six.text_type) or
+                isinstance(bound, six.binary_type)):
+            raise TypeError('must be a string type')
+        return self._encode(bound)
+
+    @property
+    def lower(self):
+        return self._lower
+
+    @property
+    def lower_str(self):
+        return str(self.lower)
+
+    @lower.setter
+    def lower(self, value):
+        if value is None or (value == b"" if isinstance(value, bytes) else
+                             value == u""):
+            value = Namespace.MIN
+        try:
+            value = self._encode_bound(value)
+        except TypeError as err:
+            raise TypeError('lower %s' % err)
+        if value > self._upper:
+            raise ValueError(
+                'lower (%r) must be less than or equal to upper (%r)' %
+                (value, self.upper))
+        self._lower = value
+
+    @property
+    def upper(self):
+        return self._upper
+
+    @property
+    def upper_str(self):
+        return str(self.upper)
+
+    @upper.setter
+    def upper(self, value):
+        if value is None or (value == b"" if isinstance(value, bytes) else
+                             value == u""):
+            value = Namespace.MAX
+        try:
+            value = self._encode_bound(value)
+        except TypeError as err:
+            raise TypeError('upper %s' % err)
+        if value < self._lower:
+            raise ValueError(
+                'upper (%r) must be greater than or equal to lower (%r)' %
+                (value, self.lower))
+        self._upper = value
+
+    @property
+    def end_marker(self):
+        return self.upper_str + '\x00' if self.upper else ''
+
+    def entire_namespace(self):
+        """
+        Returns True if this namespace includes the entire namespace, False
+        otherwise.
+        """
+        return (self.lower == Namespace.MIN and
+                self.upper == Namespace.MAX)
+
+    def overlaps(self, other):
+        """
+        Returns True if this namespace overlaps with the other namespace.
+
+        :param other: an instance of :class:`~swift.common.utils.Namespace`
+        """
+        if not isinstance(other, Namespace):
+            return False
+        return max(self.lower, other.lower) < min(self.upper, other.upper)
+
+    def includes(self, other):
+        """
+        Returns True if this namespace includes the whole of the other
+        namespace, False otherwise.
+
+        :param other: an instance of :class:`~swift.common.utils.Namespace`
+        """
+        return (self.lower <= other.lower) and (other.upper <= self.upper)
+
+    def expand(self, donors):
+        """
+        Expands the bounds as necessary to match the minimum and maximum bounds
+        of the given donors.
+
+        :param donors: A list of :class:`~swift.common.utils.Namespace`
+        :return: True if the bounds have been modified, False otherwise.
+        """
+        modified = False
+        new_lower = self.lower
+        new_upper = self.upper
+        for donor in donors:
+            new_lower = min(new_lower, donor.lower)
+            new_upper = max(new_upper, donor.upper)
+        if self.lower > new_lower or self.upper < new_upper:
+            self.lower = new_lower
+            self.upper = new_upper
+            modified = True
+        return modified
+
+
+class NamespaceBoundList(object):
+    def __init__(self, bounds):
+        """
+        Encapsulate a compact representation of namespaces. Each item in the
+        list is a list [lower bound, name].
+
+        :param bounds: a list of lists ``[lower bound, name]``. The list
+            should be ordered by ``lower bound``.
+        """
+        self.bounds = [] if bounds is None else bounds
+
+    def __eq__(self, other):
+        # test for equality of NamespaceBoundList objects only
+        if not isinstance(other, NamespaceBoundList):
+            return False
+        return self.bounds == other.bounds
+
+    @classmethod
+    def parse(cls, namespaces):
+        """
+        Create a NamespaceBoundList object by parsing a list of Namespaces or
+        shard ranges and only storing the compact bounds list.
+
+        Each Namespace in the given list of ``namespaces`` provides the next
+        [lower bound, name] list to append to the NamespaceBoundList. The
+        given ``namespaces`` should be contiguous because the
+        NamespaceBoundList only stores lower bounds; if ``namespaces`` has
+        overlaps then at least one of the overlapping namespaces may be
+        ignored; similarly, gaps between namespaces are not represented in the
+        NamespaceBoundList.
+
+        :param namespaces: A list of Namespace instances. The list should be
+            ordered by namespace bounds.
+        :return: a NamespaceBoundList.
+        """
+        if not namespaces:
+            return None
+        bounds = []
+        upper = namespaces[0].lower
+        for ns in namespaces:
+            if ns.lower < upper:
+                # Discard overlapping namespace.
+                # Overlapping namespaces are expected in lists of shard ranges
+                # fetched from the backend. For example, while a parent
+                # container is in the process of sharding, the parent shard
+                # range and its children shard ranges may be returned in the
+                # list of shard ranges. However, the backend sorts the list by
+                # (upper, state, lower, name) such that the children precede
+                # the parent, and it is the children that we prefer to retain
+                # in the NamespaceBoundList. For example, these namespaces:
+                #   (a-b, "child1"), (b-c, "child2"), (a-c, "parent")
+                # would result in a NamespaceBoundList:
+                #   (a, "child1"), (b, "child2")
+                # Unexpected overlaps or gaps may result in namespaces being
+                # 'extended' because only lower bounds are stored. For example,
+                # these namespaces:
+                #   (a-b, "ns1"), (d-e, "ns2")
+                # would result in a NamespaceBoundList:
+                #   (a, "ns1"), (d, "ns2")
+                # When used to find a target namespace for an object update
+                # that lies in a gap, the NamespaceBoundList will map the
+                # object name to the preceding namespace. In the example, an
+                # object named "c" would be mapped to "ns1". (In previous
+                # versions, an object update lying in a gap would have been
+                # mapped to the root container.)
+                continue
+            bounds.append([ns.lower_str, str(ns.name)])
+            upper = ns.upper
+        return cls(bounds)
+
+    def get_namespace(self, item):
+        """
+        Get a Namespace instance that contains ``item`` by bisecting on the
+        lower bounds directly. This function is used for performance sensitive
+        path, for example, '_get_update_shard' in proxy object controller. For
+        normal paths, convert NamespaceBoundList to a list of Namespaces, and
+        use `~swift.common.utils.find_namespace` or
+        `~swift.common.utils.filter_namespaces`.
+
+        :param item: The item for a which a Namespace is to be found.
+        :return: the Namespace that contains ``item``.
+        """
+        pos = bisect.bisect(self.bounds, [item]) - 1
+        lower, name = self.bounds[pos]
+        upper = ('' if pos + 1 == len(self.bounds)
+                 else self.bounds[pos + 1][0])
+        return Namespace(name, lower, upper)
+
+    def get_namespaces(self):
+        """
+        Get the contained namespaces as a list of contiguous Namespaces ordered
+        by lower bound.
+
+        :return: A list of Namespace objects which are ordered by
+            ``lower bound``.
+        """
+        if not self.bounds:
+            return []
+        namespaces = []
+        num_ns = len(self.bounds)
+        for i in range(num_ns):
+            lower, name = self.bounds[i]
+            upper = ('' if i + 1 == num_ns else self.bounds[i + 1][0])
+            namespaces.append(Namespace(name, lower, upper))
+        return namespaces
+
+
+class ShardName(object):
+    """
+    Encapsulates the components of a shard name.
+
+    Instances of this class would typically be constructed via the create() or
+    parse() class methods.
+
+    Shard names have the form:
+
+        <account>/<root_container>-<parent_container_hash>-<timestamp>-<index>
+
+    Note: some instances of :class:`~swift.common.utils.ShardRange` have names
+    that will NOT parse as a :class:`~swift.common.utils.ShardName`; e.g. a
+    root container's own shard range will have a name format of
+    <account>/<root_container> which will raise ValueError if passed to parse.
+    """
+
+    def __init__(self, account, root_container,
+                 parent_container_hash,
+                 timestamp,
+                 index):
+        self.account = self._validate(account)
+        self.root_container = self._validate(root_container)
+        self.parent_container_hash = self._validate(parent_container_hash)
+        self.timestamp = Timestamp(timestamp)
+        self.index = int(index)
+
+    @classmethod
+    def _validate(cls, arg):
+        if arg is None:
+            raise ValueError('arg must not be None')
+        return arg
+
+    def __str__(self):
+        return '%s/%s-%s-%s-%s' % (self.account,
+                                   self.root_container,
+                                   self.parent_container_hash,
+                                   self.timestamp.internal,
+                                   self.index)
+
+    @classmethod
+    def hash_container_name(cls, container_name):
         """
         Calculates the hash of a container name.
 
@@ -5329,7 +4976,7 @@ class ShardName(object):
             raise ValueError('invalid name: %s' % name)
 
 
-class ShardRange(object):
+class ShardRange(Namespace):
     """
     A ShardRange encapsulates sharding state related to a container including
     lower and upper bounds that define the object namespace for which the
@@ -5398,41 +5045,25 @@ class ShardRange(object):
     SHARDING_STATES = (SHARDING, SHARDED)
     CLEAVING_STATES = SHRINKING_STATES + SHARDING_STATES
 
-    @functools.total_ordering
-    class MaxBound(ShardRangeOuterBound):
-        # singleton for maximum bound
-        def __ge__(self, other):
-            return True
-
-    @functools.total_ordering
-    class MinBound(ShardRangeOuterBound):
-        # singleton for minimum bound
-        def __le__(self, other):
-            return True
-
-    MIN = MinBound()
-    MAX = MaxBound()
     __slots__ = (
         'account', 'container',
         '_timestamp', '_meta_timestamp', '_state_timestamp', '_epoch',
-        '_lower', '_upper', '_deleted', '_state', '_count', '_bytes',
+        '_deleted', '_state', '_count', '_bytes',
         '_tombstones', '_reported')
 
-    def __init__(self, name, timestamp, lower=MIN, upper=MAX,
+    def __init__(self, name, timestamp=0,
+                 lower=Namespace.MIN, upper=Namespace.MAX,
                  object_count=0, bytes_used=0, meta_timestamp=None,
                  deleted=False, state=None, state_timestamp=None, epoch=None,
-                 reported=False, tombstones=-1):
+                 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._lower = ShardRange.MIN
-        self._upper = ShardRange.MAX
         self._deleted = False
         self._state = None
 
         self.name = name
         self.timestamp = timestamp
-        self.lower = lower
-        self.upper = upper
         self.deleted = deleted
         self.object_count = object_count
         self.bytes_used = bytes_used
@@ -5447,27 +5078,10 @@ class ShardRange(object):
     def sort_key(cls, sr):
         # 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_shard_range
+        # a key assumption for bisect, which is used by utils.find_namespace
+        # with shard ranges.
         return sr.upper, sr.state, sr.lower, sr.name
 
-    @classmethod
-    def _encode(cls, value):
-        if six.PY2 and isinstance(value, six.text_type):
-            return value.encode('utf-8')
-        if six.PY3 and isinstance(value, six.binary_type):
-            # This should never fail -- the value should always be coming from
-            # valid swift paths, which means UTF-8
-            return value.decode('utf-8')
-        return value
-
-    def _encode_bound(self, bound):
-        if isinstance(bound, ShardRangeOuterBound):
-            return bound
-        if not (isinstance(bound, six.text_type) or
-                isinstance(bound, six.binary_type)):
-            raise TypeError('must be a string type')
-        return self._encode(bound)
-
     def is_child_of(self, parent):
         """
         Test if this shard range is a child of another shard range. The
@@ -5638,56 +5252,6 @@ class ShardRange(object):
     def meta_timestamp(self, ts):
         self._meta_timestamp = self._to_timestamp(ts)
 
-    @property
-    def lower(self):
-        return self._lower
-
-    @property
-    def lower_str(self):
-        return str(self.lower)
-
-    @lower.setter
-    def lower(self, value):
-        if value is None or (value == b"" if isinstance(value, bytes) else
-                             value == u""):
-            value = ShardRange.MIN
-        try:
-            value = self._encode_bound(value)
-        except TypeError as err:
-            raise TypeError('lower %s' % err)
-        if value > self._upper:
-            raise ValueError(
-                'lower (%r) must be less than or equal to upper (%r)' %
-                (value, self.upper))
-        self._lower = value
-
-    @property
-    def end_marker(self):
-        return self.upper_str + '\x00' if self.upper else ''
-
-    @property
-    def upper(self):
-        return self._upper
-
-    @property
-    def upper_str(self):
-        return str(self.upper)
-
-    @upper.setter
-    def upper(self, value):
-        if value is None or (value == b"" if isinstance(value, bytes) else
-                             value == u""):
-            value = ShardRange.MAX
-        try:
-            value = self._encode_bound(value)
-        except TypeError as err:
-            raise TypeError('upper %s' % err)
-        if value < self._lower:
-            raise ValueError(
-                'upper (%r) must be greater than or equal to lower (%r)' %
-                (value, self.lower))
-        self._upper = value
-
     @property
     def object_count(self):
         return self._count
@@ -5895,56 +5459,12 @@ class ShardRange(object):
         self.timestamp = timestamp or Timestamp.now()
         return True
 
-    def __contains__(self, item):
-        # test if the given item is within the namespace
-        if item == '':
-            return False
-        item = self._encode_bound(item)
-        return self.lower < item <= self.upper
-
-    def __lt__(self, other):
-        # a ShardRange is less than other if its entire namespace is less than
-        # other; if other is another ShardRange that implies that this
-        # ShardRange's upper must be less than or equal to the other
-        # ShardRange's lower
-        if self.upper == ShardRange.MAX:
-            return False
-        if isinstance(other, ShardRange):
-            return self.upper <= other.lower
-        elif other is None:
-            return True
-        else:
-            return self.upper < self._encode(other)
-
-    def __gt__(self, other):
-        # a ShardRange is greater than other if its entire namespace is greater
-        # than other; if other is another ShardRange that implies that this
-        # ShardRange's lower must be less greater than or equal to the other
-        # ShardRange's upper
-        if self.lower == ShardRange.MIN:
-            return False
-        if isinstance(other, ShardRange):
-            return self.lower >= other.upper
-        elif other is None:
-            return False
-        else:
-            return self.lower >= self._encode(other)
-
-    def __eq__(self, other):
-        # test for equality of range bounds only
-        if not isinstance(other, ShardRange):
-            return False
-        return self.lower == other.lower and self.upper == other.upper
-
     # A by-the-book implementation should probably hash the value, which
     # in our case would be account+container+lower+upper (+timestamp ?).
     # But we seem to be okay with just the identity.
     def __hash__(self):
         return id(self)
 
-    def __ne__(self, other):
-        return not (self == other)
-
     def __repr__(self):
         return '%s<%r to %r as of %s, (%d, %d) as of %s, %s as of %s>' % (
             self.__class__.__name__, self.lower, self.upper,
@@ -5952,34 +5472,6 @@ class ShardRange(object):
             self.meta_timestamp.internal, self.state_text,
             self.state_timestamp.internal)
 
-    def entire_namespace(self):
-        """
-        Returns True if the ShardRange includes the entire namespace, False
-        otherwise.
-        """
-        return (self.lower == ShardRange.MIN and
-                self.upper == ShardRange.MAX)
-
-    def overlaps(self, other):
-        """
-        Returns True if the ShardRange namespace overlaps with the other
-        ShardRange's namespace.
-
-        :param other: an instance of :class:`~swift.common.utils.ShardRange`
-        """
-        if not isinstance(other, ShardRange):
-            return False
-        return max(self.lower, other.lower) < min(self.upper, other.upper)
-
-    def includes(self, other):
-        """
-        Returns True if this namespace includes the whole of the other
-        namespace, False otherwise.
-
-        :param other: an instance of :class:`~swift.common.utils.ShardRange`
-        """
-        return (self.lower <= other.lower) and (other.upper <= self.upper)
-
     def __iter__(self):
         yield 'name', self.name
         yield 'timestamp', self.timestamp.internal
@@ -6028,26 +5520,6 @@ class ShardRange(object):
             params['state_timestamp'], params['epoch'],
             params.get('reported', 0), params.get('tombstones', -1))
 
-    def expand(self, donors):
-        """
-        Expands the bounds as necessary to match the minimum and maximum bounds
-        of the given donors.
-
-        :param donors: A list of :class:`~swift.common.utils.ShardRange`
-        :return: True if the bounds have been modified, False otherwise.
-        """
-        modified = False
-        new_lower = self.lower
-        new_upper = self.upper
-        for donor in donors:
-            new_lower = min(new_lower, donor.lower)
-            new_upper = max(new_upper, donor.upper)
-        if self.lower > new_lower or self.upper < new_upper:
-            self.lower = new_lower
-            self.upper = new_upper
-            modified = True
-        return modified
-
 
 class ShardRangeList(UserList):
     """
@@ -6057,6 +5529,7 @@ class ShardRangeList(UserList):
     This class does not enforce ordering or continuity of the list items:
     callers should ensure that items are added in order as appropriate.
     """
+
     def __getitem__(self, index):
         # workaround for py3 - not needed for py2.7,py3.8
         result = self.data[index]
@@ -6069,27 +5542,27 @@ class ShardRangeList(UserList):
         only be equal to the lowest bound of all items in the list if the list
         contents has been sorted.
 
-        :return: lower bound of first item in the list, or ShardRange.MIN
+        :return: lower bound of first item in the list, or Namespace.MIN
                  if the list is empty.
         """
         if not self:
             # empty list has range MIN->MIN
-            return ShardRange.MIN
+            return Namespace.MIN
         return self[0].lower
 
     @property
     def upper(self):
         """
-        Returns the upper bound of the first item in the list. Note: this will
+        Returns the upper bound of the last item in the list. Note: this will
         only be equal to the uppermost bound of all items in the list if the
         list has previously been sorted.
 
-        :return: upper bound of first item in the list, or ShardRange.MIN
+        :return: upper bound of last item in the list, or Namespace.MIN
                  if the list is empty.
         """
         if not self:
             # empty list has range MIN->MIN
-            return ShardRange.MIN
+            return Namespace.MIN
         return self[-1].upper
 
     @property
@@ -6162,7 +5635,7 @@ class ShardRangeList(UserList):
             containing the filtered shard ranges.
         """
         return ShardRangeList(
-            filter_shard_ranges(self, includes, marker, end_marker))
+            filter_namespaces(self, includes, marker, end_marker))
 
     def find_lower(self, condition):
         """
@@ -6183,44 +5656,45 @@ class ShardRangeList(UserList):
         return self.upper
 
 
-def find_shard_range(item, ranges):
+def find_namespace(item, namespaces):
     """
-    Find a ShardRange in given list of ``shard_ranges`` whose namespace
+    Find a Namespace/ShardRange in given list of ``namespaces`` whose namespace
     contains ``item``.
 
-    :param item: The item for a which a ShardRange is to be found.
-    :param ranges: a sorted list of ShardRanges.
-    :return: the ShardRange whose namespace contains ``item``, or None if
-        no suitable range is found.
+    :param item: The item for a which a Namespace is to be found.
+    :param ranges: a sorted list of Namespaces.
+    :return: the Namespace/ShardRange whose namespace contains ``item``, or
+        None if no suitable Namespace is found.
     """
-    index = bisect.bisect_left(ranges, item)
-    if index != len(ranges) and item in ranges[index]:
-        return ranges[index]
+    index = bisect.bisect_left(namespaces, item)
+    if index != len(namespaces) and item in namespaces[index]:
+        return namespaces[index]
     return None
 
 
-def filter_shard_ranges(shard_ranges, includes, marker, end_marker):
+def filter_namespaces(namespaces, includes, marker, end_marker):
     """
-    Filter the given shard ranges to those whose namespace includes the
-    ``includes`` name or any part of the namespace between ``marker`` and
+    Filter the given Namespaces/ShardRanges to those whose namespace includes
+    the ``includes`` name or any part of the namespace between ``marker`` and
     ``end_marker``. If none of ``includes``, ``marker`` or ``end_marker`` are
-    specified then all shard ranges will be returned.
+    specified then all Namespaces will be returned.
 
-    :param shard_ranges: A list of :class:`~swift.common.utils.ShardRange`.
-    :param includes: a string; if not empty then only the shard range, if any,
-        whose namespace includes this string will be returned, and ``marker``
-        and ``end_marker`` will be ignored.
+    :param namespaces: A list of :class:`~swift.common.utils.Namespace` or
+        :class:`~swift.common.utils.ShardRange`.
+    :param includes: a string; if not empty then only the Namespace,
+        if any, whose namespace includes this string will be returned,
+        ``marker`` and ``end_marker`` will be ignored.
     :param marker: if specified then only shard ranges whose upper bound is
         greater than this value will be returned.
     :param end_marker: if specified then only shard ranges whose lower bound is
         less than this value will be returned.
-    :return: A filtered list of :class:`~swift.common.utils.ShardRange`.
+    :return: A filtered list of :class:`~swift.common.utils.Namespace`.
     """
     if includes:
-        shard_range = find_shard_range(includes, shard_ranges)
-        return [shard_range] if shard_range else []
+        namespace = find_namespace(includes, namespaces)
+        return [namespace] if namespace else []
 
-    def shard_range_filter(sr):
+    def namespace_filter(sr):
         end = start = True
         if end_marker:
             end = end_marker > sr.lower
@@ -6229,79 +5703,13 @@ def filter_shard_ranges(shard_ranges, includes, marker, end_marker):
         return start and end
 
     if marker or end_marker:
-        return list(filter(shard_range_filter, shard_ranges))
+        return list(filter(namespace_filter, namespaces))
 
-    if marker == ShardRange.MAX or end_marker == ShardRange.MIN:
-        # MIN and MAX are both Falsy so not handled by shard_range_filter
+    if marker == Namespace.MAX or end_marker == Namespace.MIN:
+        # MIN and MAX are both Falsy so not handled by namespace_filter
         return []
 
-    return shard_ranges
-
-
-def modify_priority(conf, logger):
-    """
-    Modify priority by nice and ionice.
-    """
-
-    global _libc_setpriority
-    if _libc_setpriority is None:
-        _libc_setpriority = load_libc_function('setpriority',
-                                               errcheck=True)
-
-    def _setpriority(nice_priority):
-        """
-        setpriority for this pid
-
-        :param nice_priority: valid values are -19 to 20
-        """
-        try:
-            _libc_setpriority(PRIO_PROCESS, os.getpid(),
-                              int(nice_priority))
-        except (ValueError, OSError):
-            print(_("WARNING: Unable to modify scheduling priority of process."
-                    " Keeping unchanged! Check logs for more info. "))
-            logger.exception('Unable to modify nice priority')
-        else:
-            logger.debug('set nice priority to %s' % nice_priority)
-
-    nice_priority = conf.get('nice_priority')
-    if nice_priority is not None:
-        _setpriority(nice_priority)
-
-    global _posix_syscall
-    if _posix_syscall is None:
-        _posix_syscall = load_libc_function('syscall', errcheck=True)
-
-    def _ioprio_set(io_class, io_priority):
-        """
-        ioprio_set for this process
-
-        :param io_class: the I/O class component, can be
-                         IOPRIO_CLASS_RT, IOPRIO_CLASS_BE,
-                         or IOPRIO_CLASS_IDLE
-        :param io_priority: priority value in the I/O class
-        """
-        try:
-            io_class = IO_CLASS_ENUM[io_class]
-            io_priority = int(io_priority)
-            _posix_syscall(NR_ioprio_set(),
-                           IOPRIO_WHO_PROCESS,
-                           os.getpid(),
-                           IOPRIO_PRIO_VALUE(io_class, io_priority))
-        except (KeyError, ValueError, OSError):
-            print(_("WARNING: Unable to modify I/O scheduling class "
-                    "and priority of process. Keeping unchanged! "
-                    "Check logs for more info."))
-            logger.exception("Unable to modify ionice priority")
-        else:
-            logger.debug('set ionice class %s priority %s',
-                         io_class, io_priority)
-
-    io_class = conf.get("ionice_class")
-    if io_class is None:
-        return
-    io_priority = conf.get("ionice_priority", 0)
-    _ioprio_set(io_class, io_priority)
+    return namespaces
 
 
 def o_tmpfile_in_path_supported(dirpath):
@@ -6369,6 +5777,15 @@ def strict_b64decode(value, allow_line_breaks=False):
         raise ValueError
 
 
+def cap_length(value, max_length):
+    if value and len(value) > max_length:
+        if isinstance(value, bytes):
+            return value[:max_length] + b'...'
+        else:
+            return value[:max_length] + '...'
+    return value
+
+
 MD5_BLOCK_READ_BYTES = 4096
 
 
@@ -6590,6 +6007,7 @@ class NoopMutex(object):
     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
@@ -6857,6 +6275,7 @@ class Watchdog(object):
         => the exception is raised, then the greenlet watchdog sleep(3) to
            wake up for the 1st timeout expiration
     """
+
     def __init__(self):
         # key => (timeout, timeout_at, caller_greenthread, exception)
         self._timeouts = dict()
@@ -6870,14 +6289,15 @@ class Watchdog(object):
 
         :param timeout: duration before the timeout expires
         :param exc: exception to throw when the timeout expire, must inherit
-                    from eventlet.timeouts.Timeout
+                    from eventlet.Timeout
         :param timeout_at: allow to force the expiration timestamp
         :return: id of the scheduled timeout, needed to cancel it
         """
+        now = time.time()
         if not timeout_at:
-            timeout_at = time.time() + timeout
+            timeout_at = now + timeout
         gth = eventlet.greenthread.getcurrent()
-        timeout_definition = (timeout, timeout_at, gth, exc)
+        timeout_definition = (timeout, timeout_at, gth, exc, now)
         key = id(timeout_definition)
         self._timeouts[key] = timeout_definition
 
@@ -6900,8 +6320,7 @@ class Watchdog(object):
         :param key: timeout id, as returned by start()
         """
         try:
-            if key in self._timeouts:
-                del(self._timeouts[key])
+            del(self._timeouts[key])
         except KeyError:
             pass
 
@@ -6921,15 +6340,14 @@ class Watchdog(object):
         self._next_expiration = None
         if self._evt.ready():
             self._evt.reset()
-        for k, (timeout, timeout_at, gth, exc) in list(self._timeouts.items()):
+        for k, (timeout, timeout_at, gth, exc,
+                created_at) in list(self._timeouts.items()):
             if timeout_at <= now:
-                try:
-                    if k in self._timeouts:
-                        del(self._timeouts[k])
-                except KeyError:
-                    pass
+                self.stop(k)
                 e = exc()
+                # set this after __init__ to keep it off the eventlet scheduler
                 e.seconds = timeout
+                e.created_at = created_at
                 eventlet.hubs.get_hub().schedule_call_global(0, gth.throw, e)
             else:
                 if (self._next_expiration is None
@@ -6946,6 +6364,7 @@ class WatchdogTimeout(object):
     """
     Context manager to schedule a timeout in a Watchdog instance
     """
+
     def __init__(self, watchdog, timeout, exc, timeout_at=None):
         """
         Schedule a timeout in a Watchdog instance
@@ -6964,3 +6383,48 @@ class WatchdogTimeout(object):
 
     def __exit__(self, type, value, traceback):
         self.watchdog.stop(self.key)
+
+
+class CooperativeIterator(object):
+    """
+    Wrapper to make a deliberate periodic call to ``sleep()`` while iterating
+    over wrapped iterator, providing an opportunity to switch greenthreads.
+
+    This is for fairness; if the network is outpacing the CPU, we'll always be
+    able to read and write data without encountering an EWOULDBLOCK, and so
+    eventlet will not switch greenthreads on its own. We do it manually so that
+    clients don't starve.
+
+    The number 5 here was chosen by making stuff up. It's not every single
+    chunk, but it's not too big either, so it seemed like it would probably be
+    an okay choice.
+
+    Note that we may trampoline to other greenthreads more often than once
+    every 5 chunks, depending on how blocking our network IO is; the explicit
+    sleep here simply provides a lower bound on the rate of trampolining.
+
+    :param iterable: iterator to wrap.
+    :param period: number of items yielded from this iterator between calls to
+        ``sleep()``.
+    """
+    __slots__ = ('period', 'count', 'wrapped_iter')
+
+    def __init__(self, iterable, period=5):
+        self.wrapped_iter = 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)