Debian Codegraph @

django/contrib/sessions/backends/db.py

raw
1 import logging
2
3 from asgiref.sync import sync_to_async
4
5 from django.contrib.sessions.backends.base import CreateError, SessionBase, UpdateError
6 from django.core.exceptions import SuspiciousOperation
7 from django.db import DatabaseError, IntegrityError, router, transaction
8 from django.utils import timezone
9 from django.utils.functional import cached_property
10
11
12 class SessionStore(SessionBase):
13 """
14 Implement database session store.
15 """
16
17 def __init__(self, session_key=None):
18 super().__init__(session_key)
19
20 @classmethod
21 def get_model_class(cls):
22 # Avoids a circular import and allows importing SessionStore when
23 # django.contrib.sessions is not in INSTALLED_APPS.
24 from django.contrib.sessions.models import Session
25
26 return Session
27
28 @cached_property
29 def model(self):
30 return self.get_model_class()
31
32 def _get_session_from_db(self):
33 try:
34 return self.model.objects.get(
35 session_key=self.session_key, expire_date__gt=timezone.now()
36 )
37 except (self.model.DoesNotExist, SuspiciousOperation) as e:
38 if isinstance(e, SuspiciousOperation):
39 logger = logging.getLogger("django.security.%s" % e.__class__.__name__)
40 logger.warning(str(e))
41 self._session_key = None
42
43 async def _aget_session_from_db(self):
44 try:
45 return await self.model.objects.aget(
46 session_key=self.session_key, expire_date__gt=timezone.now()
47 )
48 except (self.model.DoesNotExist, SuspiciousOperation) as e:
49 if isinstance(e, SuspiciousOperation):
50 logger = logging.getLogger("django.security.%s" % e.__class__.__name__)
51 logger.warning(str(e))
52 self._session_key = None
53
54 def load(self):
55 s = self._get_session_from_db()
56 return self.decode(s.session_data) if s else {}
57
58 async def aload(self):
59 s = await self._aget_session_from_db()
60 return self.decode(s.session_data) if s else {}
61
62 def exists(self, session_key):
63 return self.model.objects.filter(session_key=session_key).exists()
64
65 async def aexists(self, session_key):
66 return await self.model.objects.filter(session_key=session_key).aexists()
67
68 def create(self):
69 while True:
70 self._session_key = self._get_new_session_key()
71 try:
72 # Save immediately to ensure we have a unique entry in the
73 # database.
74 self.save(must_create=True)
75 except CreateError:
76 # Key wasn't unique. Try again.
77 continue
78 self.modified = True
79 return
80
81 async def acreate(self):
82 while True:
83 self._session_key = await self._aget_new_session_key()
84 try:
85 # Save immediately to ensure we have a unique entry in the
86 # database.
87 await self.asave(must_create=True)
88 except CreateError:
89 # Key wasn't unique. Try again.
90 continue
91 self.modified = True
92 return
93
94 def create_model_instance(self, data):
95 """
96 Return a new instance of the session model object, which represents the
97 current session state. Intended to be used for saving the session data
98 to the database.
99 """
100 return self.model(
101 session_key=self._get_or_create_session_key(),
102 session_data=self.encode(data),
103 expire_date=self.get_expiry_date(),
104 )
105
106 async def acreate_model_instance(self, data):
107 """See create_model_instance()."""
108 return self.model(
109 session_key=await self._aget_or_create_session_key(),
110 session_data=self.encode(data),
111 expire_date=await self.aget_expiry_date(),
112 )
113
114 def save(self, must_create=False):
115 """
116 Save the current session data to the database. If 'must_create' is
117 True, raise a database error if the saving operation doesn't create a
118 new entry (as opposed to possibly updating an existing entry).
119 """
120 if self.session_key is None:
121 return self.create()
122 data = self._get_session(no_load=must_create)
123 obj = self.create_model_instance(data)
124 using = router.db_for_write(self.model, instance=obj)
125 try:
126 with transaction.atomic(using=using):
127 obj.save(
128 force_insert=must_create, force_update=not must_create, using=using
129 )
130 except IntegrityError:
131 if must_create:
132 raise CreateError
133 raise
134 except DatabaseError:
135 if not must_create:
136 raise UpdateError
137 raise
138
139 async def asave(self, must_create=False):
140 """See save()."""
141 if self.session_key is None:
142 return await self.acreate()
143 data = await self._aget_session(no_load=must_create)
144 obj = await self.acreate_model_instance(data)
145 using = router.db_for_write(self.model, instance=obj)
146 try:
147 # This code MOST run in a transaction, so it requires
148 # @sync_to_async wrapping until transaction.atomic() supports
149 # async.
150 @sync_to_async
151 def sync_transaction():
152 with transaction.atomic(using=using):
153 obj.save(
154 force_insert=must_create,
155 force_update=not must_create,
156 using=using,
157 )
158
159 await sync_transaction()
160 except IntegrityError:
161 if must_create:
162 raise CreateError
163 raise
164 except DatabaseError:
165 if not must_create:
166 raise UpdateError
167 raise
168
169 def delete(self, session_key=None):
170 if session_key is None:
171 if self.session_key is None:
172 return
173 session_key = self.session_key
174 try:
175 self.model.objects.get(session_key=session_key).delete()
176 except self.model.DoesNotExist:
177 pass
178
179 async def adelete(self, session_key=None):
180 if session_key is None:
181 if self.session_key is None:
182 return
183 session_key = self.session_key
184 try:
185 obj = await self.model.objects.aget(session_key=session_key)
186 await obj.adelete()
187 except self.model.DoesNotExist:
188 pass
189
190 @classmethod
191 def clear_expired(cls):
192 cls.get_model_class().objects.filter(expire_date__lt=timezone.now()).delete()
193
194 @classmethod
195 async def aclear_expired(cls):
196 await cls.get_model_class().objects.filter(
197 expire_date__lt=timezone.now()
198 ).adelete()