Debian Codegraph @

django/core/cache/backends/locmem.py

raw
1 "Thread-safe in-memory cache backend."
2
3 import pickle
4 import time
5 from collections import OrderedDict
6 from threading import Lock
7
8 from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache
9
10 # Global in-memory store of cache data. Keyed by name, to provide
11 # multiple named local memory caches.
12 _caches = {}
13 _expire_info = {}
14 _locks = {}
15
16
17 class LocMemCache(BaseCache):
18 pickle_protocol = pickle.HIGHEST_PROTOCOL
19
20 def __init__(self, name, params):
21 super().__init__(params)
22 self._cache = _caches.setdefault(name, OrderedDict())
23 self._expire_info = _expire_info.setdefault(name, {})
24 self._lock = _locks.setdefault(name, Lock())
25
26 def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
27 key = self.make_and_validate_key(key, version=version)
28 pickled = pickle.dumps(value, self.pickle_protocol)
29 with self._lock:
30 if self._has_expired(key):
31 self._set(key, pickled, timeout)
32 return True
33 return False
34
35 def get(self, key, default=None, version=None):
36 key = self.make_and_validate_key(key, version=version)
37 with self._lock:
38 if self._has_expired(key):
39 self._delete(key)
40 return default
41 pickled = self._cache[key]
42 self._cache.move_to_end(key, last=False)
43 return pickle.loads(pickled)
44
45 def _set(self, key, value, timeout=DEFAULT_TIMEOUT):
46 if len(self._cache) >= self._max_entries:
47 self._cull()
48 self._cache[key] = value
49 self._cache.move_to_end(key, last=False)
50 self._expire_info[key] = self.get_backend_timeout(timeout)
51
52 def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
53 key = self.make_and_validate_key(key, version=version)
54 pickled = pickle.dumps(value, self.pickle_protocol)
55 with self._lock:
56 self._set(key, pickled, timeout)
57
58 def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None):
59 key = self.make_and_validate_key(key, version=version)
60 with self._lock:
61 if self._has_expired(key):
62 return False
63 self._expire_info[key] = self.get_backend_timeout(timeout)
64 return True
65
66 def incr(self, key, delta=1, version=None):
67 key = self.make_and_validate_key(key, version=version)
68 with self._lock:
69 if self._has_expired(key):
70 self._delete(key)
71 raise ValueError("Key '%s' not found" % key)
72 pickled = self._cache[key]
73 value = pickle.loads(pickled)
74 new_value = value + delta
75 pickled = pickle.dumps(new_value, self.pickle_protocol)
76 self._cache[key] = pickled
77 self._cache.move_to_end(key, last=False)
78 return new_value
79
80 def has_key(self, key, version=None):
81 key = self.make_and_validate_key(key, version=version)
82 with self._lock:
83 if self._has_expired(key):
84 self._delete(key)
85 return False
86 return True
87
88 def _has_expired(self, key):
89 exp = self._expire_info.get(key, -1)
90 return exp is not None and exp <= time.time()
91
92 def _cull(self):
93 if self._cull_frequency == 0:
94 self._cache.clear()
95 self._expire_info.clear()
96 else:
97 count = len(self._cache) // self._cull_frequency
98 for i in range(count):
99 key, _ = self._cache.popitem()
100 del self._expire_info[key]
101
102 def _delete(self, key):
103 try:
104 del self._cache[key]
105 del self._expire_info[key]
106 except KeyError:
107 return False
108 return True
109
110 def delete(self, key, version=None):
111 key = self.make_and_validate_key(key, version=version)
112 with self._lock:
113 return self._delete(key)
114
115 def clear(self):
116 with self._lock:
117 self._cache.clear()
118 self._expire_info.clear()