Python Request.path_info_pop方法代码示例

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [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 path_info_pop [as 别名]
    def handle(self, env, start_response):
        """
        WSGI entry point for auth requests (ones that match the
        self.auth_prefix).
        Wraps env in webob.Request object and passes it down.

        :param env: WSGI environment dictionary
        :param start_response: WSGI callable
        """
        try:
            req = Request(env)
            if self.auth_prefix:
                req.path_info_pop()
            req.bytes_transferred = '-'
            req.client_disconnect = False
            if 'x-storage-token' in req.headers and \
                    'x-auth-token' not in req.headers:
                req.headers['x-auth-token'] = req.headers['x-storage-token']
            if 'eventlet.posthooks' in env:
                env['eventlet.posthooks'].append(
                    (self.posthooklogger, (req,), {}))
                return self.handle_request(req)(env, start_response)
            else:
                # Lack of posthook support means that we have to log on the
                # start of the response, rather than after all the data has
                # been sent. This prevents logging client disconnects
                # differently than full transmissions.
                response = self.handle_request(req)(env, start_response)
                self.posthooklogger(env, req)
                return response
        except (Exception, Timeout):
            print "EXCEPTION IN handle: %s: %s" % (format_exc(), env)
            start_response('500 Server Error',
                           [('Content-Type', 'text/plain')])
            return ['Internal server error.\n']

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     if req.path_info_peek() == '.media':
         req.path_info_pop()
         app = StaticURLParser(os.path.join(os.path.dirname(__file__), 'media'))
         return app(environ, start_response)
     if self.base_dir:
         filename = os.path.join(self.base_dir, req.path_info.lstrip('/'))
         assert filename.startswith(self.base_dir)
     else:
         filename = self.filename
     if req.method not in ('GET', 'POST'):
         resp = exc.HTTPMethodNotAllowed('Bad method: %s' % req.method,
                                         allow='GET,POST')
     elif os.path.isdir(filename):
         if req.method == 'POST':
             resp = self.save_create(req, filename)
         else:
             if not req.path.endswith('/'):
                 resp = exc.HTTPMovedPermanently(add_slash=True)
             else:
                 resp = self.view_dir(req, filename)
     else:
         if req.method == 'POST':
             resp = self.save_file(req, filename)
         elif req.method == 'GET':
             resp = self.edit_file(req, filename)
     return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
def application(environ, start_response):
    req = Request(environ)
    res = Response()
    cmd = req.path_info_pop()
    new_conf = req.path_info_pop()
    conf.update(dict(map(lambda i: i.split('='), new_conf.split('&'))))
    res.content_type = 'text/plain'
    sleep(1)
    res.body = str(operate(conf, cmd)) + "\n"
    return res(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
    def __call__(self, environ, start_response):
        """
        This will be called when the application is being run.  This can be
        either:

            - a request to the __profiler__ framework to display profiled
              information, or
            - a normal request that will be profiled.

        Returns the WSGI application.
        """
        # If we're not accessing the profiler, profile the request.
        req = Request(environ)

        self.profiling_enabled = os.path.exists(ENABLED_FLAG_FILE)
        if req.path_info_peek() != self.profiler_path.strip('/'):
            if not self.profiling_enabled:
                return self.app(environ, start_response)
            _locals = locals()
            prof = Profile()
            start_timestamp = datetime.now()
            prof.runctx(
                "app = self.app(environ, start_response)", globals(), _locals)
            stats = prof.getstats()
            session = ProfilingSession(stats, environ, start_timestamp)
            self._backend.add(session)

            return _locals['app']

        req.path_info_pop()

        # We could import `routes` and use something like that here, but since
        # not all frameworks use this, it might become an external dependency
        # that isn't needed.  So parse the URL manually using :class:`webob`.
        query_param = req.path_info_pop()
        if not query_param:
            wsgi_app = self.list_profiles(req)
        elif query_param == "graph":
            wsgi_app = self.render_graph(req)
        elif query_param == "media":
            wsgi_app = self.media(req)
        elif query_param == "profiles":
            wsgi_app = self.show_profile(req)
        elif query_param == "delete":
            wsgi_app = self.delete_profile(req)
        else:
            wsgi_app = HTTPNotFound()

        return wsgi_app(environ, start_response)

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

        if environ['PATH_INFO'].startswith('/log/'):
            req.path_info_pop()

            file = open(os.path.sep.join((self.dir, req.path_info)))
            data = file.read()
            file.close()

            template = self.outer_template % data
            return Response(template)(environ, start_response)

        return self.app(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
    def app(self, environ, start_response):
        req = Request(environ)
        resp = Response(request=req, content_type='text/html; charset=utf-8')
        # Leave the interactive flag in tw.framework so demo controllers can know
        # if it is safe to enable advanced/unsecure features.
        tw.framework.request_local.interactive = self.interactive
        tw.framework.request_local.browser_prefix = req.script_name

        # Lookup widget XXX: Yuck!
        if req.path_info == '/':
            controller = self.home
        elif req.path_info.startswith('/_repl') and self.http_repl:
            req.path_info_pop()
            return self.http_repl(environ, start_response)
        elif req.path_info.startswith('/widgets'):
            controller = self.widgets
        else:
            try:
                widget, action = self.lookup_widget_action(req.path_info)
            except LookupError:
                resp = exc.HTTPNotFound('No widget at %s' % req.path_info)
                return resp(environ, start_response)
                

            # Lookup controller
            try:
                controller = self.lookup_controller(widget, action)
            except LookupError:
                resp = exc.HTTPNotImplemented()
                return resp(environ, start_response)
                
            # If it's a widget class instantiate it with no arguments 
            if isinstance(widget, WidgetType):
                widget = widget('test_widget')
            req.widget = widget

        # Call controller and handle output 
        output = controller(req, resp)
        if isinstance(output, str):
            resp.body = output
        elif isinstance(output, unicode):
            resp.body = output.encode('utf-8')
        elif output:
            resp = output

        return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
 def new_app(environ, start_response):
     req = Request(environ)
     if req.path_info.startswith("/getscript"):
         req.path_info_pop()
         process_script = True
     else:
         process_script = False
     result = req.get_response(app)
     if process_script and result.status.startswith("200"):
         contents = result.body
         template = jsontemplate.FromFile(open(os.path.dirname(os.path.abspath(__file__)) + "/jsmodule.jsont"))
         start_response(result.status, result.headers.items())
         newbody = template.expand(dict(script=contents, 
                                   script_name="/getscript" + req.path_info))
         return [newbody]
     start_response(result.status, result.headers.items())
     return [result.body]

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

        path = req.path_info_peek()

        if path == "theme.html":
            return self.theme(environ, start_response)

        if path == "login":
            return self.login(environ, start_response)
        if path == "logout":
            if '__ac' in req.cookies:
                res = Response()
                res.status = 304
                res.location = "/"
                res.delete_cookie("__ac")
                return res(environ, start_response)
                
        if path == "projects":
            req.path_info_pop()
            project = req.path_info_pop()
            path = req.path_info_peek()

            if path == "info.xml":
                return Response("""
<info>
<policy>medium_policy</policy>
 <featurelets> 
  <featurelet>blog</featurelet> 
  <featurelet>wikis</featurelet> 
  <featurelet>tasks</featurelet> 
  <featurelet>listen</featurelet> 
 </featurelets> 
</info>""", content_type="application/xml")(environ, start_response)
            if path == "members.xml":
                return Response("""
<members> 
 <member> 
  <id>ejucovy</id> 
  <role>ProjectAdmin</role> 
 </member> 
</members>""", content_type="application/xml")(environ, start_response)

        return Response(req.path_info_peek(), content_type='text/plain')(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
 def app(self, environ, start_response):
     """Main dispatcher. pops PATH_INFO and delegates to exposed methods."""
     req = Request(environ.copy())
     resp = Response(request=req, content_type='text/html; charset=UTF8')
     first_part = req.path_info_pop() or 'index'
     method = getattr(self, first_part, None)
     if getattr(method, 'exposed', False):
         output = method(req, resp)
         if isinstance(output, unicode):
             resp.body = output.encode('utf-8')
         elif isinstance(output, str):
             resp.body = output
         elif output:
             resp = output
     else:
         resp = exc.HTTPNotImplemented()
     return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     path = req.path_info_pop()
     if path is None or path == "":
         path = "index"
     for name, func in self.dct.iteritems():
         if hasattr(func, "pattern"):
             pattern = getattr(func, "pattern")
             m = pattern.match(path)
             if m is not None:
                 req.urlvars.update(m.groupdict())
                 res = req.get_response(func)
                 break
         if callable(func) and name == path:
             res = req.get_response(func)
             break
     else:
         res = HTTPNotFound()
     return res(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
 def __call__(self, environ, start_response):
     request = Request(environ)
     repo_name = request.path_info_pop()
     if not repo_name.endswith('.git'):
         return exc.HTTPNotFound()(environ, start_response)
     content_path = os.path.realpath(os.path.join(self.content_path, repo_name))
     if self.content_path not in content_path:
         return exc.HTTPForbidden()(environ, start_response)
     try:
         app = GitRepository(content_path)
     except (AssertionError, OSError):
         if os.path.isdir(content_path):
             app = self.repository_app(content_path)
         else:
             if self.auto_create and 'application/x-git-receive-pack-result' in request.accept:
                 try:
                     self.pre_clone_hook(content_path, request)
                     subprocess.call(u'git init --quiet --bare "%s"' % content_path, shell=True)
                     self.post_clone_hook(content_path, request)
                 except exc.HTTPException, e:
                     return e(environ, start_response)
                 app = self.repository_app(content_path)
             else:
                 return exc.HTTPNotFound()(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     if req.GET.get('__pdbid__'):
         id = int(req.GET['__pdbid__'])
         response = self.states[id]['response']
         return response(environ, start_response)
     if req.path_info_peek() == '.pdbcapture':
         req.path_info_pop()
         if req.path_info_peek() == 'static':
             req.path_info_pop()
             return self.static_app(environ, start_response)
         if req.path_info_peek() == 'media':
             req.path_info_pop()
             return self.media_app(environ, start_response)
         resp = self.internal_request(req)
         return resp(environ, start_response)
     id = self.counter.next()
     state = dict(id=id,
                  event=threading.Event(),
                  base_url=req.application_url,
                  stdout=[],
                  stdin=[],
                  stdin_event=threading.Event())
     t = threading.Thread(target=self.call_app, args=(req, state))
     t.setDaemon(True)
     t.start()
     state['event'].wait()
     if 'response' in state:
         # Normal request, nothing happened
         resp = state['response']
         return resp(environ, start_response)
     if 'exc_info' in state:
         raise state['exc_info'][0], \
             state['exc_info'][1], state['exc_info'][2]
     self.states[id] = state
     tmpl = self.get_template('pdbcapture_response.html')
     body = tmpl.substitute(req=req, state=state, id=id)
     resp = Response(body)
     return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
# 'GET'
req_method=req.method
#pprint(req.method)
#
req_dir=dir(req)
# req
# <Request at 0x27cd9e8 (invalid WSGI environ)>

req=Request.blank('/article?id=1&id=2')
pprint(req.environ)

# demo for request body
req.body='This is a request body'

req.path_info_peek()
req.path_info_pop()
req.script_name

# Headers
req.headers['Content-Type'] = 'application/x-www-urlencoded'
req.headers.items()
req.environ['CONTENT_TYPE']

# Query & POST
req = Request.blank('/test?check=a&check=b&name=Bob')
req.GET
req.GET['check']
req.GET.getall('check')
req.GET.items()
req.GET.values()

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import path_info_pop [as 别名]
def AdminController(environ, start_response):
    req = Request(environ).copy()
    req.path_info_pop() # remove admin prefix
    return g.admin_app(req.environ, start_response)