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)