Debian Codegraph @

django/core/handlers/base.py

raw
1 import asyncio
2 import logging
3 import types
4
5 from asgiref.sync import async_to_sync, iscoroutinefunction, sync_to_async
6
7 from django.conf import settings
8 from django.core.exceptions import ImproperlyConfigured, MiddlewareNotUsed
9 from django.core.signals import request_finished
10 from django.db import connections, transaction
11 from django.urls import get_resolver, set_urlconf
12 from django.utils.log import log_response
13 from django.utils.module_loading import import_string
14
15 from .exception import convert_exception_to_response
16
17 logger = logging.getLogger("django.request")
18
19
20 class BaseHandler:
21 _view_middleware = None
22 _template_response_middleware = None
23 _exception_middleware = None
24 _middleware_chain = None
25
26 def load_middleware(self, is_async=False):
27 """
28 Populate middleware lists from settings.MIDDLEWARE.
29
30 Must be called after the environment is fixed (see __call__ in subclasses).
31 """
32 self._view_middleware = []
33 self._template_response_middleware = []
34 self._exception_middleware = []
35
36 get_response = self._get_response_async if is_async else self._get_response
37 handler = convert_exception_to_response(get_response)
38 handler_is_async = is_async
39 for middleware_path in reversed(settings.MIDDLEWARE):
40 middleware = import_string(middleware_path)
41 middleware_can_sync = getattr(middleware, "sync_capable", True)
42 middleware_can_async = getattr(middleware, "async_capable", False)
43 if not middleware_can_sync and not middleware_can_async:
44 raise RuntimeError(
45 "Middleware %s must have at least one of "
46 "sync_capable/async_capable set to True." % middleware_path
47 )
48 elif not handler_is_async and middleware_can_sync:
49 middleware_is_async = False
50 else:
51 middleware_is_async = middleware_can_async
52 try:
53 # Adapt handler, if needed.
54 adapted_handler = self.adapt_method_mode(
55 middleware_is_async,
56 handler,
57 handler_is_async,
58 debug=settings.DEBUG,
59 name="middleware %s" % middleware_path,
60 )
61 mw_instance = middleware(adapted_handler)
62 except MiddlewareNotUsed as exc:
63 if settings.DEBUG:
64 if str(exc):
65 logger.debug("MiddlewareNotUsed(%r): %s", middleware_path, exc)
66 else:
67 logger.debug("MiddlewareNotUsed: %r", middleware_path)
68 continue
69 else:
70 handler = adapted_handler
71
72 if mw_instance is None:
73 raise ImproperlyConfigured(
74 "Middleware factory %s returned None." % middleware_path
75 )
76
77 if hasattr(mw_instance, "process_view"):
78 self._view_middleware.insert(
79 0,
80 self.adapt_method_mode(is_async, mw_instance.process_view),
81 )
82 if hasattr(mw_instance, "process_template_response"):
83 self._template_response_middleware.append(
84 self.adapt_method_mode(
85 is_async, mw_instance.process_template_response
86 ),
87 )
88 if hasattr(mw_instance, "process_exception"):
89 # The exception-handling stack is still always synchronous for
90 # now, so adapt that way.
91 self._exception_middleware.append(
92 self.adapt_method_mode(False, mw_instance.process_exception),
93 )
94
95 handler = convert_exception_to_response(mw_instance)
96 handler_is_async = middleware_is_async
97
98 # Adapt the top of the stack, if needed.
99 handler = self.adapt_method_mode(is_async, handler, handler_is_async)
100 # We only assign to this when initialization is complete as it is used
101 # as a flag for initialization being complete.
102 self._middleware_chain = handler
103
104 def adapt_method_mode(
105 self,
106 is_async,
107 method,
108 method_is_async=None,
109 debug=False,
110 name=None,
111 ):
112 """
113 Adapt a method to be in the correct "mode":
114 - If is_async is False:
115 - Synchronous methods are left alone
116 - Asynchronous methods are wrapped with async_to_sync
117 - If is_async is True:
118 - Synchronous methods are wrapped with sync_to_async()
119 - Asynchronous methods are left alone
120 """
121 if method_is_async is None:
122 method_is_async = iscoroutinefunction(method)
123 if debug and not name:
124 name = name or "method %s()" % method.__qualname__
125 if is_async:
126 if not method_is_async:
127 if debug:
128 logger.debug("Synchronous handler adapted for %s.", name)
129 return sync_to_async(method, thread_sensitive=True)
130 elif method_is_async:
131 if debug:
132 logger.debug("Asynchronous handler adapted for %s.", name)
133 return async_to_sync(method)
134 return method
135
136 def get_response(self, request):
137 """Return an HttpResponse object for the given HttpRequest."""
138 # Setup default url resolver for this thread
139 set_urlconf(settings.ROOT_URLCONF)
140 response = self._middleware_chain(request)
141 response._resource_closers.append(request.close)
142 if response.status_code >= 400:
143 log_response(
144 "%s: %s",
145 response.reason_phrase,
146 request.path,
147 response=response,
148 request=request,
149 )
150 return response
151
152 async def get_response_async(self, request):
153 """
154 Asynchronous version of get_response.
155
156 Funneling everything, including WSGI, into a single async
157 get_response() is too slow. Avoid the context switch by using
158 a separate async response path.
159 """
160 # Setup default url resolver for this thread.
161 set_urlconf(settings.ROOT_URLCONF)
162 response = await self._middleware_chain(request)
163 response._resource_closers.append(request.close)
164 if response.status_code >= 400:
165 await sync_to_async(log_response, thread_sensitive=False)(
166 "%s: %s",
167 response.reason_phrase,
168 request.path,
169 response=response,
170 request=request,
171 )
172 return response
173
174 def _get_response(self, request):
175 """
176 Resolve and call the view, then apply view, exception, and
177 template_response middleware. This method is everything that happens
178 inside the request/response middleware.
179 """
180 response = None
181 callback, callback_args, callback_kwargs = self.resolve_request(request)
182
183 # Apply view middleware
184 for middleware_method in self._view_middleware:
185 response = middleware_method(
186 request, callback, callback_args, callback_kwargs
187 )
188 if response:
189 break
190
191 if response is None:
192 wrapped_callback = self.make_view_atomic(callback)
193 # If it is an asynchronous view, run it in a subthread.
194 if iscoroutinefunction(wrapped_callback):
195 wrapped_callback = async_to_sync(wrapped_callback)
196 try:
197 response = wrapped_callback(request, *callback_args, **callback_kwargs)
198 except Exception as e:
199 response = self.process_exception_by_middleware(e, request)
200 if response is None:
201 raise
202
203 # Complain if the view returned None (a common error).
204 self.check_response(response, callback)
205
206 # If the response supports deferred rendering, apply template
207 # response middleware and then render the response
208 if hasattr(response, "render") and callable(response.render):
209 for middleware_method in self._template_response_middleware:
210 response = middleware_method(request, response)
211 # Complain if the template response middleware returned None
212 # (a common error).
213 self.check_response(
214 response,
215 middleware_method,
216 name="%s.process_template_response"
217 % (middleware_method.__self__.__class__.__name__,),
218 )
219 try:
220 response = response.render()
221 except Exception as e:
222 response = self.process_exception_by_middleware(e, request)
223 if response is None:
224 raise
225
226 return response
227
228 async def _get_response_async(self, request):
229 """
230 Resolve and call the view, then apply view, exception, and
231 template_response middleware. This method is everything that happens
232 inside the request/response middleware.
233 """
234 response = None
235 callback, callback_args, callback_kwargs = self.resolve_request(request)
236
237 # Apply view middleware.
238 for middleware_method in self._view_middleware:
239 response = await middleware_method(
240 request, callback, callback_args, callback_kwargs
241 )
242 if response:
243 break
244
245 if response is None:
246 wrapped_callback = self.make_view_atomic(callback)
247 # If it is a synchronous view, run it in a subthread
248 if not iscoroutinefunction(wrapped_callback):
249 wrapped_callback = sync_to_async(
250 wrapped_callback, thread_sensitive=True
251 )
252 try:
253 response = await wrapped_callback(
254 request, *callback_args, **callback_kwargs
255 )
256 except Exception as e:
257 response = await sync_to_async(
258 self.process_exception_by_middleware,
259 thread_sensitive=True,
260 )(e, request)
261 if response is None:
262 raise
263
264 # Complain if the view returned None or an uncalled coroutine.
265 self.check_response(response, callback)
266
267 # If the response supports deferred rendering, apply template
268 # response middleware and then render the response
269 if hasattr(response, "render") and callable(response.render):
270 for middleware_method in self._template_response_middleware:
271 response = await middleware_method(request, response)
272 # Complain if the template response middleware returned None or
273 # an uncalled coroutine.
274 self.check_response(
275 response,
276 middleware_method,
277 name="%s.process_template_response"
278 % (middleware_method.__self__.__class__.__name__,),
279 )
280 try:
281 if iscoroutinefunction(response.render):
282 response = await response.render()
283 else:
284 response = await sync_to_async(
285 response.render, thread_sensitive=True
286 )()
287 except Exception as e:
288 response = await sync_to_async(
289 self.process_exception_by_middleware,
290 thread_sensitive=True,
291 )(e, request)
292 if response is None:
293 raise
294
295 # Make sure the response is not a coroutine
296 if asyncio.iscoroutine(response):
297 raise RuntimeError("Response is still a coroutine.")
298 return response
299
300 def resolve_request(self, request):
301 """
302 Retrieve/set the urlconf for the request. Return the view resolved,
303 with its args and kwargs.
304 """
305 # Work out the resolver.
306 if hasattr(request, "urlconf"):
307 urlconf = request.urlconf
308 set_urlconf(urlconf)
309 resolver = get_resolver(urlconf)
310 else:
311 resolver = get_resolver()
312 # Resolve the view, and assign the match object back to the request.
313 resolver_match = resolver.resolve(request.path_info)
314 request.resolver_match = resolver_match
315 return resolver_match
316
317 def check_response(self, response, callback, name=None):
318 """
319 Raise an error if the view returned None or an uncalled coroutine.
320 """
321 if not (response is None or asyncio.iscoroutine(response)):
322 return
323 if not name:
324 if isinstance(callback, types.FunctionType): # FBV
325 name = "The view %s.%s" % (callback.__module__, callback.__name__)
326 else: # CBV
327 name = "The view %s.%s.__call__" % (
328 callback.__module__,
329 callback.__class__.__name__,
330 )
331 if response is None:
332 raise ValueError(
333 "%s didn't return an HttpResponse object. It returned None "
334 "instead." % name
335 )
336 elif asyncio.iscoroutine(response):
337 raise ValueError(
338 "%s didn't return an HttpResponse object. It returned an "
339 "unawaited coroutine instead. You may need to add an 'await' "
340 "into your view." % name
341 )
342
343 # Other utility methods.
344
345 def make_view_atomic(self, view):
346 non_atomic_requests = getattr(view, "_non_atomic_requests", set())
347 for alias, settings_dict in connections.settings.items():
348 if settings_dict["ATOMIC_REQUESTS"] and alias not in non_atomic_requests:
349 if iscoroutinefunction(view):
350 raise RuntimeError(
351 "You cannot use ATOMIC_REQUESTS with async views."
352 )
353 view = transaction.atomic(using=alias)(view)
354 return view
355
356 def process_exception_by_middleware(self, exception, request):
357 """
358 Pass the exception to the exception middleware. If no middleware
359 return a response for this exception, return None.
360 """
361 for middleware_method in self._exception_middleware:
362 response = middleware_method(request, exception)
363 if response:
364 return response
365 return None
366
367
368 def reset_urlconf(sender, **kwargs):
369 """Reset the URLconf after each request is finished."""
370 set_urlconf(None)
371
372
373 request_finished.connect(reset_urlconf)