mirror of
https://github.com/zulip/zulip.git
synced 2025-11-05 22:43:42 +00:00
9b8f0fab0f
On my laptop, this saves about 80 milliseconds per 1000 messages requested via get_old_messages queries. Since we only have one memcached process and it does not run with special priority, this might have significant impact on load during server restarts. (imported from commit 06ad13f32f4a6d87a0664c96297ef9843f410ac5)
120 lines
3.9 KiB
Python
120 lines
3.9 KiB
Python
from __future__ import absolute_import
|
|
|
|
from functools import wraps
|
|
|
|
from django.core.cache import cache as djcache
|
|
from django.core.cache import get_cache
|
|
|
|
from zephyr.lib.utils import statsd, statsd_key, make_safe_digest
|
|
import time
|
|
|
|
memcached_total_time = 0
|
|
memcached_total_requests = 0
|
|
|
|
def get_memcached_time():
|
|
return memcached_total_time
|
|
|
|
def get_memcached_requests():
|
|
return memcached_total_requests
|
|
|
|
|
|
def cache_with_key(keyfunc, cache_name=None, timeout=None):
|
|
"""Decorator which applies Django caching to a function.
|
|
|
|
Decorator argument is a function which computes a cache key
|
|
from the original function's arguments. You are responsible
|
|
for avoiding collisions with other uses of this decorator or
|
|
other uses of caching."""
|
|
|
|
def decorator(func):
|
|
@wraps(func)
|
|
def func_with_caching(*args, **kwargs):
|
|
global memcached_total_time
|
|
global memcached_total_requests
|
|
memcached_start = time.time()
|
|
if cache_name is None:
|
|
cache_backend = djcache
|
|
else:
|
|
cache_backend = get_cache(cache_name)
|
|
|
|
key = keyfunc(*args, **kwargs)
|
|
|
|
val = cache_backend.get(key)
|
|
memcached_total_requests += 1
|
|
memcached_total_time += (time.time() - memcached_start)
|
|
|
|
if val is not None:
|
|
statsd.incr("cache.%s.hit" % (statsd_key(key),))
|
|
else:
|
|
statsd.incr("cache.%s.miss" % (statsd_key(key),))
|
|
|
|
# Values are singleton tuples so that we can distinguish
|
|
# a result of None from a missing key.
|
|
if val is not None:
|
|
return val[0]
|
|
|
|
val = func(*args, **kwargs)
|
|
|
|
memcached_start = time.time()
|
|
|
|
cache_backend.set(key, (val,), timeout=timeout)
|
|
memcached_total_requests += 1
|
|
memcached_total_time += (time.time() - memcached_start)
|
|
|
|
return val
|
|
|
|
return func_with_caching
|
|
|
|
return decorator
|
|
|
|
def cache_get_many(keys, cache_name=None):
|
|
if cache_name is None:
|
|
cache_backend = djcache
|
|
else:
|
|
cache_backend = get_cache(cache_name)
|
|
return cache_backend.get_many(keys)
|
|
|
|
def cache(func):
|
|
"""Decorator which applies Django caching to a function.
|
|
|
|
Uses a key based on the function's name, filename, and
|
|
the repr() of its arguments."""
|
|
|
|
func_uniqifier = '%s-%s' % (func.func_code.co_filename, func.func_name)
|
|
|
|
@wraps(func)
|
|
def keyfunc(*args, **kwargs):
|
|
# Django complains about spaces because memcached rejects them
|
|
key = func_uniqifier + repr((args, kwargs))
|
|
return key.replace('-','--').replace(' ','-s')
|
|
|
|
return cache_with_key(keyfunc)(func)
|
|
|
|
def message_cache_key(message_id):
|
|
return "message:%d" % (message_id,)
|
|
|
|
def user_profile_by_email_cache_key(email):
|
|
# See the comment in zephyr/lib/avatar.py:gravatar_hash for why we
|
|
# are proactively encoding email addresses even though they will
|
|
# with high likelihood be ASCII-only for the foreseeable future.
|
|
return 'user_profile_by_email:%s' % (make_safe_digest(email),)
|
|
|
|
def user_profile_by_id_cache_key(user_profile_id):
|
|
return "user_profile_by_id:%s" % (user_profile_id,)
|
|
|
|
# Called by models.py to flush the user_profile cache whenever we save
|
|
# a user_profile object
|
|
def update_user_profile_cache(sender, **kwargs):
|
|
user_profile = kwargs['instance']
|
|
items_for_memcached = {}
|
|
items_for_memcached[user_profile_by_email_cache_key(user_profile.email)] = (user_profile,)
|
|
items_for_memcached[user_profile_by_id_cache_key(user_profile.id)] = (user_profile,)
|
|
djcache.set_many(items_for_memcached)
|
|
|
|
def status_dict_cache_key(user_profile):
|
|
return "status_dict:%d" % (user_profile.realm_id,)
|
|
|
|
def update_user_presence_cache(sender, **kwargs):
|
|
user_profile = kwargs['instance'].user_profile
|
|
djcache.delete(status_dict_cache_key(user_profile))
|