Debian Codegraph @

django/core/cache/backends/redis.py

raw
1 """Redis cache backend."""
2
3 import pickle
4 import random
5 import re
6
7 from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache
8 from django.utils.functional import cached_property
9 from django.utils.module_loading import import_string
10
11
12 class RedisSerializer:
13 def __init__(self, protocol=None):
14 self.protocol = pickle.HIGHEST_PROTOCOL if protocol is None else protocol
15
16 def dumps(self, obj):
17 # For better incr() and decr() atomicity, don't pickle integers.
18 # Using type() rather than isinstance() matches only integers and not
19 # subclasses like bool.
20 if type(obj) is int:
21 return obj
22 return pickle.dumps(obj, self.protocol)
23
24 def loads(self, data):
25 try:
26 return int(data)
27 except ValueError:
28 return pickle.loads(data)
29
30
31 class RedisCacheClient:
32 def __init__(
33 self,
34 servers,
35 serializer=None,
36 pool_class=None,
37 parser_class=None,
38 **options,
39 ):
40 import redis
41
42 self._lib = redis
43 self._servers = servers
44 self._pools = {}
45
46 self._client = self._lib.Redis
47
48 if isinstance(pool_class, str):
49 pool_class = import_string(pool_class)
50 self._pool_class = pool_class or self._lib.ConnectionPool
51
52 if isinstance(serializer, str):
53 serializer = import_string(serializer)
54 if callable(serializer):
55 serializer = serializer()
56 self._serializer = serializer or RedisSerializer()
57
58 if isinstance(parser_class, str):
59 parser_class = import_string(parser_class)
60 parser_class = parser_class or self._lib.connection.DefaultParser
61
62 self._pool_options = {"parser_class": parser_class, **options}
63
64 def _get_connection_pool_index(self, write):
65 # Write to the first server. Read from other servers if there are more,
66 # otherwise read from the first server.
67 if write or len(self._servers) == 1:
68 return 0
69 return random.randint(1, len(self._servers) - 1)
70
71 def _get_connection_pool(self, write):
72 index = self._get_connection_pool_index(write)
73 if index not in self._pools:
74 self._pools[index] = self._pool_class.from_url(
75 self._servers[index],
76 **self._pool_options,
77 )
78 return self._pools[index]
79
80 def get_client(self, key=None, *, write=False):
81 # key is used so that the method signature remains the same and custom
82 # cache client can be implemented which might require the key to select
83 # the server, e.g. sharding.
84 pool = self._get_connection_pool(write)
85 return self._client(connection_pool=pool)
86
87 def add(self, key, value, timeout):
88 client = self.get_client(key, write=True)
89 value = self._serializer.dumps(value)
90
91 if timeout == 0:
92 if ret := bool(client.set(key, value, nx=True)):
93 client.delete(key)
94 return ret
95 else:
96 return bool(client.set(key, value, ex=timeout, nx=True))
97
98 def get(self, key, default):
99 client = self.get_client(key)
100 value = client.get(key)
101 return default if value is None else self._serializer.loads(value)
102
103 def set(self, key, value, timeout):
104 client = self.get_client(key, write=True)
105 value = self._serializer.dumps(value)
106 if timeout == 0:
107 client.delete(key)
108 else:
109 client.set(key, value, ex=timeout)
110
111 def touch(self, key, timeout):
112 client = self.get_client(key, write=True)
113 if timeout is None:
114 return bool(client.persist(key))
115 else:
116 return bool(client.expire(key, timeout))
117
118 def delete(self, key):
119 client = self.get_client(key, write=True)
120 return bool(client.delete(key))
121
122 def get_many(self, keys):
123 client = self.get_client(None)
124 ret = client.mget(keys)
125 return {
126 k: self._serializer.loads(v) for k, v in zip(keys, ret) if v is not None
127 }
128
129 def has_key(self, key):
130 client = self.get_client(key)
131 return bool(client.exists(key))
132
133 def incr(self, key, delta):
134 client = self.get_client(key, write=True)
135 if not client.exists(key):
136 raise ValueError("Key '%s' not found." % key)
137 return client.incr(key, delta)
138
139 def set_many(self, data, timeout):
140 client = self.get_client(None, write=True)
141 pipeline = client.pipeline()
142 pipeline.mset({k: self._serializer.dumps(v) for k, v in data.items()})
143
144 if timeout is not None:
145 # Setting timeout for each key as redis does not support timeout
146 # with mset().
147 for key in data:
148 pipeline.expire(key, timeout)
149 pipeline.execute()
150
151 def delete_many(self, keys):
152 client = self.get_client(None, write=True)
153 client.delete(*keys)
154
155 def clear(self):
156 client = self.get_client(None, write=True)
157 return bool(client.flushdb())
158
159
160 class RedisCache(BaseCache):
161 def __init__(self, server, params):
162 super().__init__(params)
163 if isinstance(server, str):
164 self._servers = re.split("[;,]", server)
165 else:
166 self._servers = server
167
168 self._class = RedisCacheClient
169 self._options = params.get("OPTIONS", {})
170
171 @cached_property
172 def _cache(self):
173 return self._class(self._servers, **self._options)
174
175 def get_backend_timeout(self, timeout=DEFAULT_TIMEOUT):
176 if timeout == DEFAULT_TIMEOUT:
177 timeout = self.default_timeout
178 # The key will be made persistent if None used as a timeout.
179 # Non-positive values will cause the key to be deleted.
180 return None if timeout is None else max(0, int(timeout))
181
182 def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
183 key = self.make_and_validate_key(key, version=version)
184 return self._cache.add(key, value, self.get_backend_timeout(timeout))
185
186 def get(self, key, default=None, version=None):
187 key = self.make_and_validate_key(key, version=version)
188 return self._cache.get(key, default)
189
190 def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
191 key = self.make_and_validate_key(key, version=version)
192 self._cache.set(key, value, self.get_backend_timeout(timeout))
193
194 def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None):
195 key = self.make_and_validate_key(key, version=version)
196 return self._cache.touch(key, self.get_backend_timeout(timeout))
197
198 def delete(self, key, version=None):
199 key = self.make_and_validate_key(key, version=version)
200 return self._cache.delete(key)
201
202 def get_many(self, keys, version=None):
203 key_map = {
204 self.make_and_validate_key(key, version=version): key for key in keys
205 }
206 ret = self._cache.get_many(key_map.keys())
207 return {key_map[k]: v for k, v in ret.items()}
208
209 def has_key(self, key, version=None):
210 key = self.make_and_validate_key(key, version=version)
211 return self._cache.has_key(key)
212
213 def incr(self, key, delta=1, version=None):
214 key = self.make_and_validate_key(key, version=version)
215 return self._cache.incr(key, delta)
216
217 def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None):
218 if not data:
219 return []
220 safe_data = {}
221 for key, value in data.items():
222 key = self.make_and_validate_key(key, version=version)
223 safe_data[key] = value
224 self._cache.set_many(safe_data, self.get_backend_timeout(timeout))
225 return []
226
227 def delete_many(self, keys, version=None):
228 if not keys:
229 return
230 safe_keys = [self.make_and_validate_key(key, version=version) for key in keys]
231 self._cache.delete_many(safe_keys)
232
233 def clear(self):
234 return self._cache.clear()