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)
