Skip to content

erp5
erp5
Commit 7e497097 authored by Kazuhiko Shiozaki's avatar Kazuhiko Shiozaki
Browse files
Options

we should no longer use python-memcached < 1.45. 

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@39554 20353a03-c40f-0410-a6d1-a30d3c3de9de
parent 7b23d5f7
Show whitespace changes
Inline Side-by-side
Showing with 3 additions and 147 deletions
product/ERP5Type/patches/memcache_client.py
View file @ 7e497097
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
#Code based on python-memcached-1.44 # Code based on python-memcached-1.45
import types
try:
import cPickle as pickle
except ImportError:
import pickle
try:
# Only exists in Python 2.4+
from threading import local
except ImportError:
# TODO: add the pure-python local implementation
class local(object):
pass
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
try: try:
import memcache import memcache
except ImportError: except ImportError:
memcache = None
if memcache is not None and memcache.__version__ < '1.45':
Client = memcache.Client
SERVER_MAX_KEY_LENGTH = memcache.SERVER_MAX_KEY_LENGTH
SERVER_MAX_VALUE_LENGTH = memcache.SERVER_MAX_VALUE_LENGTH
def Client__init__(self, servers, debug=0, pickleProtocol=0,
pickler=pickle.Pickler, unpickler=pickle.Unpickler,
pload=None, pid=None, server_max_key_length=SERVER_MAX_KEY_LENGTH,
server_max_value_length=SERVER_MAX_VALUE_LENGTH):
"""
Create a new Client object with the given list of servers.
@param servers: C{servers} is passed to L{set_servers}.
@param debug: whether to display error messages when a server can't be
contacted.
@param pickleProtocol: number to mandate protocol used by (c)Pickle.
@param pickler: optional override of default Pickler to allow subclassing.
@param unpickler: optional override of default Unpickler to allow subclassing.
@param pload: optional persistent_load function to call on pickle loading.
Useful for cPickle since subclassing isn't allowed.
@param pid: optional persistent_id function to call on pickle storing.
Useful for cPickle since subclassing isn't allowed.
"""
local.__init__(self)
self.set_servers(servers)
self.debug = debug
self.stats = {}
# Allow users to modify pickling/unpickling behavior
self.pickleProtocol = pickleProtocol
self.pickler = pickler
self.unpickler = unpickler
self.persistent_load = pload
self.persistent_id = pid
#Patch store these Constant on object itself
self.server_max_key_length = server_max_key_length
self.server_max_value_length = server_max_value_length
# figure out the pickler style
file = StringIO()
try:
pickler = self.pickler(file, protocol = self.pickleProtocol)
self.picklerIsKeyword = True
except TypeError:
self.picklerIsKeyword = False
def memcache_check_key(key, key_extra_len=0):
"""Checks sanity of key. Fails if:
Key length is > SERVER_MAX_KEY_LENGTH (Raises MemcachedKeyLength).
Contains control characters (Raises MemcachedKeyCharacterError).
Is not a string (Raises MemcachedStringEncodingError)
Is an unicode string (Raises MemcachedStringEncodingError)
Is not a string (Raises MemcachedKeyError)
Is None (Raises MemcachedKeyError)
"""
if type(key) == types.TupleType: key = key[1]
if not key:
raise Client.MemcachedKeyNoneError, ("Key is None")
if isinstance(key, unicode):
raise Client.MemcachedStringEncodingError, ("Keys must be str()'s, not "
"unicode. Convert your unicode strings using "
"mystring.encode(charset)!")
if not isinstance(key, str):
raise Client.MemcachedKeyTypeError, ("Key must be str()'s")
if isinstance(key, basestring):
for char in key:
#Patch: skip key length check because we have no information
#about key length in memcache class level.
if 0 and len(key) + key_extra_len > SERVER_MAX_KEY_LENGTH:
raise Client.MemcachedKeyLengthError, ("Key length is > %s"
% SERVER_MAX_KEY_LENGTH)
if ord(char) < 32 or ord(char) == 127:
raise Client.MemcachedKeyCharacterError, "Control characters not allowed"
def Client__val_to_store_info(self, val, min_compress_len):
"""
Transform val to a storable representation, returning a tuple of the flags, the length of the new value, and the new value itself.
"""
flags = 0
if isinstance(val, str):
pass pass
elif isinstance(val, int): else:
flags |= Client._FLAG_INTEGER
val = "%d" % val
# force no attempt to compress this silly string.
min_compress_len = 0
elif isinstance(val, long):
flags |= Client._FLAG_LONG
val = "%d" % val
# force no attempt to compress this silly string.
min_compress_len = 0
else:
flags |= Client._FLAG_PICKLE
file = StringIO()
if self.picklerIsKeyword:
pickler = self.pickler(file, protocol = self.pickleProtocol)
else:
pickler = self.pickler(file, self.pickleProtocol)
if self.persistent_id:
pickler.persistent_id = self.persistent_id
pickler.dump(val)
val = file.getvalue()
lv = len(val)
# We should try to compress if min_compress_len > 0 and we could
# import zlib and this string is longer than our min threshold.
if min_compress_len and _supports_compress and lv > min_compress_len:
comp_val = compress(val)
# Only retain the result if the compression result is smaller
# than the original.
if len(comp_val) < lv:
flags |= Client._FLAG_COMPRESSED
val = comp_val
#Patch: add support for infinite value length
if self.server_max_value_length == 0:
return (flags, len(val), val)
# silently do not store if value length exceeds maximum
if len(val) >= self.server_max_value_length: return(0)
return (flags, len(val), val)
Client.__init__ = Client__init__
Client._val_to_store_info = Client__val_to_store_info
memcache.check_key = memcache_check_key
del Client__init__, Client__val_to_store_info, memcache_check_key
if memcache is not None:
memcache._Host._SOCKET_TIMEOUT = 10 # wait more than 3s is safe memcache._Host._SOCKET_TIMEOUT = 10 # wait more than 3s is safe
# always return string # always return string
# https://bugs.launchpad.net/python-memcached/+bug/509712 # https://bugs.launchpad.net/python-memcached/+bug/509712
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7