Debian Codegraph @

django/core/cache/backends/memcached.py

raw
1 "Memcached cache backend"
2
3 import re
4 import time
5
6 from django.core.cache.backends.base import (
7 DEFAULT_TIMEOUT,
8 BaseCache,
9 InvalidCacheKey,
10 memcache_key_warnings,
11 )
12 from django.utils.functional import cached_property
13
14
15 class BaseMemcachedCache(BaseCache):
16 def __init__(self, server, params, library, value_not_found_exception):
17 super().__init__(params)
18 if isinstance(server, str):
19 self._servers = re.split("[;,]", server)
20 else:
21 self._servers = server
22
23 # Exception type raised by the underlying client library for a
24 # nonexistent key.
25 self.LibraryValueNotFoundException = value_not_found_exception
26
27 self._lib = library
28 self._class = library.Client
29 self._options = params.get("OPTIONS") or {}
30
31 @property
32 def client_servers(self):
33 return self._servers
34
35 @cached_property
36 def _cache(self):
37 """
38 Implement transparent thread-safe access to a memcached client.
39 """
40 return self._class(self.client_servers, **self._options)
41
42 def get_backend_timeout(self, timeout=DEFAULT_TIMEOUT):
43 """
44 Memcached deals with long (> 30 days) timeouts in a special
45 way. Call this function to obtain a safe value for your timeout.
46 """
47 if timeout == DEFAULT_TIMEOUT:
48 timeout = self.default_timeout
49
50 if timeout is None:
51 # Using 0 in memcache sets a non-expiring timeout.
52 return 0
53 elif int(timeout) == 0:
54 # Other cache backends treat 0 as set-and-expire. To achieve this
55 # in memcache backends, a negative timeout must be passed.
56 timeout = -1
57
58 if timeout > 2592000: # 60*60*24*30, 30 days
59 # See https://github.com/memcached/memcached/wiki/Programming#expiration
60 # "Expiration times can be set from 0, meaning "never expire", to
61 # 30 days. Any time higher than 30 days is interpreted as a Unix
62 # timestamp date. If you want to expire an object on January 1st of
63 # next year, this is how you do that."
64 #
65 # This means that we have to switch to absolute timestamps.
66 timeout += int(time.time())
67 return int(timeout)
68
69 def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
70 key = self.make_and_validate_key(key, version=version)
71 return self._cache.add(key, value, self.get_backend_timeout(timeout))
72
73 def get(self, key, default=None, version=None):
74 key = self.make_and_validate_key(key, version=version)
75 return self._cache.get(key, default)
76
77 def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
78 key = self.make_and_validate_key(key, version=version)
79 if not self._cache.set(key, value, self.get_backend_timeout(timeout)):
80 # Make sure the key doesn't keep its old value in case of failure
81 # to set (memcached's 1MB limit).
82 self._cache.delete(key)
83
84 def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None):
85 key = self.make_and_validate_key(key, version=version)
86 return bool(self._cache.touch(key, self.get_backend_timeout(timeout)))
87
88 def delete(self, key, version=None):
89 key = self.make_and_validate_key(key, version=version)
90 return bool(self._cache.delete(key))
91
92 def get_many(self, keys, version=None):
93 key_map = {
94 self.make_and_validate_key(key, version=version): key for key in keys
95 }
96 ret = self._cache.get_multi(key_map.keys())
97 return {key_map[k]: v for k, v in ret.items()}
98
99 def close(self, **kwargs):
100 # Many clients don't clean up connections properly.
101 self._cache.disconnect_all()
102
103 def incr(self, key, delta=1, version=None):
104 key = self.make_and_validate_key(key, version=version)
105 try:
106 # Memcached doesn't support negative delta.
107 if delta < 0:
108 val = self._cache.decr(key, -delta)
109 else:
110 val = self._cache.incr(key, delta)
111 # Normalize an exception raised by the underlying client library to
112 # ValueError in the event of a nonexistent key when calling
113 # incr()/decr().
114 except self.LibraryValueNotFoundException:
115 val = None
116 if val is None:
117 raise ValueError("Key '%s' not found" % key)
118 return val
119
120 def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None):
121 safe_data = {}
122 original_keys = {}
123 for key, value in data.items():
124 safe_key = self.make_and_validate_key(key, version=version)
125 safe_data[safe_key] = value
126 original_keys[safe_key] = key
127 failed_keys = self._cache.set_multi(
128 safe_data, self.get_backend_timeout(timeout)
129 )
130 return [original_keys[k] for k in failed_keys]
131
132 def delete_many(self, keys, version=None):
133 keys = [self.make_and_validate_key(key, version=version) for key in keys]
134 self._cache.delete_multi(keys)
135
136 def clear(self):
137 self._cache.flush_all()
138
139 def validate_key(self, key):
140 for warning in memcache_key_warnings(key):
141 raise InvalidCacheKey(warning)
142
143
144 class PyLibMCCache(BaseMemcachedCache):
145 "An implementation of a cache binding using pylibmc"
146
147 def __init__(self, server, params):
148 import pylibmc
149
150 super().__init__(
151 server, params, library=pylibmc, value_not_found_exception=pylibmc.NotFound
152 )
153
154 @property
155 def client_servers(self):
156 output = []
157 for server in self._servers:
158 output.append(server.removeprefix("unix:"))
159 return output
160
161 def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None):
162 key = self.make_and_validate_key(key, version=version)
163 if timeout == 0:
164 return self._cache.delete(key)
165 return self._cache.touch(key, self.get_backend_timeout(timeout))
166
167 def close(self, **kwargs):
168 # libmemcached manages its own connections. Don't call disconnect_all()
169 # as it resets the failover state and creates unnecessary reconnects.
170 pass
171
172
173 class PyMemcacheCache(BaseMemcachedCache):
174 """An implementation of a cache binding using pymemcache."""
175
176 def __init__(self, server, params):
177 import pymemcache.serde
178
179 super().__init__(
180 server, params, library=pymemcache, value_not_found_exception=KeyError
181 )
182 self._class = self._lib.HashClient
183 self._options = {
184 "allow_unicode_keys": True,
185 "default_noreply": False,
186 "serde": pymemcache.serde.pickle_serde,
187 **self._options,
188 }