def process_exception(self, request, exception):
if not settings.DEBUG or MONKEY_FORCE_ACTIVE:
exc_info = sys.exc_info()
if exc_info:
response = technical_500_response(request, *exc_info)
else:
response = technical_500_response(request, type(exception), exception, None)
self.patch_response(request, response)
return response
def django_error_page_response(request, error=None):
''' Return a response with Django's error page.
If settings.DEBUG is True, Django automatically shows a useful
error page for exceptions in views. But sometimes an exception
isn't propogated out of the view, such as when the exception
occurs in a separate thread. This shows the Django error page
for any exception.
If error is not present or is None, returns an error page for the
last exception.
Example:
error = None
...
# in separate thread
error = sys.exc_info()
...
# in parent thread
show_django_error_page(error)
'''
from django.views.debug import technical_500_response
# error should be sys.exc_info() from an earlier except block
if not error:
error = sys.exc_info()
exc_type, exc_value, tb = error
response = technical_500_response(request, exc_type, exc_value, tb)
def handle_uncaught_exception(self, request, resolver, exc_info):
"""
处理未能捕捉的错误
Processing for any otherwise uncaught exceptions (those that will
generate HTTP 500 responses). Can be overridden by subclasses who want
customised 500 handling. 子类中可以重写 500 状态的处理
Be *very* careful when overriding this because the error could be
caused by anything, so assuming something like the database is always
available would be an error.
"""
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
logger.error('Internal Server Error: %s', request.path,
exc_info=exc_info,
extra={
'status_code': 500,
'request': request
}
)
调试模式特殊处理
if settings.DEBUG:
return debug.technical_500_response(request, *exc_info)
# If Http500 handler is not installed, re-raise last exception 如果http500 处理器都没有安装, 可能会崩溃
if resolver.urlconf_module is None:
six.reraise(*exc_info)
# Return an HttpResponse that displays a friendly error message.
#这是自定义的 500 处理器
callback, param_dict = resolver.resolve500()
return callback(request, **param_dict)
def server_error(request, *args, **kwargs):
debugkey = request.REQUEST.get('debugkey')
if debugkey and debugkey == getattr(settings, 'DEBUGKEY', None):
import sys
from django.views import debug
return debug.technical_500_response(request, *sys.exc_info())
return HttpResponseServerError(render_to_string(request, '500.html'))
def test_technical_500_response_empty(settings, mock_api_response_empty, mocker, rf, capsys):
settings.DEBUG = True
test_data_url = 'http://www.fixmydjango.com/test-server'
submission_url = 'http://www.fixmydjango.com/test-server/draft/create/'
try:
raise ValueError("test")
except:
exc_info = sys.exc_info()
def clean_traceback(tb):
# remove \r
tb = tb.replace('\r', '')
# remove empty lines
tb_lines = [line for line in tb.split('\n')
if line.strip()]
return '\n'.join(tb_lines)
mocker.patch('fixmydjango.is_django_exception', return_value=True)
mocker.patch('fixmydjango.clean_traceback', side_effect=clean_traceback)
mocker.patch('fixmydjango.sanitize_traceback', side_effect=lambda x: x)
mocker.patch(
'fixmydjango.ExceptionReporterPatch._get_fix_my_django_submission_url',
return_value=submission_url)
request = rf.get(reverse('test-error'))
response = technical_500_response(request, *exc_info)
assert response.status_code == 500
out, err = capsys.readouterr()
assert out == colored(FIX_MY_DJANGO_MESSAGE_TO_ADMIN_PLAIN.format(submission_url=submission_url), 'yellow') + '\n'
def server_error(self, request, exception = None, *args, **kwargs):
"""
Graceful degradation, last resort.
usage:
server_error(request, [ exception = None])
"""
try:
import logging
logging.exception('server error')
except:
pass
try: # render default 500 response
from django.conf import settings
debugkey = request.REQUEST.get('debugkey')
DEBUG = getattr(settings, 'DEBUG')
if DEBUG or (debugkey and debugkey == getattr(settings, 'DEBUGKEY')):
import sys
from django.views import debug
return debug.technical_500_response(request, *sys.exc_info())
except:
pass
try: # try coustom response
if exception:
request.response = self._exception_str(exception)
return self._fetch_page(request, 500)
except:
pass
def handle_uncaught_exception(self, request, resolver, exc_info):
"""
Processing for any otherwise uncaught exceptions (those that will
generate HTTP 500 responses). Can be overridden by subclasses who want
customised 500 handling.
Be *very* careful when overriding this because the error could be
caused by anything, so assuming something like the database is always
available would be an error.
"""
from django.conf import settings
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
print exc_info
logger.error('Internal Server Error: %s', request.path,
exc_info=exc_info,
extra={
'status_code': 500,
'request': request
}
)
from django.views import debug
return debug.technical_500_response(request, *exc_info)
def process_exception(self, request, exception):
try:
user = request.user
except:
user = None
if user and user.is_superuser:
return technical_500_response(request, *sys.exc_info())
def sensitive_kwargs_function_caller(request):
try:
sensitive_kwargs_function(''.join(['w', 'o', 'r', 'c', 'e', 's', 't', 'e', 'r', 's', 'h', 'i', 'r', 'e']))
except Exception:
exc_info = sys.exc_info()
send_log(request, exc_info)
return technical_500_response(request, *exc_info)
def raises_template_does_not_exist(request):
# We need to inspect the HTML generated by the fancy 500 debug view but
# the test client ignores it, so we send it explicitly.
try:
return render_to_response('i_dont_exist.html')
except TemplateDoesNotExist:
return technical_500_response(request, *sys.exc_info())
def raises500(request):
# We need to inspect the HTML generated by the fancy 500 debug view but
# the test client ignores it, so we send it explicitly.
try:
raise Exception
except Exception:
return technical_500_response(request, *sys.exc_info())
def handle_uncaught_exception(self, request, resolver, exc_info):
"""
Processing for any otherwise uncaught exceptions (those that will
generate HTTP 500 responses). Can be overridden by subclasses who want
customised 500 handling.
Be *very* careful when overriding this because the error could be
caused by anything, so assuming something like the database is always
available would be an error.
"""
from django.conf import settings
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
logger.error('Internal Server Error: %s' % request.path,
exc_info=exc_info,
extra={
'status_code': 500,
'request':request
}
)
# If Http500 handler is not installed, re-raise last exception
if resolver.urlconf_module is None:
raise exc_info[1], None, exc_info[2]
# Return an HttpResponse that displays a friendly error message.
callback, param_dict = resolver.resolve500()
return callback(request, **param_dict)
def email_admin_last_exception(request):
"""
Email admin about the exception just caught. It's useful when we need to
catch an exception nicely but still want to send admin an email about it.
Email code were taken from django.core.handlers.base.BaseHandler.
handle_uncaught_exception.
Usage example (normally in a view):
try:
raise ValueError
except ValueError:
email_admin_last_exception(request)
return <some nicer response>
"""
import sys
from django.core.mail import mail_admins
exc_info = sys.exc_info()
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
# When DEBUG is False, send an error message to the admins.
subject = 'Error (%s IP): %s' % ((request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), request.path)
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
message = "%s\n\n%s" % (_get_traceback(exc_info), request_repr)
mail_admins(subject, message, fail_silently=True)
def server_error(request, *args, **kwargs):
# Save exc info before next exception occurs
exc_info = sys.exc_info()
crash_reporting = logger.CrashReporting(transport='threaded')
try:
tb = Advanced.objects.all().latest('id').adv_traceback
except:
tb = True
# Crash reporting
extra_log_files = [
('/var/log/debug.log', 'debug_log'),
('/data/update.failed', 'update_failed'),
]
# If the exception comes from middleware client lets append the log
# since middlewared itself might be stuck
if issubclass(exc_info[0], (ClientException, socket.timeout)):
extra_log_files.insert(0, ('/var/log/middlewared.log', 'middlewared_log'))
log.debug('UI crash exception', exc_info=exc_info)
crash_reporting.report(exc_info, request2crashreporting(request), extra_log_files)
try:
if tb:
reporter = ExceptionReporter(request, *exc_info)
html = reporter.get_traceback_html()
return HttpResponse(html, content_type='text/html')
else:
raise
except Exception:
return debug.technical_500_response(request, *exc_info)
def handle_uncaught_exception(self, request, exc_info):
"""
Processing for any otherwise uncaught exceptions (those that will
generate HTTP 500 responses). Can be overridden by subclasses who want
customised 500 handling.
Be *very* careful when overriding this because the error could be
caused by anything, so assuming something like the database is always
available would be an error.
"""
from django.core.mail import mail_admins
if self.propagate_exceptions:
raise
if self.debug:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
# When DEBUG is False, send an error message to the admins.
subject = 'Error: %s' % request.path
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
message = "%s\n\n%s" % (self._get_traceback(exc_info), request_repr)
mail_admins(subject, message, fail_silently=True)
# Return an HttpResponse that displays a friendly error message.
return self.handle_500(request, exc_info)
def handle_uncaught_exception(self, request, resolver, exc_info):
"""
Processing for any otherwise uncaught exceptions (those that will
generate HTTP 500 responses). Can be overridden by subclasses who want
customised 500 handling.
Be *very* careful when overriding this because the error could be
caused by anything, so assuming something like the database is always
available would be an error.
"""
from django.conf import settings
from django.core.mail import mail_admins
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
# When DEBUG is False, send an error message to the admins.
subject = "Error (%s IP): %s" % (
(request.META.get("REMOTE_ADDR") in settings.INTERNAL_IPS and "internal" or "EXTERNAL"),
request.path,
)
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
message = "%s\n\n%s" % (self._get_traceback(exc_info), request_repr)
mail_admins(subject, message, fail_silently=True)
# Return an HttpResponse that displays a friendly error message.
callback, param_dict = resolver.resolve500()
return callback(request, **param_dict)
def sensitive_kwargs_function_caller(request):
try:
sensitive_kwargs_function("".join(["w", "o", "r", "c", "e", "s", "t", "e", "r", "s", "h", "i", "r", "e"]))
except Exception:
exc_info = sys.exc_info()
send_log(request, exc_info)
return technical_500_response(request, *exc_info)
def save_traceback_to_epoch_file(self, request, exc_info):
try:
resp = technical_500_response(request, *exc_info)
if BETTER_500_LOG_DIR:
epoch = int(time.mktime(datetime.datetime.now().timetuple()))
epoch_file = "%s.html" % (epoch,)
folder = os.path.join(BETTER_500_LOG_DIR, BETTER_500_UNCAUGHT_DIR)
debug_log_file = os.path.join(folder, epoch_file)
if not os.path.exists(folder):
os.makedirs(folder)
try:
default_storage.save(debug_log_file, ContentFile(resp._container[0]))
except:
f = open(debug_log_file,"a")
f.write(resp._container[0])
f.close()
return epoch
except:
try:
log = logging.getLogger("better500s")
log.error(exception_string())
except:
pass
pass
return None
def server_error_500(request, template_name='500.html'):
"""
Custom 500 handler method.
The traceback is written to an html file and a plain text file
which are placed in the log directory.
"""
file_prefix = datetime.datetime.utcnow().strftime('%Y-%m-%d-%H-%M-%S')
try:
# --- Log to file ---
# Log straight to file with Django's normal HTML formatted 500 output
traceback_500 = debug.technical_500_response(request, *sys.exc_info())
destFilename = "%s_%s_500.html" %(file_prefix, settings.LOG_FILE)
log_filepath = os.path.join(settings.LOG_DIR, destFilename)
out_file = open(log_filepath, "w")
out_file.write(traceback_500.content)
out_file.close()
# --- Render to flat file ---
# get our own custom technical 500 template to render a non-HTML
# plain text version of the error output
# Initialise Django's TECHNICAL_500_TEMPLATE to ours
from main.httpd_errors import FLAT_500_TEMPLATE
debug.TECHNICAL_500_TEMPLATE = FLAT_500_TEMPLATE
traceback_500 = debug.technical_500_response(request, *sys.exc_info())
destFilename = "%s_%s_500.log" %(file_prefix, settings.LOG_FILE)
log_filepath = os.path.join(settings.LOG_DIR, destFilename)
out_file = open(log_filepath, "w")
out_file.write(traceback_500.content)
out_file.close()
# --- Render to page ---
# get our own custom technical 500 template to render for the browser
# Initialise Django's TECHNICAL_500_TEMPLATE to ours
from main.httpd_errors import TECHNICAL_500_TEMPLATE
debug.TECHNICAL_500_TEMPLATE = TECHNICAL_500_TEMPLATE
# Get the traceback formatted the way we want it for inclusion in the
# web page we will render
traceback_500 = debug.technical_500_response(request, *sys.exc_info())
template = loader.get_template(template_name) # You need to create a 500.html template!
c = Context({
'traceback': traceback_500.content,
'log_filepath': log_filepath,
})
response = HttpResponse(template.render(c))
except Exception, e:
response = HttpResponse('<html><body><p>%s</p>Click here to return <a href="/">home</a></body></html>' % unicode(e))
def process_exception(self, request, exception):
exc_info = sys.exc_info()
user = request.user
if not user.is_superuser:
return None
if user.groups.filter(name=EX_GROUP_NAME):
return technical_500_response(request, *exc_info)
return None
def doc_reader(request, docname):
try:
doc = get_doc(docname)
except Exception, e:
# Always use the debug response, even if we aren't in DEBUG mode.
import sys
from django.views import debug
return debug.technical_500_response(request, *sys.exc_info())
def server_error(request):
"""
500 error handler.
For now always return the debug response. Mailing isn't appropriate here.
"""
from django.views import debug
return debug.technical_500_response(request, *sys.exc_info())
def multivalue_dict_key_error(request):
cooked_eggs = "".join(["s", "c", "r", "a", "m", "b", "l", "e", "d"]) # NOQA
sauce = "".join(["w", "o", "r", "c", "e", "s", "t", "e", "r", "s", "h", "i", "r", "e"]) # NOQA
try:
request.POST["bar"]
except Exception:
exc_info = sys.exc_info()
send_log(request, exc_info)
return technical_500_response(request, *exc_info)
def handle_value_error(self, request, exception):
exc_info = sys.exc_info()
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
else:
'''Return an HttpResponse that displays a friendly message.'''
callback, param_dict = resolver(request).resolve500()
return callback(request, **param_dict)
def multivalue_dict_key_error(request):
cooked_eggs = ''.join(['s', 'c', 'r', 'a', 'm', 'b', 'l', 'e', 'd']) # NOQA
sauce = ''.join(['w', 'o', 'r', 'c', 'e', 's', 't', 'e', 'r', 's', 'h', 'i', 'r', 'e']) # NOQA
try:
request.POST['bar']
except Exception:
exc_info = sys.exc_info()
send_log(request, exc_info)
return technical_500_response(request, *exc_info)
def process_exception(self, request, exception):
"""Same as UserBasedExceptionMiddleware but works for all superusers but without
need of creating groups, having cache etc.
"""
if DEBUG:
return None
if request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
return None
def raises(request):
# Make sure that a callable that raises an exception in the stack frame's
# local vars won't hijack the technical 500 response (#15025).
def callable():
raise Exception
try:
raise Exception
except Exception:
return technical_500_response(request, *sys.exc_info())
def handler_500(request):
info = sys.exc_info()
if request.settings.exists and request.settings.DEBUG:
try:
template = loader.get_template(request.settings.TEMPLATE_500)
return HttpResponseServerError(template.render(RequestContext(request)))
except:
pass
return debug.technical_500_response(request, *info)
def server_error(request, template_name="errors/500.html"):
"""
Mimics Django's error handler but adds ``STATIC_URL`` to the
context.
"""
if request.user.is_superuser or request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
return technical_500_response(request, *sys.exc_info())
context = RequestContext(request, {"STATIC_URL": settings.STATIC_URL})
t = get_template(template_name)
return HttpResponseServerError(t.render(context))
def raises(request):
# Make sure that a callable that raises an exception in the stack frame's
# local vars won't hijack the technical 500 response. See:
# http://code.djangoproject.com/ticket/15025
def callable():
raise Exception
try:
raise Exception
except Exception:
return technical_500_response(request, *sys.exc_info())
def safe_process_response(self, request, response):
try:
return process_response(self, request, response)
except Exception:
return technical_500_response(request, *sys.exc_info())
def process_exception(self, request, exception):
sentry_exception_handler(request=request)
if request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
def _wrap_view_func(request, *args, **kwargs):
is_ajax = True
if hasattr(request, 'is_ajax'):
if not request.is_ajax():
is_ajax = False
else:
# for backward compatibility with Django pre 1.0
if not (request.META.has_key('HTTP_ACCEPT') and
'application/javascript' in request.META['HTTP_ACCEPT']):
is_ajax = False
origin_resp = None
#FIXME: require refactoring here
if not is_ajax:
# require direct call original function (out of try/except) to proper determine error exception
# in orinical view
origin_resp = view_func(request, *args, **kwargs)
if isinstance(origin_resp, dict) or isinstance(origin_resp, list):
return _json_dump(origin_resp)
else:
return origin_resp
response_dict = {}
response_dict['debug'] = False
try:
origin_resp = view_func(request, *args, **kwargs)
if isinstance(origin_resp, dict) or isinstance(origin_resp, list):
if isinstance(origin_resp, dict):
if 'status' not in origin_resp:
origin_resp['status'] = 200
return _json_dump(origin_resp)
if hasattr(
origin_resp, 'content_type'
) and origin_resp.content_type == 'application/javascript':
return origin_resp
response_dict['status'] = origin_resp.status_code
response_dict['content'] = origin_resp.content
# if isinstance(origin_resp, HttpResponseRedirect):
# response_dict['location'] = origin_resp['location']
except Http404 as e:
raise Http404(e)
except Exception as e:
response_dict['status'] = 500
if settings.DEBUG:
from django.views import debug
rc = debug.technical_500_response(request, *sys.exc_info())
response_dict['debug'] = True
# rc.content #.replace('\n', '<br>\n')
response_dict['debug_msg'] = ''
else:
from django.core.mail import mail_admins
exc_info = sys.exc_info()
subject = 'Error (%s IP): %s' % (
(request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS
and 'internal' or 'EXTERNAL'), request.path)
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
message = "%s\n\n%s" % (_get_traceback(exc_info), request_repr)
mail_admins(subject, message, fail_silently=True)
resp = HttpResponse(simplejson.dumps(response_dict,
ensure_ascii=False),
content_type='application/javascript')
_copy_x_headers(origin_resp, resp)
return resp
def process_exception(self, request, exception):
if request.user.is_superuser or getip(
request) in django_settings.INTERNAL_IPS:
return technical_500_response(request, *sys.exc_info())
def process_exception(request: HttpRequest,
exception: Exception) -> HttpResponse:
# noinspection PyUnresolvedReferences
if request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
def process_exception(self, request, exception):
# 如果关闭debug模式，并且是管理员：可以看到错误页面，否则根据系统配置进行跳转。
if settings.DEBUG is False and request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
def raises(request):
try:
raise Exception
except Exception:
return technical_500_response(request, *sys.exc_info())
def __call__(self, request, *args, **kwargs):
try:
return self.func(request, *args, **kwargs)
except exceptions.DisallowedHost as ex:
self.GetLogger(request).exception(GetEnvInfo(request))
response = self._page400(request)
return response
except Http404 as e:
if settings.DEBUG:
self.GetLogger(request).exception(GetEnvInfo(request))
from django.views import debug
response = debug.technical_404_response(request, e)
else:
response = self._page404(request)
response.source_exc = e
return response
except TooLongRequestException as ex:
traceback = FormatTraceback()
log_res.exception(
"TooLongRequestException: ('{}'; '{}'; '{}')".format(
request.META['REMOTE_ADDR'],
request.full_url,
request.META.get('HTTP_USER_AGENT', 'NONE'),
))
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *sys.exc_info())
response = self._page500(request, status=503)
response._exc_details = (ex, traceback)
return response
except (OperationalError, DjangoOperationalError) as ex:
traceback = FormatTraceback()
log_res.exception("OperationalError: ('{}'; '{}'; '{}')".format(
request.META['REMOTE_ADDR'],
request.full_url,
request.META.get('HTTP_USER_AGENT', 'NONE'),
))
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *sys.exc_info())
response = self._page500(request, status=503)
response._exc_details = (ex, traceback)
response.skip_bug_report = True
return response
except exceptions.PermissionDenied as pd:
if settings.DEBUG:
self.GetLogger(request).exception(GetEnvInfo(request))
response = self._page403(request)
response.source_exc = pd
return response
except BadRequestException as pd:
self.GetLogger(request).exception(GetEnvInfo(request))
response = self._page400(request)
response.skip_bug_report = True
return response
except BotRequestException as ex:
self.GetLogger(request).exception(GetEnvInfo(request))
response = self._page503(request, status=503)
response.skip_bug_report = True
return response
except NotImplementedError as ex:
self.GetLogger(request).exception(GetEnvInfo(request))
return self._page500(request, status=503)
except SystemExit:
pass # See http://code.djangoproject.com/ticket/1023
except Exception as ex: # Handle everything else
traceback = FormatTraceback()
self.GetLogger(request).exception(GetEnvInfo(request))
# if settings.DEBUG:
# from django.views import debug
# return debug.technical_500_response(request, *sys.exc_info())
response = self._page502(request)
response._exc_details = (ex, traceback)
return response
def process_exception(self, request, exception):
if request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
def debug_500_response(self, request, exception, exc_info):
from django.views import debug
return debug.technical_500_response(request, *exc_info)
def response_for_exception(request, exc):
if isinstance(exc, Http404):
if settings.DEBUG:
response = debug.technical_404_response(request, exc)
else:
response = get_exception_response(request, get_resolver(get_urlconf()), 404, exc)
elif isinstance(exc, PermissionDenied):
response = get_exception_response(request, get_resolver(get_urlconf()), 403, exc)
log_response(
'Forbidden (Permission denied): %s', request.path,
response=response,
request=request,
exc_info=sys.exc_info(),
)
elif isinstance(exc, MultiPartParserError):
response = get_exception_response(request, get_resolver(get_urlconf()), 400, exc)
log_response(
'Bad request (Unable to parse request body): %s', request.path,
response=response,
request=request,
exc_info=sys.exc_info(),
)
elif isinstance(exc, SuspiciousOperation):
if isinstance(exc, (RequestDataTooBig, TooManyFieldsSent)):
# POST data can't be accessed again, otherwise the original
# exception would be raised.
request._mark_post_parse_error()
# The request logger receives events for any problematic request
# The security logger receives events for all SuspiciousOperations
security_logger = logging.getLogger('django.security.%s' % exc.__class__.__name__)
security_logger.error(
str(exc),
extra={'status_code': 400, 'request': request},
)
if settings.DEBUG:
response = debug.technical_500_response(request, *sys.exc_info(), status_code=400)
else:
response = get_exception_response(request, get_resolver(get_urlconf()), 400, exc)
elif isinstance(exc, SystemExit):
# Allow sys.exit() to actually exit. See tickets #1023 and #4701
raise
else:
signals.got_request_exception.send(sender=None, request=request)
response = handle_uncaught_exception(request, get_resolver(get_urlconf()), sys.exc_info())
log_response(
'%s: %s', response.reason_phrase, request.path,
response=response,
request=request,
exc_info=sys.exc_info(),
)
# Force a TemplateResponse to be rendered.
if not getattr(response, 'is_rendered', True) and callable(getattr(response, 'render', None)):
response = response.render()
return response
def process_exception(self, request, exception):
if request.user.is_superuser or request.META.get(
'REMOTE_ADDR') in settings.INTERNAL_IPS:
return technical_500_response(request, *sys.exc_info())
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
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
# Use a flag to check if the response was rendered to prevent
# multiple renderings or to force rendering if necessary.
response_is_rendered = False
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
set_urlconf(urlconf)
resolver = get_resolver(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:
response = self.process_exception_by_middleware(e, request)
# 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. It returned None instead."
% (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)
# Complain if the template response middleware returned None (a common error).
if response is None:
raise ValueError(
"%s.process_template_response didn't return an "
"HttpResponse object. It returned None instead." %
(middleware_method.__self__.__class__.__name__))
try:
response = response.render()
except Exception as e:
response = self.process_exception_by_middleware(e, request)
response_is_rendered = True
except http.Http404 as exc:
logger.warning('Not Found: %s',
request.path,
extra={
'status_code': 404,
'request': request
})
if settings.DEBUG:
response = debug.technical_404_response(request, exc)
else:
response = self.get_exception_response(request, resolver, 404,
exc)
except PermissionDenied as exc:
logger.warning('Forbidden (Permission denied): %s',
request.path,
extra={
'status_code': 403,
'request': request
})
response = self.get_exception_response(request, resolver, 403, exc)
except MultiPartParserError as exc:
logger.warning('Bad request (Unable to parse request body): %s',
request.path,
extra={
'status_code': 400,
'request': request
})
response = self.get_exception_response(request, resolver, 400, exc)
except SuspiciousOperation as exc:
# The request logger receives events for any problematic request
# The security logger receives events for all SuspiciousOperations
security_logger = logging.getLogger('django.security.%s' %
exc.__class__.__name__)
security_logger.error(force_text(exc),
extra={
'status_code': 400,
'request': request
})
if settings.DEBUG:
return debug.technical_500_response(request,
*sys.exc_info(),
status_code=400)
response = self.get_exception_response(request, resolver, 400, exc)
except SystemExit:
# Allow sys.exit() to actually exit. See tickets #1023 and #4701
raise
except Exception: # 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)
# Complain if the response middleware returned None (a common error).
if response is None:
raise ValueError(
"%s.process_response didn't return an "
"HttpResponse object. It returned None instead." %
(middleware_method.__self__.__class__.__name__))
response = self.apply_response_fixes(request, response)
except Exception: # 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())
response._closable_objects.append(request)
# If the exception handler returns a TemplateResponse that has not
# been rendered, force it to be rendered.
if not response_is_rendered and callable(
getattr(response, 'render', None)):
response = response.render()
return response
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)
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
elif settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
else:
# When DEBUG is False, send an error message to the admins.
subject = 'Error (%s IP): %s' % (
(request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS
and 'internal' or 'EXTERNAL'), request.path)
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
message = "%s\n\n%s" % (self._get_traceback(exc_info),
request_repr)
mail_admins(subject, message, fail_silently=True)
# Return an HttpResponse that displays a friendly error message.
callback, param_dict = resolver.resolve500()
return callback(request, **param_dict)
def handler500(request):
return debug.technical_500_response(request, *sys.exc_info())
def process_exception(self, request, exception):
print(request.META.get('REMOTE_ADDR'))
# if request.user.is_superuser or request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
if repr(request.META.get('REMOTE_ADDR')) == repr("127.0.0.1"): # 允许的ip
print("ahah")
return technical_500_response(request, *sys.exc_info())
def process_exception(self, request, exception):
# 对管理员展示错误页面，一般用户只能看到404 500等页面
ip = request.META.get('REMOTE_ADDR')
if ip == '127.0.0.1':
return technical_500_response(request, *sys.exc_info())
return redirect(reverse('App:errors'))
def server_error_display(request):
error_html = debug.technical_500_response(request, *sys.exc_info()).content
return HttpResponseServerError(error_html)
def __call__(self, request):
response = self.get_response(request)
if request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
return response
def process_exception(request: HttpRequest,
exception: Exception) -> HttpResponse:
if request.user.is_superuser:
return technical_500_response(request, *sys.exc_info())
def my_customized_server_error(request, template_name='500.html'):
import sys
from django.views import debug
error_html = debug.technical_500_response(request, *sys.exc_info()).content
return HttpResponseServerError(error_html)
def process_exception(self, request, exception):
ip = request.META.get('REMOTE_ADDR')
if ip == '127.0.0.1':
return technical_500_response(request, *sys.exc_info())
return redirect(reverse('film:index'))
def _build_html_response(request: HttpRequest,
debug_info_enabled: bool) -> HttpResponse:
if debug_info_enabled:
return technical_500_response(request, *sys.exc_info())
return server_error(request)