swift 2.23.2__py3-none-any.whl → 2.35.0__py3-none-any.whl

swift/common/memcached.py

@@ -44,19 +44,23 @@ version is at:
 http://github.com/memcached/memcached/blob/1.4.2/doc/protocol.txt
 """
 
-import six
-import six.moves.cPickle as pickle
+import os
 import json
 import logging
-import time
+# the name of 'time' module is changed to 'tm', to avoid changing the
+# signatures of member functions in this file.
+import time as tm
 from bisect import bisect
-from hashlib import md5
 
-from eventlet.green import socket
+from eventlet.green import socket, ssl
 from eventlet.pools import Pool
 from eventlet import Timeout
-from six.moves import range
+from configparser import ConfigParser, NoSectionError, NoOptionError
 from swift.common import utils
+from swift.common.exceptions import MemcacheConnectionError, \
+    MemcacheIncrNotFoundError, MemcachePoolTimeout
+from swift.common.utils import md5, human_readable, config_true_value, \
+    memcached_timing_stats
 
 DEFAULT_MEMCACHED_PORT = 11211
 
@@ -66,23 +70,27 @@ IO_TIMEOUT = 2.0
 PICKLE_FLAG = 1
 JSON_FLAG = 2
 NODE_WEIGHT = 50
-PICKLE_PROTOCOL = 2
 TRY_COUNT = 3
 
 # if ERROR_LIMIT_COUNT errors occur in ERROR_LIMIT_TIME seconds, the server
 # will be considered failed for ERROR_LIMIT_DURATION seconds.
 ERROR_LIMIT_COUNT = 10
-ERROR_LIMIT_TIME = 60
-ERROR_LIMIT_DURATION = 60
+ERROR_LIMIT_TIME = ERROR_LIMIT_DURATION = 60
+DEFAULT_ITEM_SIZE_WARNING_THRESHOLD = -1
+
+# Different sample rates for emitting Memcached timing stats.
+TIMING_SAMPLE_RATE_HIGH = 0.1
+TIMING_SAMPLE_RATE_MEDIUM = 0.01
+TIMING_SAMPLE_RATE_LOW = 0.001
+
+# The max value of a delta expiration time.
+EXPTIME_MAXDELTA = 30 * 24 * 60 * 60
 
 
 def md5hash(key):
     if not isinstance(key, bytes):
-        if six.PY2:
-            key = key.encode('utf-8')
-        else:
-            key = key.encode('utf-8', errors='surrogateescape')
-    return md5(key).hexdigest().encode('ascii')
+        key = key.encode('utf-8', errors='surrogateescape')
+    return md5(key, usedforsecurity=False).hexdigest().encode('ascii')
 
 
 def sanitize_timeout(timeout):
@@ -92,8 +100,8 @@ def sanitize_timeout(timeout):
     translates negative values to mean a delta of 30 days in seconds (and 1
     additional second), client beware.
     """
-    if timeout > (30 * 24 * 60 * 60):
-        timeout += time.time()
+    if timeout > EXPTIME_MAXDELTA:
+        timeout += tm.time()
     return int(timeout)
 
 
@@ -111,14 +119,6 @@ def set_msg(key, flags, timeout, value):
     ]) + (b'\r\n' + value + b'\r\n')
 
 
-class MemcacheConnectionError(Exception):
-    pass
-
-
-class MemcachePoolTimeout(Timeout):
-    pass
-
-
 class MemcacheConnPool(Pool):
     """
     Connection pool for Memcache Connections
@@ -128,11 +128,12 @@ class MemcacheConnPool(Pool):
     :func:`swift.common.utils.parse_socket_string` for details.
     """
 
-    def __init__(self, server, size, connect_timeout):
+    def __init__(self, server, size, connect_timeout, tls_context=None):
         Pool.__init__(self, max_size=size)
         self.host, self.port = utils.parse_socket_string(
             server, DEFAULT_MEMCACHED_PORT)
         self._connect_timeout = connect_timeout
+        self._tls_context = tls_context
 
     def create(self):
         addrs = socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC,
@@ -140,16 +141,54 @@ class MemcacheConnPool(Pool):
         family, socktype, proto, canonname, sockaddr = addrs[0]
         sock = socket.socket(family, socket.SOCK_STREAM)
         sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        with Timeout(self._connect_timeout):
-            sock.connect(sockaddr)
+        try:
+            with Timeout(self._connect_timeout):
+                sock.connect(sockaddr)
+            if self._tls_context:
+                sock = self._tls_context.wrap_socket(sock,
+                                                     server_hostname=self.host)
+        except (Exception, Timeout):
+            sock.close()
+            raise
         return (sock.makefile('rwb'), sock)
 
     def get(self):
         fp, sock = super(MemcacheConnPool, self).get()
-        if fp is None:
-            # An error happened previously, so we need a new connection
-            fp, sock = self.create()
-        return fp, sock
+        try:
+            if fp is None:
+                # An error happened previously, so we need a new connection
+                fp, sock = self.create()
+            return fp, sock
+        except MemcachePoolTimeout:
+            # This is the only place that knows an item was successfully taken
+            # from the pool, so it has to be responsible for repopulating it.
+            # Any other errors should get handled in _get_conns(); see the
+            # comment about timeouts during create() there.
+            self.put((None, None))
+            raise
+
+
+class MemcacheCommand(object):
+    """
+    Helper class that encapsulates common parameters of a command.
+
+    :param method: the name of the MemcacheRing method that was called.
+    :param key: the memcached key.
+    """
+    __slots__ = ('method', 'key', 'command', 'hash_key')
+
+    def __init__(self, method, key):
+        self.method = method
+        self.key = key
+        self.command = method.encode()
+        self.hash_key = md5hash(key)
+
+    @property
+    def key_prefix(self):
+        # get the prefix of a user provided memcache key by removing the
+        # content after the last '/', all current usages within swift are using
+        # prefix, such as "shard-updating-v2", "nvratelimit" and etc.
+        return self.key.rsplit('/', 1)[0]
 
 
 class MemcacheRing(object):
@@ -157,39 +196,100 @@ class MemcacheRing(object):
     Simple, consistent-hashed memcache client.
     """
 
-    def __init__(self, servers, connect_timeout=CONN_TIMEOUT,
-                 io_timeout=IO_TIMEOUT, pool_timeout=POOL_TIMEOUT,
-                 tries=TRY_COUNT, allow_pickle=False, allow_unpickle=False,
-                 max_conns=2):
+    def __init__(
+            self, servers, connect_timeout=CONN_TIMEOUT,
+            io_timeout=IO_TIMEOUT, pool_timeout=POOL_TIMEOUT,
+            tries=TRY_COUNT,
+            max_conns=2, tls_context=None, logger=None,
+            error_limit_count=ERROR_LIMIT_COUNT,
+            error_limit_time=ERROR_LIMIT_TIME,
+            error_limit_duration=ERROR_LIMIT_DURATION,
+            item_size_warning_threshold=DEFAULT_ITEM_SIZE_WARNING_THRESHOLD):
         self._ring = {}
         self._errors = dict(((serv, []) for serv in servers))
         self._error_limited = dict(((serv, 0) for serv in servers))
+        self._error_limit_count = error_limit_count
+        self._error_limit_time = error_limit_time
+        self._error_limit_duration = error_limit_duration
         for server in sorted(servers):
             for i in range(NODE_WEIGHT):
                 self._ring[md5hash('%s-%s' % (server, i))] = server
         self._tries = tries if tries <= len(servers) else len(servers)
         self._sorted = sorted(self._ring)
-        self._client_cache = dict(((server,
-                                    MemcacheConnPool(server, max_conns,
-                                                     connect_timeout))
-                                  for server in servers))
+        self._client_cache = dict((
+            (server, MemcacheConnPool(server, max_conns, connect_timeout,
+                                      tls_context=tls_context))
+            for server in servers))
         self._connect_timeout = connect_timeout
         self._io_timeout = io_timeout
         self._pool_timeout = pool_timeout
-        self._allow_pickle = allow_pickle
-        self._allow_unpickle = allow_unpickle or allow_pickle
+        if logger is None:
+            self.logger = logging.getLogger()
+        else:
+            self.logger = logger
+        self.item_size_warning_threshold = item_size_warning_threshold
 
-    def _exception_occurred(self, server, e, action='talking',
-                            sock=None, fp=None, got_connection=True):
+    @property
+    def memcache_servers(self):
+        return list(self._client_cache.keys())
+
+    def _log_error(self, server, cmd, action, msg):
+        self.logger.error(
+            "Error %(action)s to memcached: %(server)s"
+            ": with key_prefix %(key_prefix)s, method %(method)s: %(msg)s",
+            {'action': action, 'server': server, 'key_prefix': cmd.key_prefix,
+             'method': cmd.method, 'msg': msg})
+
+    """
+    Handles exceptions.
+
+    :param server: a server.
+    :param e: an exception.
+    :param cmd: an instance of MemcacheCommand.
+    :param conn_start_time: the time at which the failed operation started.
+    :param action: a verb describing the operation.
+    :param sock: an optional socket that needs to be closed by this method.
+    :param fp: an optional file pointer that needs to be closed by this method.
+    :param got_connection: if ``True``, the server's connection will be reset
+        in the cached connection pool.
+    """
+    def _exception_occurred(self, server, e, cmd, conn_start_time,
+                            action='talking', sock=None,
+                            fp=None, got_connection=True):
         if isinstance(e, Timeout):
-            logging.error("Timeout %(action)s to memcached: %(server)s",
-                          {'action': action, 'server': server})
+            self.logger.error(
+                "Timeout %(action)s to memcached: %(server)s"
+                ": with key_prefix %(key_prefix)s, method %(method)s, "
+                "config_timeout %(config_timeout)s, time_spent %(time_spent)s",
+                {'action': action, 'server': server,
+                 'key_prefix': cmd.key_prefix, 'method': cmd.method,
+                 'config_timeout': e.seconds,
+                 'time_spent': tm.time() - conn_start_time})
+            self.logger.timing_since(
+                'memcached.' + cmd.method + '.timeout.timing',
+                conn_start_time)
         elif isinstance(e, (socket.error, MemcacheConnectionError)):
-            logging.error("Error %(action)s to memcached: %(server)s: %(err)s",
-                          {'action': action, 'server': server, 'err': e})
+            self.logger.error(
+                "Error %(action)s to memcached: %(server)s: "
+                "with key_prefix %(key_prefix)s, method %(method)s, "
+                "time_spent %(time_spent)s, %(err)s",
+                {'action': action, 'server': server,
+                 'key_prefix': cmd.key_prefix, 'method': cmd.method,
+                 'time_spent': tm.time() - conn_start_time, 'err': e})
+            self.logger.timing_since(
+                'memcached.' + cmd.method + '.conn_err.timing',
+                conn_start_time)
         else:
-            logging.exception("Error %(action)s to memcached: %(server)s",
-                              {'action': action, 'server': server})
+            self.logger.exception(
+                "Error %(action)s to memcached: %(server)s"
+                ": with key_prefix %(key_prefix)s, method %(method)s, "
+                "time_spent %(time_spent)s",
+                {'action': action, 'server': server,
+                 'key_prefix': cmd.key_prefix, 'method': cmd.method,
+                 'time_spent': tm.time() - conn_start_time})
+            self.logger.timing_since(
+                'memcached.' + cmd.method + '.errors.timing', conn_start_time)
+
         try:
             if fp:
                 fp.close()
@@ -206,73 +306,93 @@ class MemcacheRing(object):
             # We need to return something to the pool
             # A new connection will be created the next time it is retrieved
             self._return_conn(server, None, None)
-        now = time.time()
-        self._errors[server].append(time.time())
-        if len(self._errors[server]) > ERROR_LIMIT_COUNT:
+
+        if isinstance(e, MemcacheIncrNotFoundError):
+            # these errors can be caused by other greenthreads not yielding to
+            # the incr greenthread often enough, rather than a server problem,
+            # so don't error limit the server
+            return
+
+        if self._error_limit_time <= 0 or self._error_limit_duration <= 0:
+            return
+
+        now = tm.time()
+        self._errors[server].append(now)
+        if len(self._errors[server]) > self._error_limit_count:
             self._errors[server] = [err for err in self._errors[server]
-                                    if err > now - ERROR_LIMIT_TIME]
-            if len(self._errors[server]) > ERROR_LIMIT_COUNT:
-                self._error_limited[server] = now + ERROR_LIMIT_DURATION
-                logging.error('Error limiting server %s', server)
+                                    if err > now - self._error_limit_time]
+            if len(self._errors[server]) > self._error_limit_count:
+                self._error_limited[server] = now + self._error_limit_duration
+                self.logger.error('Error limiting server %s', server)
 
-    def _get_conns(self, key):
+    def _get_conns(self, cmd):
         """
         Retrieves a server conn from the pool, or connects a new one.
         Chooses the server based on a consistent hash of "key".
+
+        :param cmd: an instance of MemcacheCommand.
+        :return: generator to serve memcached connection
         """
-        pos = bisect(self._sorted, key)
+        pos = bisect(self._sorted, cmd.hash_key)
         served = []
+        any_yielded = False
         while len(served) < self._tries:
             pos = (pos + 1) % len(self._sorted)
             server = self._ring[self._sorted[pos]]
             if server in served:
                 continue
             served.append(server)
-            if self._error_limited[server] > time.time():
+            pool_start_time = tm.time()
+            if self._error_limited[server] > pool_start_time:
                 continue
             sock = None
             try:
                 with MemcachePoolTimeout(self._pool_timeout):
                     fp, sock = self._client_cache[server].get()
+                any_yielded = True
                 yield server, fp, sock
             except MemcachePoolTimeout as e:
-                self._exception_occurred(
-                    server, e, action='getting a connection',
-                    got_connection=False)
+                self._exception_occurred(server, e, cmd, pool_start_time,
+                                         action='getting a connection',
+                                         got_connection=False)
             except (Exception, Timeout) as e:
                 # Typically a Timeout exception caught here is the one raised
                 # by the create() method of this server's MemcacheConnPool
                 # object.
-                self._exception_occurred(
-                    server, e, action='connecting', sock=sock)
+                self._exception_occurred(server, e, cmd, pool_start_time,
+                                         action='connecting', sock=sock)
+        if not any_yielded:
+            self._log_error('ALL', cmd, 'connecting',
+                            'No more memcached servers to try')
 
     def _return_conn(self, server, fp, sock):
         """Returns a server connection to the pool."""
         self._client_cache[server].put((fp, sock))
 
+    # Sample rates of different memcached operations are based on generic
+    # swift usage patterns.
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_HIGH)
     def set(self, key, value, serialize=True, time=0,
-            min_compress_len=0):
+            min_compress_len=0, raise_on_error=False):
         """
         Set a key/value pair in memcache
 
         :param key: key
         :param value: value
         :param serialize: if True, value is serialized with JSON before sending
-                          to memcache, or with pickle if configured to use
-                          pickle instead of JSON (to avoid cache poisoning)
+                          to memcache
         :param time: the time to live
         :param min_compress_len: minimum compress length, this parameter was
                                  added to keep the signature compatible with
                                  python-memcached interface. This
                                  implementation ignores it.
+        :param raise_on_error: if True, propagate Timeouts and other errors.
+                               By default, errors are ignored.
         """
-        key = md5hash(key)
+        cmd = MemcacheCommand('set', key)
         timeout = sanitize_timeout(time)
         flags = 0
-        if serialize and self._allow_pickle:
-            value = pickle.dumps(value, PICKLE_PROTOCOL)
-            flags |= PICKLE_FLAG
-        elif serialize:
+        if serialize:
             if isinstance(value, bytes):
                 value = value.decode('utf8')
             value = json.dumps(value).encode('ascii')
@@ -280,55 +400,94 @@ class MemcacheRing(object):
         elif not isinstance(value, bytes):
             value = str(value).encode('utf-8')
 
-        for (server, fp, sock) in self._get_conns(key):
+        if 0 <= self.item_size_warning_threshold <= len(value):
+            self.logger.warning(
+                "Item size larger than warning threshold: "
+                "%d (%s) >= %d (%s)", len(value),
+                human_readable(len(value)),
+                self.item_size_warning_threshold,
+                human_readable(self.item_size_warning_threshold))
+
+        for (server, fp, sock) in self._get_conns(cmd):
+            conn_start_time = tm.time()
             try:
                 with Timeout(self._io_timeout):
-                    sock.sendall(set_msg(key, flags, timeout, value))
+                    sock.sendall(set_msg(cmd.hash_key, flags, timeout, value))
                     # Wait for the set to complete
-                    fp.readline()
+                    msg = fp.readline().strip()
+                    if msg != b'STORED':
+                        msg = msg.decode('ascii')
+                        raise MemcacheConnectionError('failed set: %s' % msg)
                     self._return_conn(server, fp, sock)
                     return
             except (Exception, Timeout) as e:
-                self._exception_occurred(server, e, sock=sock, fp=fp)
-
-    def get(self, key):
+                self._exception_occurred(server, e, cmd, conn_start_time,
+                                         sock=sock, fp=fp)
+        if raise_on_error:
+            raise MemcacheConnectionError(
+                "No memcached connections succeeded.")
+
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_MEDIUM)
+    def get(self, key, raise_on_error=False):
         """
         Gets the object specified by key.  It will also unserialize the object
-        before returning if it is serialized in memcache with JSON, or if it
-        is pickled and unpickling is allowed.
+        before returning if it is serialized in memcache with JSON.
 
         :param key: key
+        :param raise_on_error: if True, propagate Timeouts and other errors.
+                               By default, errors are treated as cache misses.
         :returns: value of the key in memcache
         """
-        key = md5hash(key)
+        cmd = MemcacheCommand('get', key)
         value = None
-        for (server, fp, sock) in self._get_conns(key):
+        for (server, fp, sock) in self._get_conns(cmd):
+            conn_start_time = tm.time()
             try:
                 with Timeout(self._io_timeout):
-                    sock.sendall(b'get ' + key + b'\r\n')
+                    sock.sendall(b'get ' + cmd.hash_key + b'\r\n')
                     line = fp.readline().strip().split()
                     while True:
                         if not line:
                             raise MemcacheConnectionError('incomplete read')
                         if line[0].upper() == b'END':
                             break
-                        if line[0].upper() == b'VALUE' and line[1] == key:
+                        if (line[0].upper() == b'VALUE' and
+                                line[1] == cmd.hash_key):
                             size = int(line[3])
                             value = fp.read(size)
                             if int(line[2]) & PICKLE_FLAG:
-                                if self._allow_unpickle:
-                                    value = pickle.loads(value)
-                                else:
-                                    value = None
-                            elif int(line[2]) & JSON_FLAG:
+                                value = None
+                            if int(line[2]) & JSON_FLAG:
                                 value = json.loads(value)
                             fp.readline()
                         line = fp.readline().strip().split()
                     self._return_conn(server, fp, sock)
                     return value
             except (Exception, Timeout) as e:
-                self._exception_occurred(server, e, sock=sock, fp=fp)
-
+                self._exception_occurred(server, e, cmd, conn_start_time,
+                                         sock=sock, fp=fp)
+        if raise_on_error:
+            raise MemcacheConnectionError(
+                "No memcached connections succeeded.")
+
+    def _incr_or_decr(self, fp, sock, cmd, delta):
+        sock.sendall(b' '.join([cmd.command, cmd.hash_key, delta]) + b'\r\n')
+        line = fp.readline().strip().split()
+        if not line:
+            raise MemcacheConnectionError('incomplete read')
+        if line[0].upper() == b'NOT_FOUND':
+            return None
+        return int(line[0].strip())
+
+    def _add(self, fp, sock, cmd, add_val, timeout):
+        sock.sendall(b' '.join([
+            b'add', cmd.hash_key, b'0', str(timeout).encode('ascii'),
+            str(len(add_val)).encode('ascii')
+        ]) + b'\r\n' + add_val + b'\r\n')
+        line = fp.readline().strip().split()
+        return None if line[0].upper() == b'NOT_STORED' else int(add_val)
+
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_LOW)
     def incr(self, key, delta=1, time=0):
         """
         Increments a key which has a numeric value by delta.
@@ -346,44 +505,35 @@ class MemcacheRing(object):
         :returns: result of incrementing
         :raises MemcacheConnectionError:
         """
-        key = md5hash(key)
-        command = b'incr'
-        if delta < 0:
-            command = b'decr'
-        delta = str(abs(int(delta))).encode('ascii')
+        cmd = MemcacheCommand('incr' if delta >= 0 else 'decr', key)
+        delta_val = str(abs(int(delta))).encode('ascii')
         timeout = sanitize_timeout(time)
-        for (server, fp, sock) in self._get_conns(key):
+        for (server, fp, sock) in self._get_conns(cmd):
+            conn_start_time = tm.time()
             try:
                 with Timeout(self._io_timeout):
-                    sock.sendall(b' '.join([
-                        command, key, delta]) + b'\r\n')
-                    line = fp.readline().strip().split()
-                    if not line:
-                        raise MemcacheConnectionError('incomplete read')
-                    if line[0].upper() == b'NOT_FOUND':
-                        add_val = delta
-                        if command == b'decr':
-                            add_val = b'0'
-                        sock.sendall(b' '.join([
-                            b'add', key, b'0', str(timeout).encode('ascii'),
-                            str(len(add_val)).encode('ascii')
-                        ]) + b'\r\n' + add_val + b'\r\n')
-                        line = fp.readline().strip().split()
-                        if line[0].upper() == b'NOT_STORED':
-                            sock.sendall(b' '.join([
-                                command, key, delta]) + b'\r\n')
-                            line = fp.readline().strip().split()
-                            ret = int(line[0].strip())
-                        else:
-                            ret = int(add_val)
-                    else:
-                        ret = int(line[0].strip())
+                    new_val = self._incr_or_decr(fp, sock, cmd, delta_val)
+                    if new_val is None:
+                        add_val = b'0' if cmd.method == 'decr' else delta_val
+                        new_val = self._add(fp, sock, cmd, add_val, timeout)
+                        if new_val is None:
+                            new_val = self._incr_or_decr(
+                                fp, sock, cmd, delta_val)
+                            if new_val is None:
+                                # This can happen if this thread takes more
+                                # than the TTL to get from the first failed
+                                # incr to the second incr, during which time
+                                # the key was concurrently added and expired.
+                                raise MemcacheIncrNotFoundError(
+                                    'expired ttl=%s' % time)
                     self._return_conn(server, fp, sock)
-                    return ret
+                    return new_val
             except (Exception, Timeout) as e:
-                self._exception_occurred(server, e, sock=sock, fp=fp)
-        raise MemcacheConnectionError("No Memcached connections succeeded.")
+                self._exception_occurred(server, e, cmd, conn_start_time,
+                                         sock=sock, fp=fp)
+        raise MemcacheConnectionError("No memcached connections succeeded.")
 
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_LOW)
     def decr(self, key, delta=1, time=0):
         """
         Decrements a key which has a numeric value by delta. Calls incr with
@@ -399,24 +549,32 @@ class MemcacheRing(object):
         """
         return self.incr(key, delta=-delta, time=time)
 
-    def delete(self, key):
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_HIGH)
+    def delete(self, key, server_key=None):
         """
         Deletes a key/value pair from memcache.
 
         :param key: key to be deleted
+        :param server_key: key to use in determining which server in the ring
+                            is used
         """
-        key = md5hash(key)
-        for (server, fp, sock) in self._get_conns(key):
+        cmd = server_cmd = MemcacheCommand('delete', key)
+        if server_key:
+            server_cmd = MemcacheCommand('delete', server_key)
+        for (server, fp, sock) in self._get_conns(server_cmd):
+            conn_start_time = tm.time()
             try:
                 with Timeout(self._io_timeout):
-                    sock.sendall(b'delete ' + key + b'\r\n')
+                    sock.sendall(b'delete ' + cmd.hash_key + b'\r\n')
                     # Wait for the delete to complete
                     fp.readline()
                     self._return_conn(server, fp, sock)
                     return
             except (Exception, Timeout) as e:
-                self._exception_occurred(server, e, sock=sock, fp=fp)
+                self._exception_occurred(server, e, cmd, conn_start_time,
+                                         sock=sock, fp=fp)
 
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_HIGH)
     def set_multi(self, mapping, server_key, serialize=True, time=0,
                   min_compress_len=0):
         """
@@ -426,30 +584,27 @@ class MemcacheRing(object):
         :param server_key: key to use in determining which server in the ring
                             is used
         :param serialize: if True, value is serialized with JSON before sending
-                          to memcache, or with pickle if configured to use
-                          pickle instead of JSON (to avoid cache poisoning)
+                          to memcache.
         :param time: the time to live
         :min_compress_len: minimum compress length, this parameter was added
                            to keep the signature compatible with
                            python-memcached interface. This implementation
                            ignores it
         """
-        server_key = md5hash(server_key)
+        cmd = MemcacheCommand('set_multi', server_key)
         timeout = sanitize_timeout(time)
         msg = []
         for key, value in mapping.items():
             key = md5hash(key)
             flags = 0
-            if serialize and self._allow_pickle:
-                value = pickle.dumps(value, PICKLE_PROTOCOL)
-                flags |= PICKLE_FLAG
-            elif serialize:
+            if serialize:
                 if isinstance(value, bytes):
                     value = value.decode('utf8')
                 value = json.dumps(value).encode('ascii')
                 flags |= JSON_FLAG
             msg.append(set_msg(key, flags, timeout, value))
-        for (server, fp, sock) in self._get_conns(server_key):
+        for (server, fp, sock) in self._get_conns(cmd):
+            conn_start_time = tm.time()
             try:
                 with Timeout(self._io_timeout):
                     sock.sendall(b''.join(msg))
@@ -459,8 +614,10 @@ class MemcacheRing(object):
                     self._return_conn(server, fp, sock)
                     return
             except (Exception, Timeout) as e:
-                self._exception_occurred(server, e, sock=sock, fp=fp)
+                self._exception_occurred(server, e, cmd, conn_start_time,
+                                         sock=sock, fp=fp)
 
+    @memcached_timing_stats(sample_rate=TIMING_SAMPLE_RATE_HIGH)
     def get_multi(self, keys, server_key):
         """
         Gets multiple values from memcache for the given keys.
@@ -470,12 +627,13 @@ class MemcacheRing(object):
                            is used
         :returns: list of values
         """
-        server_key = md5hash(server_key)
-        keys = [md5hash(key) for key in keys]
-        for (server, fp, sock) in self._get_conns(server_key):
+        cmd = MemcacheCommand('get_multi', server_key)
+        hash_keys = [md5hash(key) for key in keys]
+        for (server, fp, sock) in self._get_conns(cmd):
+            conn_start_time = tm.time()
             try:
                 with Timeout(self._io_timeout):
-                    sock.sendall(b'get ' + b' '.join(keys) + b'\r\n')
+                    sock.sendall(b'get ' + b' '.join(hash_keys) + b'\r\n')
                     line = fp.readline().strip().split()
                     responses = {}
                     while True:
@@ -487,17 +645,14 @@ class MemcacheRing(object):
                             size = int(line[3])
                             value = fp.read(size)
                             if int(line[2]) & PICKLE_FLAG:
-                                if self._allow_unpickle:
-                                    value = pickle.loads(value)
-                                else:
-                                    value = None
+                                value = None
                             elif int(line[2]) & JSON_FLAG:
                                 value = json.loads(value)
                             responses[line[1]] = value
                             fp.readline()
                         line = fp.readline().strip().split()
                     values = []
-                    for key in keys:
+                    for key in hash_keys:
                         if key in responses:
                             values.append(responses[key])
                         else:
@@ -505,4 +660,98 @@ class MemcacheRing(object):
                     self._return_conn(server, fp, sock)
                     return values
             except (Exception, Timeout) as e:
-                self._exception_occurred(server, e, sock=sock, fp=fp)
+                self._exception_occurred(server, e, cmd, conn_start_time,
+                                         sock=sock, fp=fp)
+
+
+def load_memcache(conf, logger):
+    """
+    Build a MemcacheRing object from the given config.  It will also use the
+    passed in logger.
+
+    :param conf: a dict, the config options
+    :param logger: a logger
+    """
+    memcache_servers = conf.get('memcache_servers')
+    try:
+        # Originally, while we documented using memcache_max_connections
+        # we only accepted max_connections
+        max_conns = int(conf.get('memcache_max_connections',
+                                 conf.get('max_connections', 0)))
+    except ValueError:
+        max_conns = 0
+
+    memcache_options = {}
+    if (not memcache_servers
+            or max_conns <= 0):
+        path = os.path.join(conf.get('swift_dir', '/etc/swift'),
+                            'memcache.conf')
+        memcache_conf = ConfigParser()
+        if memcache_conf.read(path):
+            # if memcache.conf exists we'll start with those base options
+            try:
+                memcache_options = dict(memcache_conf.items('memcache'))
+            except NoSectionError:
+                pass
+
+            if not memcache_servers:
+                try:
+                    memcache_servers = \
+                        memcache_conf.get('memcache', 'memcache_servers')
+                except (NoSectionError, NoOptionError):
+                    pass
+            if max_conns <= 0:
+                try:
+                    new_max_conns = \
+                        memcache_conf.get('memcache',
+                                          'memcache_max_connections')
+                    max_conns = int(new_max_conns)
+                except (NoSectionError, NoOptionError, ValueError):
+                    pass
+
+    # while memcache.conf options are the base for the memcache
+    # middleware, if you set the same option also in the filter
+    # section of the proxy config it is more specific.
+    memcache_options.update(conf)
+    connect_timeout = float(memcache_options.get(
+        'connect_timeout', CONN_TIMEOUT))
+    pool_timeout = float(memcache_options.get(
+        'pool_timeout', POOL_TIMEOUT))
+    tries = int(memcache_options.get('tries', TRY_COUNT))
+    io_timeout = float(memcache_options.get('io_timeout', IO_TIMEOUT))
+    if config_true_value(memcache_options.get('tls_enabled', 'false')):
+        tls_cafile = memcache_options.get('tls_cafile')
+        tls_certfile = memcache_options.get('tls_certfile')
+        tls_keyfile = memcache_options.get('tls_keyfile')
+        tls_context = ssl.create_default_context(
+            cafile=tls_cafile)
+        if tls_certfile:
+            tls_context.load_cert_chain(tls_certfile, tls_keyfile)
+    else:
+        tls_context = None
+    error_suppression_interval = float(memcache_options.get(
+        'error_suppression_interval', ERROR_LIMIT_TIME))
+    error_suppression_limit = float(memcache_options.get(
+        'error_suppression_limit', ERROR_LIMIT_COUNT))
+    item_size_warning_threshold = int(memcache_options.get(
+        'item_size_warning_threshold', DEFAULT_ITEM_SIZE_WARNING_THRESHOLD))
+
+    if not memcache_servers:
+        memcache_servers = '127.0.0.1:11211'
+    if max_conns <= 0:
+        max_conns = 2
+
+    return MemcacheRing(
+        [s.strip() for s in memcache_servers.split(',')
+         if s.strip()],
+        connect_timeout=connect_timeout,
+        pool_timeout=pool_timeout,
+        tries=tries,
+        io_timeout=io_timeout,
+        max_conns=max_conns,
+        tls_context=tls_context,
+        logger=logger,
+        error_limit_count=error_suppression_limit,
+        error_limit_time=error_suppression_interval,
+        error_limit_duration=error_suppression_interval,
+        item_size_warning_threshold=item_size_warning_threshold)