Python wsgi.get_host函数代码示例

 def test_get_host_multiple_forwarded(self):
     env = {'HTTP_X_FORWARDED_HOST': 'example.com, example.org',
            'SERVER_NAME': 'bullshit', 'HOST_NAME': 'ignore me dammit'}
     self.assert_equal(wsgi.get_host(env), 'example.com')
     self.assert_equal(
         wsgi.get_host(create_environ('/', 'http://example.com')),
         'example.com')

def test_get_host():
    """Host lookup"""
    env = {'HTTP_X_FORWARDED_HOST': 'example.org',
           'SERVER_NAME': 'bullshit', 'HOST_NAME': 'ignore me dammit'}
    assert get_host(env) == 'example.org'
    assert get_host(create_environ('/', 'http://example.org')) \
        == 'example.org'

 def test_get_host_multiple_forwarded(self):
     env = {
         "HTTP_X_FORWARDED_HOST": "example.com, example.org",
         "SERVER_NAME": "bullshit",
         "HOST_NAME": "ignore me dammit",
     }
     self.assert_equal(wsgi.get_host(env), "example.com")
     self.assert_equal(wsgi.get_host(create_environ("/", "http://example.com")), "example.com")

 def test_get_host_fallback(self):
     self.assert_equal(
         wsgi.get_host({"SERVER_NAME": "foobar.example.com", "wsgi.url_scheme": "http", "SERVER_PORT": "80"}),
         "foobar.example.com",
     )
     self.assert_equal(
         wsgi.get_host({"SERVER_NAME": "foobar.example.com", "wsgi.url_scheme": "http", "SERVER_PORT": "81"}),
         "foobar.example.com:81",
     )

def test_get_host_fallback():
    assert (
        wsgi.get_host({"SERVER_NAME": "foobar.example.com", "wsgi.url_scheme": "http", "SERVER_PORT": "80"})
        == "foobar.example.com"
    )
    assert (
        wsgi.get_host({"SERVER_NAME": "foobar.example.com", "wsgi.url_scheme": "http", "SERVER_PORT": "81"})
        == "foobar.example.com:81"
    )

def test_get_host_validate_trusted_hosts():
    env = {"SERVER_NAME": "example.org", "SERVER_PORT": "80", "wsgi.url_scheme": "http"}
    assert wsgi.get_host(env, trusted_hosts=[".example.org"]) == "example.org"
    pytest.raises(BadRequest, wsgi.get_host, env, trusted_hosts=["example.com"])
    env["SERVER_PORT"] = "8080"
    assert wsgi.get_host(env, trusted_hosts=[".example.org:8080"]) == "example.org:8080"
    pytest.raises(BadRequest, wsgi.get_host, env, trusted_hosts=[".example.com"])
    env = {"HTTP_HOST": "example.org", "wsgi.url_scheme": "http"}
    assert wsgi.get_host(env, trusted_hosts=[".example.org"]) == "example.org"
    pytest.raises(BadRequest, wsgi.get_host, env, trusted_hosts=["example.com"])

    def open(self, *args, **kwargs):
        as_tuple = kwargs.pop('as_tuple', False)
        buffered = kwargs.pop('buffered', False)
        follow_redirects = kwargs.pop('follow_redirects', False)
        environ = None
        if not kwargs and len(args) == 1:
            if isinstance(args[0], EnvironBuilder):
                environ = args[0].get_environ()
            elif isinstance(args[0], dict):
                environ = args[0]
        if environ is None:
            builder = EnvironBuilder(*args, **kwargs)
            try:
                environ = builder.get_environ()
            finally:
                builder.close()

        if self.cookie_jar is not None:
            self.cookie_jar.inject_wsgi(environ)
        rv = run_wsgi_app(self.application, environ, buffered=buffered)
        if self.cookie_jar is not None:
            self.cookie_jar.extract_wsgi(environ, rv[2])
        redirect_chain = []
        status_code = int(rv[1].split(None, 1)[0])
        while status_code in (301, 302, 303, 305, 307) and follow_redirects:
            if not self.redirect_client:
                self.redirect_client = Client(self.application)
                self.redirect_client.cookie_jar = self.cookie_jar
            redirect = dict(rv[2])['Location']
            scheme, netloc, script_root, qs, anchor = urlparse.urlsplit(redirect)
            base_url = urlparse.urlunsplit((scheme,
             netloc,
             '',
             '',
             '')).rstrip('/') + '/'
            host = get_host(create_environ('/', base_url, query_string=qs)).split(':', 1)[0]
            if get_host(environ).split(':', 1)[0] != host:
                raise RuntimeError('%r does not support redirect to external targets' % self.__class__)
            redirect_chain.append((redirect, status_code))
            redirect_kwargs = {}
            redirect_kwargs.update({'path': script_root,
             'base_url': base_url,
             'query_string': qs,
             'as_tuple': True,
             'buffered': buffered,
             'follow_redirects': False})
            environ, rv = self.redirect_client.open(**redirect_kwargs)
            status_code = int(rv[1].split(None, 1)[0])
            if redirect_chain[-1] in redirect_chain[0:-1]:
                raise ClientRedirectError('loop detected')

        response = self.response_wrapper(*rv)
        if as_tuple:
            return (environ, response)
        return response

def test_get_host_fallback():
    assert wsgi.get_host({
        'SERVER_NAME':      'foobar.example.com',
        'wsgi.url_scheme':  'http',
        'SERVER_PORT':      '80'
    }) == 'foobar.example.com'
    assert wsgi.get_host({
        'SERVER_NAME':      'foobar.example.com',
        'wsgi.url_scheme':  'http',
        'SERVER_PORT':      '81'
    }) == 'foobar.example.com:81'

 def test_get_host_fallback(self):
     self.assert_equal(wsgi.get_host({
         'SERVER_NAME':      'foobar.example.com',
         'wsgi.url_scheme':  'http',
         'SERVER_PORT':      '80'
     }), 'foobar.example.com')
     self.assert_equal(wsgi.get_host({
         'SERVER_NAME':      'foobar.example.com',
         'wsgi.url_scheme':  'http',
         'SERVER_PORT':      '81'
     }), 'foobar.example.com:81')

def test_get_host_fallback():
    """Test non Host header server name guessing"""
    assert get_host({
        'SERVER_NAME':      'foobar.example.com',
        'wsgi.url_scheme':  'http',
        'SERVER_PORT':      '80'
    }) == 'foobar.example.com'
    assert get_host({
        'SERVER_NAME':      'foobar.example.com',
        'wsgi.url_scheme':  'http',
        'SERVER_PORT':      '81'
    }) == 'foobar.example.com:81'

def test_get_host_validate_trusted_hosts():
    env = {'SERVER_NAME': 'example.org', 'SERVER_PORT': '80',
           'wsgi.url_scheme': 'http'}
    assert wsgi.get_host(env, trusted_hosts=['.example.org']) == 'example.org'
    pytest.raises(BadRequest, wsgi.get_host, env,
                  trusted_hosts=['example.com'])
    env['SERVER_PORT'] = '8080'
    assert wsgi.get_host(env, trusted_hosts=['.example.org:8080']) == 'example.org:8080'
    pytest.raises(BadRequest, wsgi.get_host, env,
                  trusted_hosts=['.example.com'])
    env = {'HTTP_HOST': 'example.org', 'wsgi.url_scheme': 'http'}
    assert wsgi.get_host(env, trusted_hosts=['.example.org']) == 'example.org'
    pytest.raises(BadRequest, wsgi.get_host, env,
                  trusted_hosts=['example.com'])

    def resolve_redirect(self, response, new_location, environ, buffered=False):
        """Resolves a single redirect and triggers the request again
        directly on this redirect client.
        """
        scheme, netloc, script_root, qs, anchor = url_parse(new_location)
        base_url = url_unparse((scheme, netloc, "", "", "")).rstrip("/") + "/"

        cur_server_name = netloc.split(":", 1)[0].split(".")
        real_server_name = get_host(environ).rsplit(":", 1)[0].split(".")

        if self.allow_subdomain_redirects:
            allowed = cur_server_name[-len(real_server_name) :] == real_server_name
        else:
            allowed = cur_server_name == real_server_name

        if not allowed:
            raise RuntimeError("%r does not support redirect to " "external targets" % self.__class__)

        # For redirect handling we temporarily disable the response
        # wrapper.  This is not threadsafe but not a real concern
        # since the test client must not be shared anyways.
        old_response_wrapper = self.response_wrapper
        self.response_wrapper = None
        try:
            return self.open(path=script_root, base_url=base_url, query_string=qs, as_tuple=True, buffered=buffered)
        finally:
            self.response_wrapper = old_response_wrapper

 def test_get_host_validation(self):
     env = {'HTTP_X_FORWARDED_HOST': 'example.org',
            'SERVER_NAME': 'bullshit', 'HOST_NAME': 'ignore me dammit'}
     self.assert_equal(wsgi.get_host(env, trusted_hosts=['.example.org']),
                       'example.org')
     self.assert_raises(BadRequest, wsgi.get_host, env,
                        trusted_hosts=['example.com'])

def dispatcher(environ, start_response, handlers={'conf': conf_app}):
	host = drop_last(get_host(environ))
	
	if not os.path.exists(os.path.join(BASE_DIR, host)):
		if host in handlers:
			del handlers[host]
		return error_app(environ, start_response)

	if host in handlers:
		return handlers[host]()(environ, start_response)

	if is_django(host):
		app = make_django_app(host)
	else:
		app = forwarding_app
		make_apache_confs(host)

	handlers[host] = app
	return app()(environ, start_response)

    def resolve_redirect(self, response, new_location, environ, buffered=False):
        """Resolves a single redirect and triggers the request again
        directly on this redirect client.
        """
        scheme, netloc, script_root, qs, anchor = url_parse(new_location)
        base_url = url_unparse((scheme, netloc, '', '', '')).rstrip('/') + '/'

        cur_server_name = netloc.split(':', 1)[0].split('.')
        real_server_name = get_host(environ).rsplit(':', 1)[0].split('.')
        if cur_server_name == ['']:
            # this is a local redirect having autocorrect_location_header=False
            cur_server_name = real_server_name
            base_url = EnvironBuilder(environ).base_url

        if self.allow_subdomain_redirects:
            allowed = cur_server_name[-len(real_server_name):] == real_server_name
        else:
            allowed = cur_server_name == real_server_name

        if not allowed:
            raise RuntimeError('%r does not support redirect to '
                               'external targets' % self.__class__)

        status_code = int(response[1].split(None, 1)[0])
        if status_code == 307:
            method = environ['REQUEST_METHOD']
        else:
            method = 'GET'

        # For redirect handling we temporarily disable the response
        # wrapper.  This is not threadsafe but not a real concern
        # since the test client must not be shared anyways.
        old_response_wrapper = self.response_wrapper
        self.response_wrapper = None
        try:
            return self.open(path=script_root, base_url=base_url,
                             query_string=qs, as_tuple=True,
                             buffered=buffered, method=method)
        finally:
            self.response_wrapper = old_response_wrapper