Esempio n. 1
0
 def host(self):
     """Just the host including the port if available."""
     return get_host(self.environ)
 def host(self):
     """Just the host including the port if available."""
     return get_host(self.environ)
Esempio n. 3
0
    def open(self, *args, **kwargs):
        """Takes the same arguments as the :class:`EnvironBuilder` class with
        some additions:  You can provide a :class:`EnvironBuilder` or a WSGI
        environment as only argument instead of the :class:`EnvironBuilder`
        arguments and two optional keyword arguments (`as_tuple`, `buffered`)
        that change the type of the return value or the way the application is
        executed.

        .. versionchanged:: 0.5
           If a dict is provided as file in the dict for the `data` parameter
           the content type has to be called `content_type` now instead of
           `mimetype`.  This change was made for consistency with
           :class:`werkzeug.FileWrapper`.

            The `follow_redirects` parameter was added to :func:`open`.

        Additional parameters:

        :param as_tuple: Returns a tuple in the form ``(environ, result)``
        :param buffered: Set this to true to buffer the application run.
                         This will automatically close the application for
                         you as well.
        :param follow_redirects: Set this to True if the `Client` should
                                 follow HTTP redirects.
        """
        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])

        # handle redirects
        redirect_chain = []
        status_code = int(rv[1].split(None, 1)[0])
        while status_code in (301, 302, 303, 305, 307) and follow_redirects:
            redirect = dict(rv[2])['Location']
            host = get_host(create_environ('/', redirect))
            if get_host(environ).split(':', 1)[0] != host:
                raise RuntimeError('%r does not support redirect to '
                                   'external targets' % self.__class__)

            scheme, netloc, script_root, qs, anchor = urlparse.urlsplit(redirect)
            redirect_chain.append((redirect, status_code))

            kwargs.update({
                'base_url':         urlparse.urlunsplit((scheme, host,
                                    script_root, '', '')).rstrip('/') + '/',
                'query_string':     qs,
                'as_tuple':         as_tuple,
                'buffered':         buffered,
                'follow_redirects': False
            })
            rv = self.open(*args, **kwargs)
            status_code = int(rv[1].split(None, 1)[0])

            # Prevent loops
            if redirect_chain[-1] in redirect_chain[0:-1]:
                break

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