Python Response.status_int方法代码示例

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
        def __call__(self, environ, start_response):
            try:
                return self.app(environ, start_response)
            except Exception as exc:
                # get a formatted exception
                out = StringIO()
                print_exc(file=out)
                LOG.exception(exc)

                # get formatted WSGI environment
                formatted_environ = pformat(environ)

                # render our template
                result = debug_template.render(
                    traceback=out.getvalue(),
                    environment=formatted_environ
                )

                # construct and return our response
                response = Response()
                if isinstance(exc, HTTPException):
                    response.status_int = exc.status
                else:
                    response.status_int = 500
                response.unicode_body = result
                return response(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
    def __call__(self, environ, start_response):
        relative_urls = asbool(self.config.get('adhocracy.relative_urls',
                                               'false'))
        environ['adhocracy.domain'] = self.domain
        instance_key = self.config.get('adhocracy.instance')

        if instance_key is None:
            instance_key = self.domains_instances.get(environ.get('HTTP_HOST'))

        if instance_key is None:
            if relative_urls:
                path = environ.get('PATH_INFO', '')
                if path.startswith('/i/'):
                    instance_key = path.split('/')[2]
                    environ['PATH_INFO'] = path[len('/i/' + instance_key):]
                    if environ['PATH_INFO'] == '':
                        response = Response()
                        if instance_key == '':
                            response.status_int = 404
                            # Double slashes are stripped, so we can't redirect
                            # to /i//
                            return response(environ, start_response)

                        response.status_int = 302
                        response.headers['location'] = path + '/'
                        return response(environ, start_response)
            else:
                host = environ.get('HTTP_HOST', "")
                host = host.replace(self.domain, "")
                host = host.replace('localhost', "")
                host = host.split(':', 1)[0]
                host = host.strip('.').strip()
                instance_key = host

        if instance_key:  # instance key is set (neither None nor "")
            instance = model.Instance.find(instance_key)
            if instance is None:
                response = Response()
                if not relative_urls:
                    # HTTP_HOST needs to be set to an existing domain,
                    # otherwise we end up here again after being internally
                    # redirected from StatusCodeRedirect and produce a white
                    # page.
                    environ['HTTP_HOST'] = self.domain
                    # Fair handling of users prefixing everything with www.
                    if instance_key == 'www':
                        response.status_int = 301
                        response.headers['location'] = \
                            base_url(environ.get('PATH_INFO', '/'),
                                     absolute=True, config=self.config)
                        return response(environ, start_response)
                response.status_int = 404
                return response(environ, start_response)
            else:
                model.instance_filter.setup_thread(instance)
        try:
            return self.app(environ, start_response)
        finally:
            model.instance_filter.setup_thread(None)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
def jresponse(status,msg,req,status_int,headers=None,statusstr='',param=None):
    
    data = {'status':str(status),'msg':str(msg)}
    
    if param:
        data.update(param)
        
    container_list = json.dumps(data)
    if headers:
        ret = Response(body=container_list, request=req,headers=headers)
    else:
        ret = Response(body=container_list, request=req)
        
    ret.content_type = 'application/json'
    ret.charset = 'utf-8'
    ret.status_int = status_int
    if statusstr:
        ret.status = statusstr
        
    if status != '0' and req.method == 'PUT': 
        pass
        # syslog.syslog(syslog.LOG_ERR,'jresponse:   status: ' + str(status_int)+'  path: '+str(req.path)+'  msg: '+str(msg) + '  tx_id:  '+ req.environ.get('swift.trans_id',''))
        # print 'jresponse:   status: ' + str(status_int)+'  path: '+str(req.path)+'  msg: '+str(msg) + '  tx_id:  '+ req.environ.get('swift.trans_id','') + '  method:  '+str(req.method) + '  headers:  '+str(req.headers) + '  params:  '+str(req.GET)
        # traceback.print_stack() 
        # syslog.syslog(syslog.LOG_ERR,'jresponse:   '+str(traceback.extract_stack() ))     
        # syslog.syslog(syslog.LOG_ERR,'jresponse:   '+str(traceback.print_stack() ))
    return ret

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
def test_HEAD_conditional_response_range_empty_response():
    from webob.response import EmptyResponse
    req = Request.blank('/')
    req.method = 'HEAD'
    res = Response(request=req, conditional_response=True)
    res.status_int = 200
    res.body = 'Are we not men?'
    res.content_length = len(res.body)
    class FakeRequest:
        method = 'HEAD'
        if_none_match = 'none'
        if_modified_since = False
        def __init__(self, env):
            self.env = env
            self.range = self # simulate inner api
            self.if_range = self
        def content_range(self, length):
            """range attr"""
            class Range:
                start = 4
                stop = 5
            return Range
        def match_response(self, res):
            """if_range_match attr"""
            return True
    def start_response(status, headerlist):
        pass
    res.RequestClass = FakeRequest
    result = res({}, start_response)
    ok_(isinstance(result, EmptyResponse), result)

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

        # match route or 404
        view_fn = self.get_view_for_route(request)
        if view_fn is None:
            response = Response()
            response.status_int = 404
            return response(environ, start_response)

        # before middlewares
        for before in self.befores:
            response = before(request)
            if response is not None:
                return self.render_response(environ, start_response, response)

        # run view
        response = view_fn(request)
        if isinstance(response, dict):
            response = Response(json=response)

        # after middlewares
        for after in self.afters:
            a_response = after(request, response)
            if a_response is not None:
                return self.render_response(environ, start_response, response)

        # Support dict as view/middleware response
        return self.render_response(environ, start_response, response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
    def __call__(self, environ, start_response):
        relative_urls = asbool(self.config.get('adhocracy.relative_urls',
                                               'false'))
        environ['adhocracy.domain'] = self.domain
        instance_key = self.config.get('adhocracy.instance')
        if instance_key is None:
            if relative_urls:
                path = environ.get('PATH_INFO', '')
                if path.startswith('/i/'):
                    instance_key = path.split('/')[2]
                    environ['PATH_INFO'] = path[len('/i/' + instance_key):]
                    if environ['PATH_INFO'] == '':
                        response = Response()
                        if instance_key == '':
                            response.status_int = 404
                            # Double slashes are stripped, so we can't redirect
                            # to /i//
                            return response(environ, start_response)

                        response.status_int = 302
                        response.headers['location'] = path + '/'
                        return response(environ, start_response)
            else:
                host = environ.get('HTTP_HOST', "")
                host = host.replace(self.domain, "")
                host = host.replace('localhost', "")
                host = host.split(':', 1)[0]
                host = host.strip('.').strip()
                instance_key = host

        if instance_key:  # instance key is set (neither None nor "")
            instance = model.Instance.find(instance_key)
            if instance is None:
                if (not relative_urls) and instance_key == 'www':
                    log.debug("No such instance: www, defaulting to global!")
                else:
                    response = Response()
                    response.status_int = 404
                    return response(environ, start_response)
            else:
                model.instance_filter.setup_thread(instance)
        try:
            return self.app(environ, start_response)
        finally:
            model.instance_filter.setup_thread(None)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
 def DELETE(self, request, start_response):
     uid = request.environ['selector.vars']['uid']
     res = Response(content_type='application/json')
     uid = self.get_uid(request)
     if self.rtree(request).get(uid):
         del self.rtree(request)[uid]
     else:
         res.status_int = 404
     return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
 def GET(self, request, start_response):
     res = Response(content_type='application/json')
     index = self.rtree(request)
     uid = self.get_uid(request)
     bounds = index.get(uid)
     if bounds is None:
         res.status_int = 404
         return res
     res.body = simplejson.dumps(dict(id=uid, bbox=bounds))
     return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
 def render(self, controller, action, format, status, dict):
     '''
     Method gets fallowing arguments: controller, action, format, code, dict
     '''
     template = '{0}/{1}.{2}'.format(controller, action, format)
     content = self.engine.render(template=template, dict=dict)
     response = Response()
     response.status_int = status
     response.unicode_body = content
     return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
    def __call__(self, environ, start_response):
        if environ['wsgi.multiprocess']:
            raise RuntimeError(
                "The DebugMiddleware middleware is not usable in a "
                "multi-process environment"
            )

        if environ.get('paste.testing'):
            return self.app(environ, start_response)

        # initiate a PDB session if requested
        global __debug_environ__
        debugging = environ['PATH_INFO'] == '/__pecan_initiate_pdb__'
        if debugging:
            PdbMiddleware(self.app, self.debugger)(
                __debug_environ__, start_response
            )
            environ = __debug_environ__

        try:
            return self.app(environ, start_response)
        except:
            # save the environ for debugging
            if not debugging:
                __debug_environ__ = environ

            # get a formatted exception
            out = StringIO()
            print_exc(file=out)

            # get formatted WSGI environment
            formatted_environ = pformat(environ)

            # render our template
            result = debug_template.render(
                traceback=out.getvalue(),
                environment=formatted_environ,
                pecan_image=pecan_image,
                xregexp_js=xregexp_js,
                syntax_js=syntax_js,
                brush=brush,
                syntax_css=syntax_css,
                theme=theme,
                debugging=debugging
            )

            # construct and return our response
            response = Response()
            response.status_int = 400
            response.unicode_body = result
            return response(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     resp = Response()
     filename = req.path_info.strip('/')
     lfilename = filename.lower()
     if not req.path_info.strip('/') or os.path.isdir(filename):
         if filename:
             filename = path(filename, 'index.html')
         else:
             filename = 'index.html'
         body = open(filename, 'rb').read()
         resp.body = body
     elif os.path.isfile(filename):
         if req.method.lower() == 'delete':
             sh.rm(filename + '*', shell=True)
             resp = exc.HTTPNoContent()
             return resp(environ, start_response)
         if req.path_info.endswith('.metadata'):
             cfg = ConfigObject(filename=filename)
             if req.method.lower() == 'get':
                 resp.content_type = 'application/json'
             elif req.method.lower() == 'put':
                 data = json.loads(req.body)
                 cfg.metadata.update(data)
                 cfg.write()
             metadata = dict(cfg.metadata.items())
             metadata.update(tags=cfg.metadata.tags.as_list())
             resp.body = json.dumps(metadata)
         elif req.path_info.endswith('.js'):
             resp.content_type = 'text/javascript'
         elif req.path_info.endswith('.json'):
             resp.content_type = 'application/json'
         elif req.path_info.endswith('.css'):
             resp.content_type = 'text/css'
         elif lfilename.endswith('.jpg'):
             resp.charset = None
             resp.content_type = 'image/jpeg'
         print(filename)
         if not resp.content_length:
             resp.app_iter = fd(filename)
     elif req.path_info.startswith('/delete/'):
         filename = req.path_info[8:-1]
         self.delete(filename)
         resp.status_int = 302
         resp.location = '/' + path.dirname(filename)
     else:
         resp.body = str(req.path_info)
     resp.last_modified = datetime.now()
     return resp(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
def make_response(uri, environ):
    
    res = Response(conditional_response=True)
    
    # check if the host is online. If not raise an http error
    if not pingSMB( parseSMBuri(uri)["host"] ):
        return HTTPGatewayTimeout("Host is currently offline. You may try again at a later time.")
    
    try:
        f = c.open(uri)
    except smbc.NoEntryError:
        return HTTPNotFound("The file you requested is no longer available!")
    
    fs = f.fstat()
    filesize = fs[6]
    last_modified = fs[8] # mtime
    filename = uri.split("/")[-1]
    req = Request(environ)
    log.debug("Incoming request: \n" + str(req))
    
    if req.range:
        log.debug("begin ranged transfer")
        res.status_int = 206
        res.content_range = req.range.content_range(filesize)
        (start, stop) = req.range.range_for_length(filesize)
        
        log.debug("filesize: " + str(filesize))
        log.debug("start: " + str(start)  + "   stop: " + str(stop))
        log.debug("Content-Range: " + str(res.content_range))
        
        res.app_iter = FileIterable(uri, start=start, stop=stop)
        res.content_length = stop - start
    
    else:
        log.debug("begin normal transfer")
        res.app_iter = FileIterable(uri)
        res.content_length = filesize
    
    log.debug("Content-Length: " + str(res.content_length))
    
    res.server_protocol = "HTTP/1.1"
    # Make sure the file gets downloaded and not played live
    res.content_type = "application/octet-stream"
    res.last_modified = last_modified
    res.etag = '%s-%s-%s' % (fs[8], fs[6], hash(f))
    res.headers.add("Content-Disposition", 'attachment; filename="%s"' % str(filename) )
    res.headers.add("Accept-Ranges", "bytes")
    return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
 def __call__(self, environ, start_response):
     req = Request(environ)
     path = req.path.split('/')
     assert path[1] and not path[0]
     res = Response()
     try:
         handler = getattr(self, '_handle_' + path[1])
     except AttributeError:
         res.status_int = 404
     else:
         args = path[2:]
         # XXX assumes no unquoting necessary
         kw = dict((str(k),
             True if v == 'True' else
             False if v == 'False' else
             str(v)) for k, v in req.GET.iteritems())
         handler(req, res, *args, **kw)
     return res(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
    def _read_object(self, env, start_response, headers):

        req = Request(env)
        os_res = req.get_response(self.app)

        cdmi_version = env.get('HTTP_X_CDMI_SPECIFICATION_VERSION', False)
        # If this is not a CDMI content request, simply return the response
        if not cdmi_version:
            return os_res

        # For CDMI content request, more work need to be done.
        res = Response()
        # Set up CDMI required headers
        res.headers[Consts.CDMI_VERSION] = Consts.CDMI_VERSION_VALUE
        res.headers['Content-Type'] = Consts.CDMI_APP_OBJECT

        object_body = os_res.body
        # Build the response message body according to CDMI specification
        body = {}

        # Setup required attributes for response body
        body['objectType'] = Consts.CDMI_APP_OBJECT
        body['objectName'] = self.object_name
        body['parentURI'] = concat_parts(self.account_name,
                                         self.parent_name) + '/'
        body['capabilitiesURI'] = concat_parts(self.cdmi_capability_id,
                                               self.account_name,
                                               self.container_name,
                                               self.parent_name,
                                               self.object_name) + '/'
        body['completionStatus'] = 'Complete'
        body['metadata'] = {}

        # Handling CDMI metadata
        body['metadata'] = self._process_metadata(headers)
        body['mimetype'] = headers.get('content-type', '')
        body['valuetransferencoding'] = \
            headers.get(Consts.VALUE_ENCODING, 'utf-8')
        body['valuerange'] = '0-' + str(len(object_body))
        body['value'] = object_body
        res.body = json.dumps(body, indent=2)
        res.status_int = 200

        return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import status_int [as 别名]
    def respond(self, request):
        address_parts = dict(scheme=self.scheme,
                             host=self.host,
                             port=self.port,
                             path=request.path,
                             )
        address = "{scheme}://{host}:{port!s}{path}".format(**address_parts)

        # TODO Use HTTP cache-control headers.

        # Request the information from our proxy
        resp, content = self.http.request(address)
        status = int(resp['status'])
        del resp['status']
        response = Response()
        response.status_int = status
        response.headerlist = resp.items()
        response.body = content
        return response