def get_response(self, request): # 产生最终响应
"""Return an HttpResponse object for the given HttpRequest."""
# Setup default url resolver for this thread
set_urlconf(settings.ROOT_URLCONF)
response = self._middleware_chain(request)
response._closable_objects.append(request)
# If the exception handler returns a TemplateResponse that has not
# been rendered, force it to be rendered.
if not getattr(response, 'is_rendered', True) and callable(
getattr(response, 'render', None)):
response = response.render()
if response.status_code == 404:
logger.warning(
'Not Found: %s',
request.path,
extra={
'status_code': 404,
'request': request
},
)
return response
def _django_set_urlconf(request):
"""Apply the @pytest.mark.urls marker, internal to pytest-django."""
marker = request.node.get_closest_marker("urls")
if marker:
skip_if_no_django()
import django.conf
try:
from django.urls import clear_url_caches, set_urlconf
except ImportError:
# Removed in Django 2.0
from django.core.urlresolvers import clear_url_caches, set_urlconf
urls = validate_urls(marker)
original_urlconf = django.conf.settings.ROOT_URLCONF
django.conf.settings.ROOT_URLCONF = urls
clear_url_caches()
set_urlconf(None)
def restore():
django.conf.settings.ROOT_URLCONF = original_urlconf
# Copy the pattern from
# https://github.com/django/django/blob/master/django/test/signals.py#L152
clear_url_caches()
set_urlconf(None)
request.addfinalizer(restore)
def process_request(self, request):
MULTISITE_CMS_URLS = getattr(settings, 'MULTISITE_CMS_URLS', {})
MULTISITE_CMS_ALIASES = getattr(settings, 'MULTISITE_CMS_ALIASES', {})
MULTISITE_CMS_FALLBACK = getattr(settings, 'MULTISITE_CMS_FALLBACK',
'')
try:
parsed = urlparse.urlparse(request.build_absolute_uri())
host = parsed.hostname.split(':')[0]
urlconf = None
try:
urlconf = MULTISITE_CMS_URLS[host]
except KeyError:
for domain, hosts in MULTISITE_CMS_ALIASES.items():
if host in hosts and domain in MULTISITE_CMS_URLS:
urlconf = MULTISITE_CMS_URLS[domain]
break
if (not urlconf and MULTISITE_CMS_FALLBACK
and MULTISITE_CMS_FALLBACK in MULTISITE_CMS_URLS.keys()):
urlconf = MULTISITE_CMS_URLS[MULTISITE_CMS_FALLBACK]
if urlconf:
request.urlconf = urlconf
# sets urlconf for current thread, so that code that does not know
# about the request (e.g MyModel.get_absolute_url()) get the correct
# urlconf.
set_urlconf(urlconf)
try:
# In django CMS 3.4.2 this allows us to save a few queries thanks to per-site appresolvers caching
reload_urlconf(clear_cache=False)
except TypeError:
reload_urlconf()
except KeyError:
# use default urlconf (settings.ROOT_URLCONF)
set_urlconf(None)
def handler500(request):
if hasattr(request, 'urlconf'):
urlconf = request.urlconf
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
else:
resolver = get_resolver()
resolver_match = resolver.resolve(request.path_info)
callback, callback_args, callback_kwargs = resolver_match
request.resolver_match = resolver_match
obj = base.BaseHandler
wrapped_callback = obj.make_view_atomic(obj, callback)
try:
response = wrapped_callback(request, *callback_args, **callback_kwargs)
except Exception as e:
exc_type, exc_value, tb = sys.exc_info()
reporter = ExceptionReporter(request, exc_type, exc_value, tb)
frames = reporter.get_traceback_frames()
traceback_string = ""
for frame in frames:
traceback_string += "({},{})".format(str(frame['lineno']),
str(frame['filename']))
logger.critical("|URL->| {} |ERROR->| {} |TRACEBACK->| {}".format(request,\
e, traceback_string))
return HttpResponse(status=500)
def process_view(self, request, view_func, view_args, view_kwargs):
request.is_appadmin = False
# the admin has to use localcosmos_server.urls to not conflict with the commercial installation
# online_content needs the correct urlconf
if '/app-admin/' in request.path:
request.is_appadmin = True
if 'app_uid' not in view_kwargs:
raise ImproperlyConfigured(
'all app-admin urls require app_uid as an url kwarg')
app = App.objects.get(uid=view_kwargs['app_uid'])
request.app = app
login_path = reverse('log_in')
if login_path not in request.path:
user = request.user
if not user.is_authenticated:
url = '{0}?next={1}'.format(reverse('log_in'),
request.path)
return redirect(url)
has_access = rules.test_rule('app_admin.has_access', user, app)
if not has_access:
raise PermissionDenied
request.urlconf = 'localcosmos_server.urls'
set_urlconf('localcosmos_server.urls')
return None
def get_response(self, request):
"""Return an HttpResponse object for the given HttpRequest.
1 设置 URLS 根文件
2 处理 Request
3 返回 reponse 实例(HttpResponse)
"""
# Setup default url resolver for this thread
# 1 URLS 根文件
set_urlconf(settings.ROOT_URLCONF)
# 2 middle chain中的第一个处理函数开始流失经过所有middle, 返回最终的response
response = self._middleware_chain(request)
# 3 返回最终的response, 不会空
response._closable_objects.append(request)
# If the exception handler returns a TemplateResponse that has not
# been rendered, force it to be rendered.
if not getattr(response, 'is_rendered', True) and callable(getattr(response, 'render', None)):
response = response.render()
# 4 记录日志信息
if response.status_code == 404:
logger.warning(
'Not Found: %s', request.path,
extra={'status_code': 404, 'request': request},
)
return response
def test_view_exception(self):
""""""
request = self.request_factory.request()
request.site = get_current_site(request)
request.user = get_user_object(TEST_USER_NAME)
request.META['QUERY_STRING'] = urlencode({
'pk': '999'
}, doseq=True)
response = select2_contenttypes_view(request, 'user')
# Should be http code server error as user is not exists
self.assertEqual(500, response.status_code)
self.assertEqual(500, json.loads(smart_text(response.content))['meta']['status'])
request.method = 'POST'
response = select2_contenttypes_view(request, 'user')
# Should be http code not permitted
self.assertEqual(405, response.status_code)
self.assertEqual(405, json.loads(smart_text(response.content))['meta']['status'])
# Test: authorization
request.user.is_superuser = False
request.user.is_staff = False
request.user.save()
request.method = 'GET'
# Manually Trigger Default Router Generation other than exception should be happen
DynamicRouteMiddleware().process_request(request)
# We are pushing newly generated url conf into current thread
set_urlconf(request.urlconf)
# Patch Done!
response = select2_contenttypes_view(request, 'user')
# Should Be Redirect to login page
self.assertEqual(302, response.status_code)
self.assertIn('admin/login', response.url)
def get_response(self, request):
"""Return an HttpResponse object for the given HttpRequest."""
# Setup default url resolver for this thread
set_urlconf(settings.ROOT_URLCONF)
response = self._middleware_chain(request)
response._closable_objects.append(request)
# If the exception handler returns a TemplateResponse that has not
# been rendered, force it to be rendered.
if not getattr(response, 'is_rendered', True) and callable(
getattr(response, 'render', None)):
response = response.render()
if response.status_code >= 400:
log_response(
'%s: %s',
response.reason_phrase,
request.path,
response=response,
request=request,
)
return response
def _django_set_host(request):
"""Apply the @pytest.mark.host marker, internal to pytest-django."""
marker = request.keywords.get('host', None)
print(marker)
if marker:
skip_if_no_django()
import django.conf
from django.urls import clear_url_caches, set_urlconf
from django_hosts.resolvers import clear_host_caches
# clear_host_caches
validate_host(marker)
original_urlconf = django.conf.settings.DEFAULT_HOST
django.conf.settings.DEFAULT_HOST = marker.args[0]
# django.conf.settings.DEFAULT_HOST = 'pashinin'
clear_host_caches()
set_urlconf(None)
def restore():
# django.conf.settings.ROOT_URLCONF = original_urlconf
django.conf.settings.DEFAULT_HOST = original_urlconf
# Copy the pattern from
# https://github.com/django/django/blob/master/django/test/signals.py#L152
clear_host_caches()
set_urlconf(None)
request.addfinalizer(restore)
def get_response(self, request):
"""Return an HttpResponse object for the given HttpRequest."""
# Setup default url resolver for this thread
set_urlconf(settings.ROOT_URLCONF)
response = self._middleware_chain(request)
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__))
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, get_resolver(get_urlconf()), 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 getattr(response, 'is_rendered', True) and callable(getattr(response, 'render', None)):
response = response.render()
if response.status_code == 404:
logger.warning(
'Not Found: %s', request.path,
extra={'status_code': 404, 'request': request},
)
return response
def handle(self, *args, **options):
site = ApplyHomePage.objects.first().get_site()
set_urlconf('hypha.apply.urls')
# Mock a HTTPRequest in order to pass the site settings into the
# templates
request = HttpRequest()
request.META['SERVER_NAME'] = site.hostname
request.META['SERVER_PORT'] = site.port
request.META[settings.SECURE_PROXY_SSL_HEADER] = 'https'
request.session = {}
request._messages = FallbackStorage(request)
today = timezone.now().date()
due_date = today + relativedelta(days=options['days_before'])
for project in Project.objects.in_progress():
next_report = project.report_config.current_due_report()
due_soon = next_report.end_date == due_date
not_notified_today = (not next_report.notified
or next_report.notified.date() != today)
if due_soon and not_notified_today:
messenger(
MESSAGES.REPORT_NOTIFY,
request=request,
user=None,
source=project,
related=next_report,
)
# Notify about the due report
next_report.notified = timezone.now()
next_report.save()
self.stdout.write(
self.style.SUCCESS(f'Notified project: {project.id}'))
def restore():
# django.conf.settings.ROOT_URLCONF = original_urlconf
django.conf.settings.DEFAULT_HOST = original_urlconf
# Copy the pattern from
# https://github.com/django/django/blob/master/django/test/signals.py#L152
clear_host_caches()
set_urlconf(None)
def test_site_apps(self):
"""Test that apps are only available inside their sites"""
page = Page.objects.create(
title="blog",
slug="blog",
static_path=False,
language_code="en",
is_active=True,
application="blog",
site=Site.objects.create(host="testserver2"),
)
a = Article.objects.create(title="article", category="blog")
# No urlconf.
self.assertRaises(NoReverseMatch, a.get_absolute_url)
# No apps on this site
with set_current_site(self.test_site):
self.assertEqual(apps_urlconf(), "testapp.urls")
# Apps on this site
with set_current_site(page.site):
self.assertEqual(apps_urlconf(),
"urlconf_01c07a48384868b2300536767c9879e2")
try:
set_urlconf("urlconf_01c07a48384868b2300536767c9879e2")
self.assertEqual(a.get_absolute_url(), "/blog/%s/" % a.pk)
finally:
set_urlconf(None)
def admin_register(self, model, admin_site):
"""Register an model with admin to the test case, test client and URL reversing code."""
self.admin_site.register(model, admin_site)
# Make sure the URLs are reachable by reverse()
clear_url_caches()
set_urlconf(tuple([path("tmp-admin/", self.admin_site.urls)]))
def setUp(self):
from django.urls import set_urlconf
set_urlconf("test_urls")
self.factory = RequestFactory()
self.request_200 = self.factory.get("/fine-thank-you")
self.response_200 = mock.MagicMock()
self.response_200.status_code = 200
self.response_200.get.return_value = "application/json"
if IS_DJANGO_VERSION_GTE_3_2_0:
self.response_200.headers = {"test_headers": "test_headers"}
else:
self.response_200._headers = {"test_headers": "test_headers"}
self.request_404 = self.factory.get("/not-a-valid-url")
self.response_404 = mock.MagicMock()
self.response_404.status_code = 404
self.response_404.get.return_value = "application/json"
if IS_DJANGO_VERSION_GTE_3_2_0:
self.response_404.headers = {"test_headers": "test_headers"}
else:
self.response_404._headers = {"test_headers": "test_headers"}
self.request_500 = self.factory.get("/bug")
self.response_500 = mock.MagicMock()
self.response_500.status_code = 500
self.response_500.get.return_value = "application/json"
if IS_DJANGO_VERSION_GTE_3_2_0:
self.response_500.headers = {"test_headers": "test_headers"}
else:
self.response_500._headers = {"test_headers": "test_headers"}
def _django_set_urlconf(request):
"""Apply the @pytest.mark.urls marker, internal to pytest-django."""
marker = request.node.get_closest_marker('urls')
if marker:
skip_if_no_django()
import django.conf
try:
from django.urls import clear_url_caches, set_urlconf
except ImportError:
# Removed in Django 2.0
from django.core.urlresolvers import clear_url_caches, set_urlconf
urls = validate_urls(marker)
original_urlconf = django.conf.settings.ROOT_URLCONF
django.conf.settings.ROOT_URLCONF = urls
clear_url_caches()
set_urlconf(None)
def restore():
django.conf.settings.ROOT_URLCONF = original_urlconf
# Copy the pattern from
# https://github.com/django/django/blob/master/django/test/signals.py#L152
clear_url_caches()
set_urlconf(None)
request.addfinalizer(restore)
def process_request(self, request):
# We try three options, in order of decreasing preference.
if settings.USE_X_FORWARDED_HOST and ('X-Forwarded-Host'
in request.headers):
host = request.headers['X-Forwarded-Host']
elif 'Host' in request.headers:
host = request.headers['Host']
else:
# Reconstruct the host using the algorithm from PEP 333.
host = request.META['SERVER_NAME']
server_port = str(request.META['SERVER_PORT'])
if server_port != ('443' if request.is_secure() else '80'):
host = '%s:%s' % (host, server_port)
domain, port = split_domain_port(host)
default_domain, default_port = split_domain_port(
urlparse(settings.SITE_URL).netloc)
request.port = int(port) if port else None
request.host = domain
if domain == default_domain:
request.urlconf = "pretix.multidomain.maindomain_urlconf"
elif domain:
cached = cache.get('pretix_multidomain_instance_{}'.format(domain))
if cached is None:
try:
kd = KnownDomain.objects.select_related(
'organizer', 'event').get(domainname=domain) # noqa
orga = kd.organizer
event = kd.event
except KnownDomain.DoesNotExist:
orga = False
event = False
cache.set('pretix_multidomain_instance_{}'.format(domain),
(orga, event), 3600)
else:
orga, event = cached
if event:
request.event_domain = True
request.organizer = orga if isinstance(
orga, Organizer) else Organizer.objects.get(pk=orga)
request.event = event if isinstance(
event, Event) else orga.events.get(pk=event)
request.urlconf = "pretix.multidomain.event_domain_urlconf"
elif orga:
request.organizer_domain = True
request.organizer = orga if isinstance(
orga, Organizer) else Organizer.objects.get(pk=orga)
request.urlconf = "pretix.multidomain.organizer_domain_urlconf"
elif settings.DEBUG or domain in LOCAL_HOST_NAMES:
request.urlconf = "pretix.multidomain.maindomain_urlconf"
else:
raise DisallowedHost("Unknown host: %r" % host)
else:
raise DisallowedHost("Invalid HTTP_HOST header: %r." % host)
# We need to manually set the urlconf for the whole thread. Normally, Django's basic request handling
# would do this for us, but we already need it in place for the other middlewares.
set_urlconf(request.urlconf)
def __call__(self, request):
if not getattr(_thread_local, 'enabled', True):
return
host = request.get_host()
# Find best match, falling back to settings.SUBDOMAIN_DEFAULT
for subdomain in settings.SUBDOMAINS.values():
match = subdomain['_regex'].match(host)
if match:
kwargs = match.groupdict()
break
else:
kwargs = {}
subdomain = self.default
urlconf = subdomain['urlconf']
callback = subdomain['_callback']
request.urlconf = urlconf
try:
set_urlconf(urlconf)
response_from_callback = callback(request, **kwargs)
finally:
set_urlconf(None)
return response_from_callback or self.get_response(request)
def handle(self, *args, **options):
site = ApplyHomePage.objects.first().get_site()
set_urlconf('hypha.apply.urls')
# Mock a HTTPRequest in order to pass the site settings into the
# templates
request = HttpRequest()
request.META['SERVER_NAME'] = site.hostname
request.META['SERVER_PORT'] = site.port
request.META[settings.SECURE_PROXY_SSL_HEADER] = 'https'
request.session = {}
request._messages = FallbackStorage(request)
for reminder in Reminder.objects.filter(sent=False,
time__lte=timezone.now()):
messenger(
reminder.action_message,
request=request,
user=None,
source=reminder.submission,
related=reminder,
)
self.stdout.write(
self.style.SUCCESS(f'Reminder sent: {reminder.id}'))
reminder.sent = True
reminder.save()
def admin_register(self, model, admin_site):
"""Register an model with admin to the test case, test client and URL reversing code."""
self.admin_site.register(model, admin_site)
# Make sure the URLs are reachable by reverse()
clear_url_caches()
set_urlconf(tuple([
url('^tmp-admin/', self.admin_site.urls)
]))
def _get_response(self, request):
response = None
if hasattr(request, 'urlconf'):
urlconf = request.urlconf
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
else:
resolver = get_resolver()
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:
return response
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
elif 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)
return response
def process_request(self, request):
domain = self._get_domain(request)
urlconf = self._get_urlconf(domain)
# sets urlconf for current thread, so that code that does not know
# about the request (e.g MyModel.get_absolute_url()) get the correct
# urlconf.
# urlconf might be None, in that case, the default is set
set_urlconf(urlconf)
reload_urlconf()
def _get_response(self, request):
response = None
if hasattr(request, 'urlconf'):
urlconf = request.urlconf
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
else:
resolver = get_resolver()
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:
return response
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
elif 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)
return response
def __getData(self, requestData):
if '_links' in requestData:
urlconf = settings.ROOT_URLCONF
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
for prop, url in requestData['_links'].items():
requestData[prop] = self.__getObjectForUrl(url, resolver)
del requestData['_links']
return requestData
def test_prefix_url_middleware_starts_with_known_url(rf, settings, url,
expected):
set_urlconf('tests.urls_prefixed')
request = rf.get(url)
response = PrefixUrlMiddleware().process_request(request)
assert response.status_code == 302
assert response.url == expected
def test_override_urlconf_when_exception(current, override):
set_urlconf(current)
assert get_urlconf() == current
try:
with override_urlconf(override):
assert get_urlconf() == override
raise Exception('something went wrong')
except Exception as err:
assert str(err) == 'something went wrong'
assert get_urlconf() == current
def process_request(self, request):
# Short circuit if tenant is already set by another middleware.
# This allows for multiple tenant-resolving middleware chained together.
if hasattr(request, "tenant"):
return
connection.set_schema_to_public()
tenant = None
urlconf = None
TenantModel = get_tenant_model()
hostname = self.hostname_from_request(request)
subfolder_prefix_path = "/{}/".format(get_subfolder_prefix())
# We are in the public tenant
if not request.path.startswith(subfolder_prefix_path):
try:
tenant = TenantModel.objects.get(
schema_name=get_public_schema_name())
except TenantModel.DoesNotExist:
raise self.TENANT_NOT_FOUND_EXCEPTION(
"Unable to find public tenant")
# Do we have a public-specific urlconf?
if (hasattr(settings, "PUBLIC_SCHEMA_URLCONF")
and tenant.schema_name == get_public_schema_name()):
urlconf = settings.PUBLIC_SCHEMA_URLCONF
# We are in a specific tenant
else:
path_chunks = request.path[len(subfolder_prefix_path):].split("/")
tenant_subfolder = path_chunks[0]
try:
tenant = TenantModel.objects.get(
domains__domain=tenant_subfolder)
except TenantModel.DoesNotExist:
raise self.TENANT_NOT_FOUND_EXCEPTION(
'No tenant for subfolder "%s"' % (tenant_subfolder or ""))
tenant.domain_subfolder = tenant_subfolder
urlconf = get_subfolder_urlconf(tenant)
tenant.domain_url = hostname
request.tenant = tenant
connection.set_tenant(request.tenant)
clear_url_caches(
) # Required to remove previous tenant prefix from cache, if present
if urlconf:
request.urlconf = urlconf
set_urlconf(urlconf)
def test_prefix_url_middleware_starts_with_known_url_domain_set(
rf, settings, url, expected):
settings.URL_PREFIX_DOMAIN = 'http://foo.com'
set_urlconf('tests.urls_prefixed')
request = rf.get(url)
response = PrefixUrlMiddleware().process_request(request)
assert response.status_code == 302
assert response.url == expected
def test_prefix_url_middleware_starts_with_known_url_correct_domain(
rf, settings, url):
settings.URL_PREFIX_DOMAIN = 'http://foo.com'
set_urlconf('tests.urls_prefixed')
request = rf.get(url, HTTP_HOST='foo.com')
response = PrefixUrlMiddleware().process_request(request)
assert response is None
def _get_response(self, request):
"""
Resolve and call the view, then apply view, exception, and
template_response middleware. This method is everything that happens
inside the request/response middleware.
"""
response = None
if hasattr(request, 'urlconf'):
urlconf = request.urlconf
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
else:
resolver = get_resolver()
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).
self.check_response(response, callback)
# 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).
self.check_response(
response,
middleware_method,
name='%s.process_template_response' %
(middleware_method.__self__.__class__.__name__, ))
try:
response = response.render()
except Exception as e:
response = self.process_exception_by_middleware(e, request)
return response
def __call__(self, request):
hostname = remove_www(request.get_host().split(":")[0])
connection.set_schema_to_public()
tenant = None
# Checking for static tenants
for schema, data in settings.TENANTS.items():
if schema in ["public", "default"]:
continue
if hostname in data["DOMAINS"]:
tenant = SchemaDescriptor.create(schema_name=schema, domain_url=hostname)
break
# Checking for dynamic tenants
else:
DomainModel = get_domain_model()
prefix = request.path.split("/")[1]
try:
domain = DomainModel.objects.select_related("tenant").get(domain=hostname, folder=prefix)
except DomainModel.DoesNotExist:
try:
domain = DomainModel.objects.select_related("tenant").get(domain=hostname, folder="")
except DomainModel.DoesNotExist:
domain = None
if domain:
tenant = domain.tenant
tenant.domain_url = hostname
tenant.folder = None
request.strip_tenant_from_path = lambda x: x
if prefix and domain.folder == prefix:
tenant.folder = prefix
request.strip_tenant_from_path = lambda x: re.sub(r"^/{}/".format(prefix), "/", x)
clear_url_caches() # Required to remove previous tenant prefix from cache (#8)
# Checking fallback domains
if not tenant:
for schema, data in settings.TENANTS.items():
if schema in ["public", "default"]:
continue
if hostname in data.get("FALLBACK_DOMAINS", []):
tenant = SchemaDescriptor.create(schema_name=schema, domain_url=hostname)
break
# No tenant found from domain / folder
if not tenant:
raise self.TENANT_NOT_FOUND_EXCEPTION("No tenant for hostname '%s'" % hostname)
request.tenant = tenant
urlconf = get_urlconf_from_schema(tenant)
request.urlconf = urlconf
set_urlconf(urlconf)
connection.set_schema(tenant)
return self.get_response(request)
def override_urlconf(new_urlconf):
"""
Context manager for temporarily overriding the urlconf for the current
thread.
"""
original_urlconf = get_urlconf()
set_urlconf(new_urlconf)
try:
yield
finally:
set_urlconf(original_urlconf)
def get_view_from_request_or_none(request):
try:
if hasattr(request, 'urlconf'):
urlconf = request.urlconf
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
else:
resolver = get_resolver()
return resolver.resolve(request.path_info)[0]
except Resolver404:
return None
def test_using_not_default_urlconf(self):
# Ensure that changing the currently active URLconf to something other
# than the default still resolves wildcard subdomains correctly.
set_urlconf(self.get_path_to_urlconf('api'))
subdomain = 'wildcard'
# This will raise NoReverseMatch if we're using the wrong URLconf for
# the provided subdomain.
self.assertEqual(reverse('application', subdomain=subdomain),
'http://%s.%s/application/' % (subdomain, self.DOMAIN))
def reload_django_url_config():
"""
Reloads Django's URL config.
This is useful, for example, when a test enables new URLs
with a django setting and the URL config needs to be refreshed.
"""
urlconf = settings.ROOT_URLCONF
if urlconf and urlconf in sys.modules:
reload(sys.modules[urlconf])
reloaded = import_module(urlconf)
reloaded_urls = reloaded.urlpatterns
set_urlconf(tuple(reloaded_urls))
def reload_django_url_config():
"""
Reloads Django's URL config.
This is useful, for example, when a test enables new URLs
with a django setting and the URL config needs to be refreshed.
"""
urlconf = settings.ROOT_URLCONF
if urlconf and urlconf in sys.modules:
reload(sys.modules[urlconf])
reloaded = import_module(urlconf)
reloaded_urls = reloaded.urlpatterns
set_urlconf(tuple(reloaded_urls))
def get_response(self, request):
"""Return an HttpResponse object for the given HttpRequest."""
# Setup default url resolver for this thread
set_urlconf(settings.ROOT_URLCONF)
response = self._middleware_chain(request)
response._closable_objects.append(request)
if response.status_code >= 400:
log_response(
'%s: %s', response.reason_phrase, request.path,
response=response,
request=request,
)
return response
def process_request(self, request):
# Find best match, falling back to settings.DEFAULT_HOST
host, kwargs = self.get_host(request.get_host())
# This is the main part of this middleware
request.urlconf = host.urlconf
request.host = host
# But we have to temporarily override the URLconf
# already to allow correctly reversing host URLs in
# the host callback, if needed.
current_urlconf = get_urlconf()
try:
set_urlconf(host.urlconf)
return host.callback(request, **kwargs)
finally:
# Reset URLconf for this thread on the way out for complete
# isolation of request.urlconf
set_urlconf(current_urlconf)
def process_response(self, request, response):
# Django resets the base urlconf when it starts to process
# the response, so we need to set this again, in case
# any of our middleware makes use of host, etc URLs.
# Find best match, falling back to settings.DEFAULT_HOST
try:
host, kwargs = self.get_host(request.get_host())
except DisallowedHost:
# Bail out early, there is nothing to reset as HostsRequestMiddleware
# never gets called with an invalid host.
return response
# This is the main part of this middleware
request.urlconf = host.urlconf
request.host = host
set_urlconf(host.urlconf)
return response
def process_request(self, request):
# We try three options, in order of decreasing preference.
if settings.USE_X_FORWARDED_HOST and ('HTTP_X_FORWARDED_HOST' in request.META):
host = request.META['HTTP_X_FORWARDED_HOST']
elif 'HTTP_HOST' in request.META:
host = request.META['HTTP_HOST']
else:
# Reconstruct the host using the algorithm from PEP 333.
host = request.META['SERVER_NAME']
server_port = str(request.META['SERVER_PORT'])
if server_port != ('443' if request.is_secure() else '80'):
host = '%s:%s' % (host, server_port)
domain, port = split_domain_port(host)
default_domain, default_port = split_domain_port(urlparse(settings.SITE_URL).netloc)
if domain:
request.host = domain
request.port = int(port) if port else None
orga = cache.get('pretix_multidomain_organizer_instance_{}'.format(domain))
if orga is None:
try:
kd = KnownDomain.objects.select_related('organizer').get(domainname=domain) # noqa
orga = kd.organizer
except KnownDomain.DoesNotExist:
orga = False
cache.set('pretix_multidomain_organizer_instance_{}'.format(domain), orga, 3600)
if orga:
request.organizer_domain = True
request.organizer = orga if isinstance(orga, Organizer) else Organizer.objects.get(pk=orga)
request.urlconf = "pretix.multidomain.subdomain_urlconf"
else:
if settings.DEBUG or domain in LOCAL_HOST_NAMES or domain == default_domain:
request.urlconf = "pretix.multidomain.maindomain_urlconf"
else:
raise DisallowedHost("Unknown host: %r" % host)
else:
raise DisallowedHost("Invalid HTTP_HOST header: %r." % host)
# We need to manually set the urlconf for the whole thread. Normally, Django's basic request
# would do this for us, but we already need it in place for the other middlewares.
set_urlconf(request.urlconf)
def reset_urlconf():
"""
Reset the default urlconf used by "reverse" to the one provided
by settings.ROOT_URLCONF.
Django resets the default urlconf back to settings.ROOT_URLCONF at
the beginning of each request, but if the incoming request has a
"urlconf" attribute, the default urlconf is changed to its value for
the remainder of the request, so that all subsequent "reverse" calls
use that value (unless they explicitly specify a different one). The
problem occurs when a test is run that uses the "request.urlconf"
mechanism, setting the default urlconf to something other than
settings.ROOT_URLCONF, and then subsequent tests make "reverse" calls
that fail because they're expecting a default urlconf of
settings.ROOT_URLCONF (i.e., they're not explicitly providing a
urlconf value to the "reverse" call).
"""
set_urlconf(None)
yield
set_urlconf(None)
def get_response(self, request):
"""Return an HttpResponse object for the given HttpRequest."""
# Setup default url resolver for this thread
set_urlconf(settings.ROOT_URLCONF)
response = self._middleware_chain(request)
response._closable_objects.append(request)
# If the exception handler returns a TemplateResponse that has not
# been rendered, force it to be rendered.
if not getattr(response, 'is_rendered', True) and callable(getattr(response, 'render', None)):
response = response.render()
if response.status_code == 404:
logger.warning(
'Not Found: %s', request.path,
extra={'status_code': 404, 'request': request},
)
return response
def tearDown(self):
clear_url_caches()
set_urlconf(None)
def tearDownClass(cls):
# cleanup URLconfs changed by django-hosts
set_urlconf(None)
super().tearDownClass()
def restore():
django.conf.settings.ROOT_URLCONF = original_urlconf
# Copy the pattern from
# https://github.com/django/django/blob/master/django/test/signals.py#L152
clear_url_caches()
set_urlconf(None)
def test_override_urlconf(current, override):
set_urlconf(current)
assert get_urlconf() == current
with override_urlconf(override):
assert get_urlconf() == override
assert get_urlconf() == current
def reset_urlconf(sender, **kwargs):
"""Reset the URLconf after each request is finished."""
set_urlconf(None)
def root_urlconf_changed(**kwargs):
if kwargs['setting'] == 'ROOT_URLCONF':
from django.urls import clear_url_caches, set_urlconf
clear_url_caches()
set_urlconf(None)
def get_response(self, request: HttpRequest) -> HttpResponse:
"Returns an HttpResponse object for the given HttpRequest"
try:
try:
# Setup default url resolver for this thread.
urlconf = settings.ROOT_URLCONF
set_urlconf(urlconf)
resolver = resolvers.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
set_urlconf(urlconf)
resolver = resolvers.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 view_middleware_method in self._view_middleware:
response = view_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_timer_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 exception_middleware_method in self._exception_middleware:
response = exception_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 template_middleware_method in self._template_response_middleware:
response = template_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 Exception:
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 Exception:
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:
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
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 tearDownClass(cls):
super(AdminTestCase, cls).tearDownClass()
clear_url_caches()
set_urlconf(None)
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
def _clear_urlconf():
clear_url_caches()
set_urlconf(None)
