rewrite memcache_client.py monkey patch based on python_memcached-1.53.

still keeping backward compatibility with older python_memcached.

product/ERP5Type/patches/memcache_client.py

 # -*- coding: utf-8 -*-
-# Code based on python-memcached-1.45
+# Code based on python-memcached-1.53
 try:
     from memcache import _Host, Client, _Error
 except ImportError:
     pass
 else:
     _Host._SOCKET_TIMEOUT = 10 # wait more than 3s is safe
-    # always return string
-    # https://bugs.launchpad.net/python-memcached/+bug/509712
-    def readline(self):
-        buf = self.buffer
-        recv = self.socket.recv
-        while True:
-            index = buf.find('\r\n')
-            if index >= 0:
-                break
-            data = recv(4096)
-            if not data:
-                self.mark_dead('Connection closed while reading from %s'
-                        % repr(self))
-                self.buffer = ''
-                # (patch)
-                # return None
-                return ''
-            buf += data
-        self.buffer = buf[index+2:]
-        return buf[:index]
-    _Host.readline = readline
 
-    # Client._get() should raises an Exception instead of returning
-    # None, in case of connection errors or missing values.
-    class MemcachedConnectionError(Exception):
-        pass
-    Client.MemcachedConnectionError = MemcachedConnectionError
+    try:
+        from memcache import _ConnectionDeadError
+    except ImportError:
+        # BBB
+        class _ConnectionDeadError(Exception):
+            pass
+    Client.MemcachedConnectionError = _ConnectionDeadError
 
     import socket
     def _get(self, cmd, key):
-        self.check_key(key)
+        if getattr(self, 'do_check_key', True):
+            self.check_key(key)
         server, key = self._get_server(key)
         if not server:
             # (patch)
             # return None
-            raise MemcachedConnectionError
-        self._statlog(cmd)
+            raise _ConnectionDeadError
 
-        try:
-            server.send_cmd("%s %s" % (cmd, key))
-            rkey = flags = rlen = cas_id = None
-            if cmd == 'gets':
-                rkey, flags, rlen, cas_id, = self._expect_cas_value(server)
-                if rkey:
-                    self.cas_ids[rkey] = cas_id
-            else:
-                rkey, flags, rlen, = self._expectvalue(server)
+        def _unsafe_get():
+            self._statlog(cmd)
 
-            if not rkey:
+            try:
+                server.send_cmd("%s %s" % (cmd, key))
+                rkey = flags = rlen = cas_id = None
+
+                if cmd == 'gets':
+                    try:
+                        rkey, flags, rlen, cas_id, = self._expect_cas_value(server,
+                                raise_exception=True)
+                    except TypeError:
+                        # BBB
+                        rkey, flags, rlen, cas_id, = self._expect_cas_value(server)
+                    if rkey and self.cache_cas:
+                        self.cas_ids[rkey] = cas_id
+                else:
+                    try:
+                        rkey, flags, rlen, = self._expectvalue(server,
+                                raise_exception=True)
+                    except TypeError:
+                        # BBB
+                        rkey, flags, rlen, = self._expectvalue(server)
+                if not rkey:
+                    # (patch)
+                    # return None
+                    raise KeyError
+                try:
+                    value = self._recv_value(server, flags, rlen)
+                finally:
+                    try:
+                        server.expect("END", raise_exception=True)
+                    except TypeError:
+                        # BBB
+                        server.expect("END")
+            except (_Error, socket.error), msg:
+                if isinstance(msg, tuple): msg = msg[1]
+                server.mark_dead(msg)
+                # (patch)
+                # return None
+                raise _ConnectionDeadError
+
+            return value
+
+        try:
+            return _unsafe_get()
+        except _ConnectionDeadError:
+            # retry once
+            try:
+                if server.connect():
+                    return _unsafe_get()
                 # (patch)
                 # return None
-                raise KeyError
-            value = self._recv_value(server, flags, rlen)
-            server.expect("END")
-        except (_Error, socket.error), msg:
-            if isinstance(msg, tuple): msg = msg[1]
-            server.mark_dead(msg)
+                raise _ConnectionDeadError
+            except (_ConnectionDeadError, socket.error), msg:
+                server.mark_dead(msg)
             # (patch)
             # return None
-            raise MemcachedConnectionError
-        return value
+            raise _ConnectionDeadError
 
     Client._get = _get