Python Request.get_response方法代码示例

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def wsgi_app(self, environ, start_response):
        self.host_framework.start_request(environ)
        environ['paste.registry'].register(tw.framework, self.host_framework)
        #XXX Do we really need to stuff these in environ?
        environ['toscawidgets.prefix'] = self.prefix
        environ.setdefault('toscawidgets.framework', self.host_framework)
        environ.setdefault('toscawidgets.javascript.require_once', self.require_once)

        req = Request(environ)
        try:
            tw.framework.script_name = req.script_name
            if self.serve_resources and req.path_info.startswith(self.prefix):
                # Intercept request to possibly serve a static resource
                req.path_info = req.path_info[len(self.prefix):]
                req.script_name += self.prefix
                resources_app = resources.registry
                if req.path_info.startswith(resources_app.prefix):
                    req.path_info = req.path_info[len(resources_app.prefix):]
                    req.script_name += resources_app.prefix
                    resp = req.get_response(resources_app)
                    return resp(environ, start_response)
            else:
                # Pass request downstream
                resp = req.get_response(self.application)
            return resp(environ, start_response)
        finally:
            self.host_framework.end_request(environ)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        request = Request(environ)
        session = environ['beaker.session']
        csrf_token = session.get('csrf')
        if not csrf_token:
            csrf_token = session['csrf'] = str(random.getrandbits(128))
            session.save()

        if request.method == 'POST':
            # check to see if we want to process the post at all
            if (self.unprotected_path is not None
                and request.path_info.startswith(self.unprotected_path)):
                resp = request.get_response(self.app)
                resp.headers['X-Frame-Options'] = 'SAMEORIGIN'
                resp.set_cookie('csrf', csrf_token, max_age=3600)
                return resp(environ, start_response)

            # check incoming token
            try:
                account_data = request.POST.get('account', None)
                request_csrf_token = environ.get('HTTP_X_CSRF', request.POST.get('csrftoken'))
                if account_data is None and request_csrf_token != csrf_token:
                    resp = HTTPForbidden(_ERROR_MSG)
                    metrics.track(request, 'invalid-session')
                    resp.headers['X-Error'] = 'CSRF'
                else:
                    resp = request.get_response(self.app)
            except KeyError:
                resp = HTTPForbidden(_ERROR_MSG)
                resp.headers['X-Error'] = 'CSRF'
        # if we're a get, we don't do any checking
        else:
            resp = request.get_response(self.app)

        if resp.status_int != 200:
            return resp(environ, start_response)

        resp.headers['X-Frame-Options'] = 'SAMEORIGIN'
        resp.set_cookie('csrf', csrf_token, max_age=3600)

        if resp.content_type.split(';')[0] in _HTML_TYPES:
            # ensure we don't add the 'id' attribute twice (HTML validity)
            idattributes = itertools.chain(('id="csrfmiddlewaretoken"',),
                                            itertools.repeat(''))
            def add_csrf_field(match):
                """Returns the matched <form> tag plus the added <input> element"""
                return match.group() + '<div style="display:none;">' + \
                '<input type="hidden" ' + idattributes.next() + \
                ' name="csrftoken" value="' + csrf_token + \
                '" /></div>'

            # Modify any POST forms and fix content-length
            resp.body = _POST_FORM_RE.sub(add_csrf_field, resp.body)

        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
 def m(environ, start_response):
     count = 1
     request = Request(environ)
     response = request.get_response(app)
     while response.status_int in REDIR_STATUS and count < limit:
         request = Request.blank(response.headers["Location"],
                                 environ={k: v for k, v in request.environ.items() \
                                          if k not in ENV_PATH_KEYS})
         response = request.get_response(app)
         count += 1
     else:
         return response(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
def middleware(environ, start_response):
    request = Request(environ).copy()

    response = request.get_response(django)

    if response.status_int != 305:
        return response(environ, start_response)
    data = json.loads(response.body)

    proxy = RemoteProxy([data['base_url']], rewrite_links=True)

    request.environ.pop("HTTP_ACCEPT_ENCODING", None)

    request.environ['SCRIPT_NAME'] = str(data['script_name']).rstrip("/")
    request.environ['PATH_INFO'] = "/" + str(data['path_info'].lstrip("/") )

    from Cookie import SimpleCookie as Cookie
    orig_cookie = cookie = request.environ.get('HTTP_COOKIE')
    if cookie:
        cookie = Cookie(cookie)
        for key in data['cookie_blacklist']:
            cookie.pop(key, None)
        cookiestr = []
        for key, value in cookie.items():
            cookiestr.append(value.OutputString())
        cookiestr = "; ".join(cookiestr)
        request.environ['HTTP_COOKIE'] = cookiestr

    request.environ['HTTP_X_THING_THEME'] = data['theme']

    filter = deliverance(proxy)

    def per_project_theme(environ):
        return "%(wsgi.url_scheme)s://%(HTTP_HOST)s%(HTTP_X_THING_THEME)s" % environ
    filter.default_theme = per_project_theme
    filter.rule_getter = TemplateRuleGetter(data['deliverance_rules'])
    filter.use_internal_subrequest = lambda *args, **kw: False

    base_subrequest = filter.build_external_subrequest
    def build_external_subrequest(url, orig_req, log):
        subreq = base_subrequest(url, orig_req, log)
        if url.endswith("/theme/") and orig_cookie:
            subreq.environ['HTTP_COOKIE'] = orig_cookie
        return subreq
    filter.build_external_subrequest = build_external_subrequest

    resp = request.get_response(filter)

    return resp(request.environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     sess = self.session_factory(req)
     req.environ[self.environ_key] = sess
     resp = req.get_response(self.app)
     sess.response_callback(req, resp)
     return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     res = req.get_response(self.app)
     if res.status_int == 200 and res.content_type == "text/plain":
         res.content_type = "text/html"
         res.body = "<pre>%s</pre>" % cgi.escape(res.body)
     return res(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        port = 80
        hostname = environ.get('HTTP_HOST', '')
        if ":" in hostname:
            hostname, port = hostname.split(':', 1)

        # nothing configure for this host bail out
        if hostname not in self._config:
            return self.app(environ, start_response)

        request = Request(environ)
        no_redirect_param = request.GET.get(self.no_redirect_param_name)
        no_redirect_cookie = request.cookies.get(self.no_redirect_param_name)

        force_no_redirect = no_redirect_param or no_redirect_cookie

        # mobi.devices middleware has tagged it as mobile
        if request.method == 'GET' and self.is_mobile(request):
            if force_no_redirect:
                response = request.get_response(self.app)
                if not no_redirect_cookie:
                    response.set_cookie(
                        self.no_redirect_param_name, 'on', path="/")
                return response(environ, start_response)

            location = self._config[hostname]
            if self.follow_path:
                location = self._get_location(request, location)
            start_response('302 Redirect', [('Location', location,)])
            return []

        return self.app(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     req.remove_conditional_headers()
     resp = req.get_response(self.app)
     if resp.content_type == 'text/html':
         resp.body = jumble_words(resp.body)
     return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        request = Request(environ)
        path_info = request.path_info
        route_match = routing.mapping.match(path_info)

        if route_match is None:
            # If there's an equivalent URL that ends with /, redirect
            # to that.
            if not path_info.endswith('/') \
                    and request.method == 'GET' \
                    and routing.mapping.match(path_info + '/'):
                new_path_info = path_info + '/'
                if request.GET:
                    new_path_info = '%s?%s' % (
                        new_path_info, urllib.urlencode(request.GET))
                redirect = exc.HTTPFound(location=new_path_info)
                return request.get_response(redirect)(environ, start_response)

            # Return a 404
            response = util.generate_404_response(
                request, routing, environ, self.staticdirector)
            return response(environ, start_response)

        controller = load_controller(route_match['controller'])
        request.start_response = start_response

        request.matchdict = route_match
        request.urlgen = routes.URLGenerator(routing.mapping, environ)
        request.staticdirect = self.staticdirector

        return controller(request)(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        """Dispatcher to processBefore, processAfter, no-op, etc."""

        req = Request(environ)

        # Mark the start time
        start = time.time()

        # Generate the response.  If text/html, print elapsed
        resp = req.get_response(self.app)
        if resp.content_type == "text/html":
            #elapsed = str(1 / (time.time() - start))[0:5]
            elapsed = str(time.time() - start)[0:5]
            first_result = resp.body
            before = 'id="portal-copyright">'
            scoreboard = """
            <style>
            .timeit {font-size: 0.7em; color:white}
            .timeit:hover {color: gray}
            </style>
<div class="timeit">%s - Elapsed: %s sec</div>
"""
            after = before + scoreboard % (self.hostname, elapsed)
            body = first_result.replace(before, after, 1)
            if isinstance(body, unicode):
                resp.charset = 'UTF-8'
                resp.unicode_body = body
            else:
                resp.body = body

        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        req = Request(environ)
        if self._no_redirect_re.match(environ['PATH_INFO']):
            return req.get_response(self.app)(environ, start_response)
        resp = None
        try:
            request_uri = req.url
            request_uri.decode('ascii')
        except UnicodeError:
            resp = exc.HTTPNotFound()
        secure = req.url.startswith('https://')
        srv_path = req.url.split('://', 1)[-1]
        # This SFUSER check is SourceForge-specific (to require all logged-in users to use https)
        # BUT has the additional affect of not forcing SSL for regular Allura instances
        # This is important for local development, at least.  When we remove SFUSER (perhaps by requiring SSL everywhere),
        # we can use `no_redirect.pattern = .` for local development to work without SSL
        force_ssl = req.cookies.get('SFUSER') or self._force_ssl_re.match(environ['PATH_INFO'])
        if not secure and force_ssl:
            resp = exc.HTTPFound(location='https://' + srv_path)
        elif secure and not force_ssl:
            resp = exc.HTTPFound(location='http://' + srv_path)

        if not resp:
            resp = self.app
        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        """Dispatcher to processBefore, processAfter, no-op, etc."""

        req = Request(environ)

        # Mark the start time
        start = time.time()

        # Generate the response.  If text/html, print elapsed
        resp = req.get_response(self.app)
        if resp.content_type == "text/html":
            elapsed = str(1 / (time.time() - start))[0:5]
            first_result = resp.body
            before = 'id="header-user-menu">'
            scoreboard = """
<div style="float:left">Requests per second: %s</div>
"""
            after = before + scoreboard % elapsed
            body = first_result.replace(before, after, 1)
            if isinstance(body, unicode):
                resp.charset = 'UTF-8'
                resp.unicode_body = body
            else:
                resp.body = body

        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        req = Request(environ)
        if "deliv_notheme" in req.GET:
            return self.app(environ, start_response)
        req.environ["deliverance.base_url"] = req.application_url
        ## FIXME: copy_get?:
        orig_req = Request(environ.copy())
        if "deliverance.log" in req.environ:
            log = req.environ["deliverance.log"]
        else:
            log = self.log_factory(req, self, **self.log_factory_kw)
            ## FIXME: should this be put in both the orig_req and this req?
            req.environ["deliverance.log"] = log

        def resource_fetcher(url, retry_inner_if_not_200=False):
            """
            Return the Response object for the given URL
            """
            return self.get_resource(url, orig_req, log, retry_inner_if_not_200)

        if req.path_info_peek() == ".deliverance":
            req.path_info_pop()
            resp = self.internal_app(req, resource_fetcher)
            return resp(environ, start_response)
        rule_set = self.rule_getter(resource_fetcher, self.app, orig_req)
        clientside = rule_set.check_clientside(req, log)
        if clientside and req.url in self.known_html:
            if req.cookies.get("jsEnabled"):
                log.debug(self, "Responding to %s with a clientside theme" % req.url)
                return self.clientside_response(req, rule_set, resource_fetcher, log)(environ, start_response)
            else:
                log.debug(self, "Not doing clientside theming because jsEnabled cookie not set")
        resp = req.get_response(self.app)
        ## FIXME: also XHTML?
        if resp.content_type != "text/html":
            ## FIXME: remove from known_html?
            return resp(environ, start_response)

        # XXX: Not clear why such responses would have a content type, but
        # they sometimes do (from Zope/Plone, at least) and that then breaks
        # when trying to apply a theme.
        if resp.status_int in (301, 302, 304):
            return resp(environ, start_response)

        if resp.content_length == 0:
            return resp(environ, start_response)

        if clientside and req.url not in self.known_html:
            log.debug(
                self, "%s would have been a clientside check; in future will be since we know it is HTML" % req.url
            )
            self.known_titles[req.url] = self._get_title(resp.body)
            self.known_html.add(req.url)
        resp = rule_set.apply_rules(req, resp, resource_fetcher, log, default_theme=self.default_theme)
        if clientside:
            resp.decode_content()
            resp.body = self._substitute_jsenable(resp.body)
        resp = log.finish_request(req, resp)

        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def __call__(self, environ, start_response):
        req = Request(environ)

        if self.cookie_name in req.cookies:
            vid = self.get_visitor_id(req)
            fresh = False
        else:
            vid = nonce()
            fresh = True

        site_id = self.host_map.get(req.host.split(':', 1)[0], 0)

        req.environ['manhattan.visitor'] = visitor = Visitor(
            vid, self.log, site_id, self.buffer_writes)

        if self.pixel_path and req.path_info == self.pixel_path:
            resp = self.handle_pixel(visitor, fresh)
        else:
            resp = req.get_response(self.app)

            if self.count_page(req):
                visitor.page(req)

            if fresh:
                resp.set_cookie(self.cookie_name, self.signer.sign(visitor.id),
                                httponly=True)

            if self.pixel_path and resp.content_type == 'text/html':
                self.inject_pixel(resp)

        visitor.flush()
        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import get_response [as 别名]
    def _read_root(self, env, start_response):

        req = Request(env)
        req.headers['Accept'] = Consts.APP_JSON
        res = req.get_response(self.app)

        body = {}

        # Setup required attributes for response body
        body['objectType'] = Consts.CDMI_APP_CONTAINER
        body['objectName'] = self.account_name + '/'
        body['parentURI'] = '/'.join(['', self.cdmi_root, ''])
        body['capabilitiesURI'] = '/'.join(['', self.cdmi_root,
                                            self.account_name,
                                            self.cdmi_capability_id,
                                           'rootcontainer/'])
        body['metadata'] = {}

        body['children'] = []

        if res.status_int == 200:
            children = json.loads(res.body)
            for child in children:
                body['children'].append(child['name'] + '/')

        if body['children'] == []:
            body['childrenRange'] = ''
        else:
            body['childrenRange'] = '0-' + str(len(body['children']) - 1)
        res.body = json.dumps(body, indent=2)

        return res