| 1 |
from django.conf import settings |
| 2 |
from django.contrib.sessions.backends.base import CreateError, SessionBase, UpdateError |
| 3 |
from django.core.cache import caches |
| 4 |
|
| 5 |
KEY_PREFIX = "django.contrib.sessions.cache" |
| 6 |
|
| 7 |
|
| 8 |
class SessionStore(SessionBase): |
| 9 |
""" |
| 10 |
A cache-based session store. |
| 11 |
""" |
| 12 |
|
| 13 |
cache_key_prefix = KEY_PREFIX |
| 14 |
|
| 15 |
def __init__(self, session_key=None): |
| 16 |
self._cache = caches[settings.SESSION_CACHE_ALIAS] |
| 17 |
super().__init__(session_key) |
| 18 |
|
| 19 |
@property |
| 20 |
def cache_key(self): |
| 21 |
return self.cache_key_prefix + self._get_or_create_session_key() |
| 22 |
|
| 23 |
async def acache_key(self): |
| 24 |
return self.cache_key_prefix + await self._aget_or_create_session_key() |
| 25 |
|
| 26 |
def load(self): |
| 27 |
try: |
| 28 |
session_data = self._cache.get(self.cache_key) |
| 29 |
except Exception: |
| 30 |
# Some backends (e.g. memcache) raise an exception on invalid |
| 31 |
# cache keys. If this happens, reset the session. See #17810. |
| 32 |
session_data = None |
| 33 |
if session_data is not None: |
| 34 |
return session_data |
| 35 |
self._session_key = None |
| 36 |
return {} |
| 37 |
|
| 38 |
async def aload(self): |
| 39 |
try: |
| 40 |
session_data = await self._cache.aget(await self.acache_key()) |
| 41 |
except Exception: |
| 42 |
session_data = None |
| 43 |
if session_data is not None: |
| 44 |
return session_data |
| 45 |
self._session_key = None |
| 46 |
return {} |
| 47 |
|
| 48 |
def create(self): |
| 49 |
# Because a cache can fail silently (e.g. memcache), we don't know if |
| 50 |
# we are failing to create a new session because of a key collision or |
| 51 |
# because the cache is missing. So we try for a (large) number of times |
| 52 |
# and then raise an exception. That's the risk you shoulder if using |
| 53 |
# cache backing. |
| 54 |
for i in range(10000): |
| 55 |
self._session_key = self._get_new_session_key() |
| 56 |
try: |
| 57 |
self.save(must_create=True) |
| 58 |
except CreateError: |
| 59 |
continue |
| 60 |
self.modified = True |
| 61 |
return |
| 62 |
raise RuntimeError( |
| 63 |
"Unable to create a new session key. " |
| 64 |
"It is likely that the cache is unavailable." |
| 65 |
) |
| 66 |
|
| 67 |
async def acreate(self): |
| 68 |
for i in range(10000): |
| 69 |
self._session_key = await self._aget_new_session_key() |
| 70 |
try: |
| 71 |
await self.asave(must_create=True) |
| 72 |
except CreateError: |
| 73 |
continue |
| 74 |
self.modified = True |
| 75 |
return |
| 76 |
raise RuntimeError( |
| 77 |
"Unable to create a new session key. " |
| 78 |
"It is likely that the cache is unavailable." |
| 79 |
) |
| 80 |
|
| 81 |
def save(self, must_create=False): |
| 82 |
if self.session_key is None: |
| 83 |
return self.create() |
| 84 |
if must_create: |
| 85 |
func = self._cache.add |
| 86 |
elif self._cache.get(self.cache_key) is not None: |
| 87 |
func = self._cache.set |
| 88 |
else: |
| 89 |
raise UpdateError |
| 90 |
result = func( |
| 91 |
self.cache_key, |
| 92 |
self._get_session(no_load=must_create), |
| 93 |
self.get_expiry_age(), |
| 94 |
) |
| 95 |
if must_create and not result: |
| 96 |
raise CreateError |
| 97 |
|
| 98 |
async def asave(self, must_create=False): |
| 99 |
if self.session_key is None: |
| 100 |
return await self.acreate() |
| 101 |
if must_create: |
| 102 |
func = self._cache.aadd |
| 103 |
elif await self._cache.aget(await self.acache_key()) is not None: |
| 104 |
func = self._cache.aset |
| 105 |
else: |
| 106 |
raise UpdateError |
| 107 |
result = await func( |
| 108 |
await self.acache_key(), |
| 109 |
await self._aget_session(no_load=must_create), |
| 110 |
await self.aget_expiry_age(), |
| 111 |
) |
| 112 |
if must_create and not result: |
| 113 |
raise CreateError |
| 114 |
|
| 115 |
def exists(self, session_key): |
| 116 |
return ( |
| 117 |
bool(session_key) and (self.cache_key_prefix + session_key) in self._cache |
| 118 |
) |
| 119 |
|
| 120 |
async def aexists(self, session_key): |
| 121 |
return bool(session_key) and await self._cache.ahas_key( |
| 122 |
self.cache_key_prefix + session_key |
| 123 |
) |
| 124 |
|
| 125 |
def delete(self, session_key=None): |
| 126 |
if session_key is None: |
| 127 |
if self.session_key is None: |
| 128 |
return |
| 129 |
session_key = self.session_key |
| 130 |
self._cache.delete(self.cache_key_prefix + session_key) |
| 131 |
|
| 132 |
async def adelete(self, session_key=None): |
| 133 |
if session_key is None: |
| 134 |
if self.session_key is None: |
| 135 |
return |
| 136 |
session_key = self.session_key |
| 137 |
await self._cache.adelete(self.cache_key_prefix + session_key) |
| 138 |
|
| 139 |
@classmethod |
| 140 |
def clear_expired(cls): |
| 141 |
pass |
| 142 |
|
| 143 |
@classmethod |
| 144 |
async def aclear_expired(cls): |
| 145 |
pass |