def get_response(self, request): # type: (HttpRequest) -> HttpResponse "Returns an HttpResponse object for the given HttpRequest" try: try: # Setup default url resolver for this thread. urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) response = None # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: break if hasattr(request, "urlconf"): # Reset url resolver with a custom urlconf. urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) ### ADDED BY ZULIP request._resolver = resolver ### END ADDED BY ZULIP callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware if response is None: for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: break ### THIS BLOCK MODIFIED BY ZULIP if response is None: try: response = callback(request, *callback_args, **callback_kwargs) if response is RespondAsynchronously: async_request_stop(request) return None clear_handler_by_id(self.handler_id) except Exception as e: clear_handler_by_id(self.handler_id) # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: break if response is None: raise if response is None: try: view_name = callback.__name__ except AttributeError: view_name = callback.__class__.__name__ + '.__call__' raise ValueError("The view %s.%s returned None." % (callback.__module__, view_name)) # If the response supports deferred rendering, apply template # response middleware and the render the response if hasattr(response, 'render') and callable(response.render): for middleware_method in self._template_response_middleware: response = middleware_method(request, response) response = response.render() except http.Http404 as e: if settings.DEBUG: from django.views import debug response = debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() response = callback(request, **param_dict) except: try: response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) finally: signals.got_request_exception.send(sender=self.__class__, request=request) except exceptions.PermissionDenied: logging.warning( 'Forbidden (Permission denied): %s', request.path, extra={ 'status_code': 403, 'request': request }) try: callback, param_dict = resolver.resolve403() response = callback(request, **param_dict) except: try: response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) finally: signals.got_request_exception.send( sender=self.__class__, request=request) except SystemExit: # See https://code.djangoproject.com/ticket/4701 raise except Exception as e: exc_info = sys.exc_info() signals.got_request_exception.send(sender=self.__class__, request=request) return self.handle_uncaught_exception(request, resolver, exc_info) finally: # Reset urlconf on the way out for isolation urlresolvers.set_urlconf(None) ### ZULIP CHANGE: The remainder of this function was moved ### into its own function, just below, so we can call it from ### finish(). response = self.apply_response_middleware(request, response, resolver) return response
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" from django.core import exceptions, urlresolvers from django.conf import settings try: # Setup default url resolver for this thread, this code is outside # the try/except so we don't get a spurious "unbound local # variable" exception in the event an exception is raised before # resolver is set urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) try: response = None # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: break if response is None: if hasattr(request, "urlconf"): # Reset url resolver with a custom urlconf. urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: break if response is None: try: response = callback(request, *callback_args, **callback_kwargs) except Exception, e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: break if response is None: raise # Complain if the view returned None (a common error). if response is None: try: view_name = callback.func_name # If it's a function except AttributeError: view_name = callback.__class__.__name__ + '.__call__' # If it's a class raise ValueError("The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) # If the response supports deferred rendering, apply template # response middleware and the render the response if hasattr(response, 'render') and callable(response.render): for middleware_method in self._template_response_middleware: response = middleware_method(request, response) response = response.render() except http.Http404, e: logger.warning('Not Found: %s', request.path, extra={ 'status_code': 404, 'request': request }) if settings.DEBUG: from django.views import debug response = debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() response = callback(request, **param_dict) except: try: response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) finally: signals.got_request_exception.send(sender=self.__class__, request=request)
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" 根据请求, 得到响应 try: 为该线程提供默认的 url 处理器 # Setup default url resolver for this thread, this code is outside # the try/except so we don't get a spurious "unbound local # variable" exception in the event an exception is raised before # resolver is set #ROOT_URLCONF = 'mysite.urls' urlconf = settings.ROOT_URLCONF # set_urlconf() 会设置 url 配置即 settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) # 实例化 RegexURLResolver, 暂且将其理解为一个 url 的匹配处理器, 下节展开 resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) try: response = None # Apply request middleware 调用请求中间件 for middleware_method in self._request_middleware: response = middleware_method(request) # 如果此 response 有效, 即不走下面的逻辑 if response: break # 如果没有结果 if response is None: # 尝试 request 中是否有 urlconf, 一般没有, 可以忽略此段代码!!! if hasattr(request, 'urlconf'): # Reset url resolver with a custom urlconf. 自定义的 urlconf urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) # 调用 RegexURLResolver.resolve(), 可以理解为启动匹配的函数; 返回 ResolverMatch 实例 resolver_match = resolver.resolve(request.path_info) # resolver_match 对象中存储了有用的信息, 譬如 callback 就是我们在 views.py 中定义的函数. callback, callback_args, callback_kwargs = resolver_match # 将返回的 resolver_match 挂钩到 request request.resolver_match = resolver_match # Apply view middleware 调用视图中间件 for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) # 如果此 response 有效, 即不走下面的逻辑 if response: break # response 还是为空 if response is None: try: # 这里调用的是真正的处理函数, 我们一般在 view.py 中定义这些函数 response = callback(request, *callback_args, **callback_kwargs) except Exception as e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. # 出现异常, 调用异常中间件 for middleware_method in self._exception_middleware: response = middleware_method(request, e) # 如果此 response 有效, 即不走下面的逻辑 if response: break if response is None: raise # response 还是为空, 可能就要异常了 # Complain if the view returned None (a common error). if response is None: if isinstance(callback, types.FunctionType): # FBV view_name = callback.__name__ else: # CBV view_name = callback.__class__.__name__ + '.__call__' raise ValueError("The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) # If the response supports deferred rendering, apply template # response middleware and the render the response 如果 response 实现了 render, 那么渲染返回. if hasattr(response, 'render') and callable(response.render): for middleware_method in self._template_response_middleware: response = middleware_method(request, response) response = response.render() except http.Http404 as e: logger.warning('Not Found: %s', request.path, extra={ 'status_code': 404, 'request': request }) # 如果是调试下, 直接要返回 404 页面 if settings.DEBUG: response = debug.technical_404_response(request, e) else: try: # 非调试模式下, 获取 url 处理器的默认 404 处理 callback, param_dict = resolver.resolve404() response = callback(request, **param_dict) except: signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) # 访问拒绝 except exceptions.PermissionDenied: logger.warning( 'Forbidden (Permission denied): %s', request.path, extra={ 'status_code': 403, 'request': request }) try: callback, param_dict = resolver.resolve403() response = callback(request, **param_dict) except: signals.got_request_exception.send( sender=self.__class__, request=request) response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) except SystemExit: # Allow sys.exit() to actually exit. See tickets #1023 and #4701 raise except: # Handle everything else, including SuspiciousOperation, etc. # Get the exception info now, in case another exception is thrown later. signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) finally: # Reset URLconf for this thread on the way out for complete # isolation of request.urlconf 重置, 因为前面有两种 url resolver 的可能, 拒绝混淆 urlresolvers.set_urlconf(None) try: # Apply response middleware, regardless of the response 调用响应中间件 for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) except: # Any exception should be gathered and handled signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) return response
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" from django import http from django.core import exceptions, urlresolvers from django.conf import settings try: try: # Setup default url resolver for this thread. urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: return response if hasattr(request, "urlconf"): # Reset url resolver with a custom urlconf. urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: return response from ...decorator import TornadoAsyncException try: response = callback(request, *callback_args, **callback_kwargs) except TornadoAsyncException, e: # # Running under Tornado, so a null return is ok... means that the # data is not finished # return except Exception, e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: return response raise # Complain if the view returned None (a common error). if response is None: try: view_name = callback.func_name # If it's a function except AttributeError: view_name = callback.__class__.__name__ + '.__call__' # If it's a class raise ValueError( "The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) return response
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" # Setup default url resolver for this thread, this code is outside # the try/except so we don't get a spurious "unbound local # variable" exception in the event an exception is raised before # resolver is set urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) try: response = None # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: break if response is None: if hasattr(request, 'urlconf'): # Reset url resolver with a custom urlconf. urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) resolver_match = resolver.resolve(request.path_info) callback, callback_args, callback_kwargs = resolver_match request.resolver_match = resolver_match # Apply view middleware for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: break if response is None: wrapped_callback = self.make_view_atomic(callback) try: response = wrapped_callback(request, *callback_args, **callback_kwargs) except Exception as e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: break if response is None: raise # Complain if the view returned None (a common error). if response is None: if isinstance(callback, types.FunctionType): # FBV view_name = callback.__name__ else: # CBV view_name = callback.__class__.__name__ + '.__call__' raise ValueError( "The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) # If the response supports deferred rendering, apply template # response middleware and then render the response if hasattr(response, 'render') and callable(response.render): for middleware_method in self._template_response_middleware: response = middleware_method(request, response) response = response.render() except http.Http404 as e: logger.warning('Not Found: %s', request.path, extra={ 'status_code': 404, 'request': request }) if settings.DEBUG: response = debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() response = callback(request, **param_dict) except: signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) except PermissionDenied: logger.warning('Forbidden (Permission denied): %s', request.path, extra={ 'status_code': 403, 'request': request }) try: callback, param_dict = resolver.resolve403() response = callback(request, **param_dict) except: signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) except SuspiciousOperation as e: # The request logger receives events for any problematic request # The security logger receives events for all SuspiciousOperations security_logger = logging.getLogger('django.security.%s' % e.__class__.__name__) security_logger.error(force_text(e), extra={ 'status_code': 400, 'request': request }) try: callback, param_dict = resolver.resolve400() response = callback(request, **param_dict) except: signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) except SystemExit: # Allow sys.exit() to actually exit. See tickets #1023 and #4701 raise except: # Handle everything else. # Get the exception info now, in case another exception is thrown later. signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) try: # Apply response middleware, regardless of the response for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) except: # Any exception should be gathered and handled signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception(request, resolver, sys.exc_info()) return response
def __init__(self, *urlpairs): self.urlpatterns = patterns('', *urlpairs) # for 1.0 compatibility we pass in None for urlconf_name and then # modify the _urlconf_module to make self hack as if its the module. self.resolver = urlresolvers.RegexURLResolver(r'^/', None) self.resolver._urlconf_module = self
raise else: continue if debug: print "found %r with urls.py" % app_label try: urlpatterns = url_mod.urlpatterns except AttributeError: if debug: print "Skip %r: urls.py has no 'urlpatterns'" % app_label continue resolver = urlresolvers.RegexURLResolver(r'^/', urlpatterns) try: func, func_args, func_kwargs = resolver.resolve(resolve_url) except urlresolvers.Resolver404, err: if debug: print "Skip %r: Can't handle root url." % app_label continue if not no_args or func_args == () and func_kwargs == {}: root_apps.append(app_label) return root_apps if __name__ == "__main__": import doctest doctest.testmod( # verbose=True
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" from django import http from django.core import exceptions, urlresolvers from django.conf import settings try: try: # Setup default url resolver for this thread. urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) response = None # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: break if hasattr(request, "urlconf"): # Reset url resolver with a custom urlconf. urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) ### ADDED BY ZULIP request._resolver = resolver ### END ADDED BY ZULIP callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware if response is None: for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: break ### THIS BLOCK MODIFIED BY ZULIP if response is None: from ...decorator import RespondAsynchronously try: response = callback(request, *callback_args, **callback_kwargs) if response is RespondAsynchronously: async_request_stop(request) return except Exception, e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: break if response is None: raise if response is None: try: view_name = callback.func_name except AttributeError: view_name = callback.__class__.__name__ + '.__call__' raise ValueError("The view %s.%s returned None." % (callback.__module__, view_name)) # If the response supports deferred rendering, apply template # response middleware and the render the response if hasattr(response, 'render') and callable(response.render): for middleware_method in self._template_response_middleware: response = middleware_method(request, response) response = response.render() except http.Http404, e: if settings.DEBUG: from django.views import debug response = debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() response = callback(request, **param_dict) except: try: response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) finally: signals.got_request_exception.send( sender=self.__class__, request=request)
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" from django.core import exceptions, urlresolvers from django.conf import settings try: try: # Reset the urlconf for this thread. urlresolvers.set_urlconf(None) # Obtain a default resolver. It's needed early for handling 404's. resolver = urlresolvers.RegexURLResolver(r'^/', None) # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: return response # Get urlconf from request object, if available. Otherwise use default. urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) # Set the urlconf for this thread to the one specified above. urlresolvers.set_urlconf(urlconf) # Reset the resolver with a possibly new urlconf resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: return response try: response = callback(request, *callback_args, **callback_kwargs) except Exception, e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: return response raise # Complain if the view returned None (a common error). if response is None: try: view_name = callback.func_name # If it's a function except AttributeError: view_name = callback.__class__.__name__ + '.__call__' # If it's a class raise ValueError("The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) return response except http.Http404, e: if settings.DEBUG: from django.views import debug return debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() return callback(request, **param_dict) except: try: return self.handle_uncaught_exception(request, resolver, sys.exc_info()) finally: receivers = signals.got_request_exception.send(sender=self.__class__, request=request)
def get_filtered_apps(resolve_url="/", no_args=True, debug=False, skip_fail=False): """ Filter settings.INSTALLED_APPS and create a list of all Apps witch can resolve the given url >resolve_url< @param resolve_url: url used for RegexURLResolver @param no_args: Only views without args/kwargs ? @parm skip_fail: If True: raise exception if app is not importable Please look at: django_tools.tests.test_installed_apps_utils with debug, some print messages would be created: e.g.: get_filtered_apps(debug=True) found 'django.contrib.admindocs' with urls.py found 'django.contrib.auth' with urls.py Skip 'django.contrib.auth': Can't handle root url. found 'django.contrib.flatpages' with urls.py ['django.contrib.admindocs'] """ root_apps = [] for app_label in settings.INSTALLED_APPS: urls_pkg = "%s.urls" % app_label try: url_mod = import_module(urls_pkg) except ImportError as err: if debug: print("Skip %r: has no urls.py" % app_label) if PY2: msg_should = "No module named urls" else: msg_should = "No module named '%s'" % urls_pkg if str(err) == msg_should: continue if not skip_fail: raise except Exception as err: if debug: print("Error importing %r: %s" % (app_label, err)) if not skip_fail: raise else: continue if debug: print("found %r with urls.py" % app_label) try: urlpatterns = url_mod.urlpatterns except AttributeError: if debug: print("Skip %r: urls.py has no 'urlpatterns'" % app_label) continue resolver = urlresolvers.RegexURLResolver(r'^', urlpatterns) try: func, func_args, func_kwargs = resolver.resolve(resolve_url) except urlresolvers.Resolver404 as err: if debug: print("Skip %r: Can't handle root url." % app_label) continue if not no_args or func_args == () and func_kwargs == {}: root_apps.append(app_label) return root_apps
def ping(source, target): """ Pingback server function. Requires URL of pinger resource and link of pinging resource. Determinition of pingable object by it's url is done by setting settings.PINGBACK_SERVER in the following format:: { 'post_detail': 'pingback.getters.post_get', } Where: - 'post_detail' is name of url - 'pingback.getters.post_get' is name of function, which will return object using parameters, resolved by URL. """ domain = Site.objects.get_current().domain try: doc = urlopen(source) except (HTTPError, URLError): return PingbackError.SOURCE_DOES_NOT_EXIST soup = BeautifulSoup(doc.read()) mylink = soup.find('a', href=target) if not mylink: return PingbackError.SOURCE_DOES_NOT_LINKING # title title = soup.find('title') if title: title = strip_tags(unicode(title)) else: title = 'Unknown title' content = unicode(mylink.findParent()) i = content.index(unicode(mylink)) content = strip_tags(content) max_length = settings.PINGBACK_RESPONSE_LENGTH if len(content) > max_length: start = i - max_length / 2 if start < 0: start = 0 end = i + len(unicode(mylink)) + max_length / 2 if end > len(content): end = len(content) content = content[start:end] scheme, server, path, query, fragment = urlsplit(target) if not (server == domain or server.split(':')[0] == domain): return PingbackError.TARGET_IS_NOT_PINGABLE resolver = ur.RegexURLResolver(r'^/', settings.ROOT_URLCONF) try: func, smth, params = resolver.resolve(path) except ur.Resolver404: return PingbackError.TARGET_DOES_NOT_EXIST name = resolver.reverse_dict[func][-1].name if not name in settings.PINGBACK_SERVER: return PingbackError.TARGET_IS_NOT_PINGABLE getter = settings.PINGBACK_SERVER[name] if not callable(getter): getter = get_callable(getter) obj = getter(**params) ctype = ContentType.objects.get_for_model(obj) try: Pingback.objects.get(url=source, content_type=ctype, object_id=obj.id) return PingbackError.PINGBACK_ALREADY_REGISTERED except Pingback.DoesNotExist: pass pb = Pingback(object=obj, url=source, content=content.encode('utf-8'), title=title.encode('utf-8'), approved=True) pb.save() return 'pingback from %s to %s saved' % (source, target)
def get_response(self, request): try: urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) try: response = None for middleware_method in self._request_middleware: response = middleware_method(request) if response: break if response is None: if hasattr(request, 'urlconf'): urlconf = request.urlconf urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver( r'^/', urlconf) resolver_match = resolver.resolve(request.path_info) callback, callback_args, callback_kwargs = resolver_match request.resolver_match = resolver_match for middleware_method in self._view_middleware: response = middleware_method( request, callback, callback_args, callback_kwargs) if response: break if response is None: try: response = yield Chain([ lambda: callback(request, *callback_args, ** callback_kwargs) ]) except Exception as e: for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: break if response is None: raise if response is None: if isinstance(callback, types.FunctionType): # FBV view_name = callback.__name__ else: # CBV view_name = callback.__class__.__name__ + '.__call__' raise ValueError( "The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) if hasattr(response, 'render') and callable( response.render): for middleware_method in self._template_response_middleware: response = middleware_method(request, response) response = response.render() except http.Http404 as e: log.warning('Not Found: %s', request.path, extra={ 'status_code': 404, 'request': request }) if settings.DEBUG: response = debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() response = callback(request, **param_dict) except: signals.got_request_exception.send( sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) except exceptions.PermissionDenied: log.warning('Forbidden (Permission denied): %s', request.path, extra={ 'status_code': 403, 'request': request }) try: callback, param_dict = resolver.resolve403() response = callback(request, **param_dict) except: signals.got_request_exception.send( sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) except SystemExit: raise except: signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) finally: urlresolvers.set_urlconf(None) try: for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) except: signals.got_request_exception.send(sender=self.__class__, request=request) response = self.handle_uncaught_exception( request, resolver, sys.exc_info()) yield response
def get_response(self, request): "Returns an HttpResponse object for the given HttpRequest" from django.core import exceptions, urlresolvers from django.conf import settings # Apply request middleware for middleware_method in self._request_middleware: response = middleware_method(request) if response: return response # Get urlconf from request object, if available. Otherwise use default. urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) try: callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in self._view_middleware: response = middleware_method(request, callback, callback_args, callback_kwargs) if response: return response try: response = callback(request, *callback_args, **callback_kwargs) except Exception as e: # If the view raised an exception, run it through exception # middleware, and if the exception middleware returns a # response, use that. Otherwise, reraise the exception. for middleware_method in self._exception_middleware: response = middleware_method(request, e) if response: return response raise # Complain if the view returned None (a common error). if response is None: try: view_name = callback.__name__ # If it's a function except AttributeError: view_name = callback.__class__.__name__ + '.__call__' # If it's a class raise ValueError("The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)) return response except http.Http404 as e: if settings.DEBUG: from django.views import debug return debug.technical_404_response(request, e) else: try: callback, param_dict = resolver.resolve404() return callback(request, **param_dict) except: return self.handle_uncaught_exception(request, resolver, sys.exc_info()) except exceptions.PermissionDenied: return http.HttpResponseForbidden('<h1>Permission denied</h1>') except SystemExit: # Allow sys.exit() to actually exit. See tickets #1023 and #4701 raise except: # Handle everything else, including SuspiciousOperation, etc. # Get the exception info now, in case another exception is thrown later. exc_info = sys.exc_info() receivers = dispatcher.send(signal=signals.got_request_exception, request=request) return self.handle_uncaught_exception(request, resolver, exc_info)