class Memcache(object):
def __init__(self):
self.shard = RedisShardAPI(CACHE)
@staticmethod
def cache_key(func, *args):
return u":".join([func.__name__] + map(unicode, args))
def cache(self):
def wraped(func):
@functools.wraps(func)
def fcall(obj, *args):
key = self.cache_key(func, *args)
rst = self.shard.get(key)
logging.warning(key)
if not rst:
data = func(obj, *args)
self.shard.set(key, json.dumps(data))
self.shard.expire(key, 3600)
return data
return rst
return fcall
return wraped
def invalidate(self, func, *args):
key = self.cache_key(func, *args)
self.shard.delete(key)
def decorator(*args, **kwargs):
servers = current_app.config.get("REDIS_SHARD_URL")
client = RedisShardAPI(servers, hash_method='md5')
now = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
ip = request.remote_addr
key = "%s{%s}" % (ip, now)
client.incr(key)
if client.get(key):
num = int(client.get(key))
else:
num = 0
client.expire(key, 10)
if num > times:
return jsonify(dict(
code=40003,
msg='warning: Refused to too many requests !'))
return f(*args, **kwargs)
def decorator(*args, **kwargs):
servers = current_app.config.get("REDIS_SHARD_URL")
client = RedisShardAPI(servers, hash_method='md5')
now = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
ip = request.remote_addr
key = "%s{%s}" % (ip, now)
client.incr(key)
if client.get(key):
num = int(client.get(key))
else:
num = 0
client.expire(key, 10)
if num > times:
return jsonify(
dict(code=40003,
msg='warning: Refused to too many requests !'))
return f(*args, **kwargs)
class SessionStore(SessionBase):
"""
Implements Redis database session store.
"""
def __init__(self, session_key=None):
super(SessionStore, self).__init__(session_key)
try:
unix_socket_path=getattr(settings, 'SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH', None)
except AttributeError:
unix_socket_path = None
if unix_socket_path is None:
self.server = RedisShardAPI(settings.SESSION_REDIS_HOSTS)
else:
self.server = redis.StrictRedis(
unix_socket_path=getattr(settings, 'SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH', '/var/run/redis/redis.sock'),
db=getattr(settings, 'SESSION_REDIS_DB', 0),
password=getattr(settings, 'SESSION_REDIS_PASSWORD', None),
)
def load(self):
try:
session_data = self.server.get(self.get_real_stored_key(self._get_or_create_session_key()))
return self.decode(force_unicode(session_data))
except:
self.create()
return {}
def exists(self, session_key):
return self.server.exists(self.get_real_stored_key(session_key))
def create(self):
while True:
self._session_key = self._get_new_session_key()
try:
self.save(must_create=True)
except CreateError:
continue
self.modified = True
return
def save(self, must_create=False):
if not getattr(settings, 'SITE_READ_ONLY', False):
if must_create and self.exists(self._get_or_create_session_key()):
raise CreateError
this_session = self._get_session(no_load=must_create)
data = self.encode(self._get_session(no_load=must_create))
if redis.VERSION[0] >= 2:
self.server.setex(self.get_real_stored_key(self._get_or_create_session_key()), self.get_expiry_age(), data)
else:
self.server.set(self.get_real_stored_key(self._get_or_create_session_key()), data)
self.server.expire(self.get_real_stored_key(self._get_or_create_session_key()), self.get_expiry_age())
def delete(self, session_key=None):
if session_key is None:
if self.session_key is None:
return
session_key = self.session_key
try:
self.server.delete(self.get_real_stored_key(session_key))
except:
pass
def get_real_stored_key(self, session_key):
"""Return the real key name in redis storage
@return string
"""
prefix = getattr(settings, 'SESSION_REDIS_PREFIX', '')
if not prefix:
return session_key
return ':'.join([prefix, session_key])
