Python Response.etag方法代码示例

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
def make_response(file, content_type):
    response = Response(content_type=content_type)
    response.app_iter = FileIterable(file)
    stat = os.fstat(file.fileno())
    response.content_length = stat.st_size
    response.last_modified = stat.st_mtime
    response.etag = '%s-%s' % (stat.st_mtime, stat.st_size)
    return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
def make_response(filename):
    res = Response(content_type=get_mimetype(filename),
                   conditional_response=True)
    res.app_iter = FileIterable(filename)
    res.content_length = os.path.getsize(filename)
    res.last_modified = os.path.getmtime(filename)
    res.etag = '%s-%s-%s' % (os.path.getmtime(filename),
                             os.path.getsize(filename), hash(filename))
    return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
def file_response(filename):
    """return a webob response object appropriate to a file name"""
    res = Response(content_type=get_mimetype(filename),
                   conditional_response=True)
    res.app_iter = FileIterable(filename)
    res.content_length = os.path.getsize(filename)
    res.last_modified = os.path.getmtime(filename)
    res.etag = '%s-%s-%s' % (os.path.getmtime(filename),
                             os.path.getsize(filename), hash(filename))
    return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
    def index(self, req):
        """ Handle GET and HEAD requests for static files. Directory requests are not allowed"""
        static_dir = os.path.normpath(os.path.join(os.path.dirname(__file__), '../static/'))

        # filter out ..
        try:
            static_path = req.urlvars['path'].replace('/..', '')
        except:
            return HTTPForbidden()

        path = os.path.join(static_dir, static_path) 
        if os.path.isdir(path):
            return HTTPForbidden()

        if req.method == 'GET' or req.method == 'HEAD':
            if os.path.isfile(path):
                etag, modified, mime_type, size = self._get_stat(path)

                res = Response()
                res.headers['content-type'] = mime_type
                res.date = rfc822.formatdate(time.time())
                res.last_modified = modified
                res.etag = etag

                if_modified_since = req.headers.get('HTTP_IF_MODIFIED_SINCE')
                if if_modified_since:
                    if rfc822.parsedate(if_modified_since) >= rfc822.parsedate(last_modified):
                        return HTTPNotModified()

                if_none_match = req.headers.get('HTTP_IF_NONE_MATCH')
                if if_none_match:
                    if if_none_match == '*' or etag in if_none_match:
                        return HTTPNotModified()

                # set the response body
                if req.method == 'GET':
                    fd = open(path, 'rb')
                    if 'wsgi.file_wrapper' in req.environ:
                        res.app_iter = req.environ['wsgi.file_wrapper'](fd)
                        res.content_length = size
                    else:
                        res.app_iter = iter(lambda: fd.read(8192), '')
                        res.content_length = size
                else:
                    res.body = ''

                return res
            else:
                return None
        else:
            return None

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [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 etag [as 别名]
def serve_file(filename):
    if os.path.exists(filename):
        basename = urlutils.basename(filename)
        content_type = mimetypes.guess_type(basename)[0]

        res = Response(content_type=content_type, conditional_response=True)
        res.app_iter = FileIterable(filename)
        res.content_length = os.path.getsize(filename)
        res.last_modified = os.path.getmtime(filename)
        # Todo: is this the best value for the etag?
        # perhaps md5 would be a better alternative
        res.etag = '%s-%s-%s' % (os.path.getmtime(filename),
            os.path.getsize(filename),
            hash(filename))
        return res

    else:
        return HTTPNotFound()

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
def make_folder_response(foldername, req):
    if req.path_url.endswith('/'):
        fold_url = req.path_url[:-1]
    else:
        fold_url = req.path_url
    folderlist = [ '<html>' + #foldername +
                '<br>'.join( [('<a href="%s/%s">%s</a>' % (fold_url, filename, filename))
                                for filename in os.listdir(foldername)])
                                 + '</html>'   ]
    res = Response(content_type="text/html",
                   conditional_response=True)
    res.body = folderlist[0]
    res.headers.add('Server', render('__server_info__'))
    res.content_length = len(res.body)
    res.last_modified = os.path.getmtime(foldername)
    res.etag = '%s-%s-%s' % (os.path.getmtime(foldername),
                             os.path.getsize(foldername), hash(foldername))
    return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
def make_file_response(filename):
    res = Response(content_type=get_mimetype(filename),
                   conditional_response=True)
    res.headers.add('Accept-Ranges','bytes')
    res.headers.add('Server', render('__server_info__'))
    res.headers.add('Content-Disposition',str('attachment; filename=%s'%(filename.split(os.path.sep)[-1])))
    res.app_iter = FileIterable(filename)
    #try:
    res.content_length = os.path.getsize(filename)
    res.last_modified = os.path.getmtime(filename)
    res.etag = '%s-%s-%s' % (os.path.getmtime(filename),
                             os.path.getsize(filename), hash(filename))
    #===========================================================================
    # except WindowsError, e:
    #    if e.errno == 2:
    #        del res
    #        res = Response(status='404')
    #        res.headers.add('Server', render('__server_info__'))
    #===========================================================================
    return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
            # catches timestamps before the epoch
            return HTTPPreconditionFailed(request=request)
        if if_modified_since and \
           datetime.fromtimestamp(float(file.metadata['X-Timestamp']), UTC) < \
           if_modified_since:
            file.close()
            return HTTPNotModified(request=request)
        response = Response(app_iter=file,
                        request=request, conditional_response=True)
        response.headers['Content-Type'] = file.metadata.get('Content-Type',
                'application/octet-stream')
        for key, value in file.metadata.iteritems():
            if key.lower().startswith('x-object-meta-') or \
                    key.lower() in self.allowed_headers:
                response.headers[key] = value
        response.etag = file.metadata['ETag']
        response.last_modified = float(file.metadata['X-Timestamp'])
        response.content_length = file_size
        if response.content_length < KEEP_CACHE_SIZE and \
                'X-Auth-Token' not in request.headers and \
                'X-Storage-Token' not in request.headers:
            file.keep_cache = True
        if 'Content-Encoding' in file.metadata:
            response.content_encoding = file.metadata['Content-Encoding']
        response.headers['X-Timestamp'] = file.metadata['X-Timestamp']
        return request.get_response(response)

    def HEAD(self, request):
        """Handle HTTP HEAD requests for the Swift Object Server."""
        try:
            device, partition, account, container, obj = \

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
            file_obj.close()
            return HTTPNotModified(request=request)
        if not file_obj.is_dir:
            response = Response(content_type=file_obj.metadata.get(X_CONTENT_TYPE,
                            FILE_TYPE), app_iter=file_obj,
                            request=request, conditional_response=True)
        else:
            response = Response(content_type=file_obj.metadata.get(X_CONTENT_TYPE,
                            DIR_TYPE), request=request,
                            conditional_response=True)

        for key, value in file_obj.metadata.iteritems():
            if key.lower().startswith('x-object-meta-') or \
                    key.lower() in self.allowed_headers:
                response.headers[key] = value
        response.etag = file_obj.metadata[X_ETAG]
        response.last_modified = float(file_obj.metadata[X_TIMESTAMP])
        response.content_length = file_size

        if not file_obj.is_dir and \
        response.content_length < KEEP_CACHE_SIZE and \
        'X-Auth-Token' not in request.headers and \
        'X-Storage-Token' not in request.headers:
            file_obj.keep_cache = True

        if 'Content-Encoding' in file_obj.metadata:
            response.content_encoding = file_obj.metadata['Content-Encoding']
        return request.get_response(response)

    def HEAD(self, request):
        """Handle HTTP HEAD requests for the Swift Object Server."""

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
    def handle_request(self, env, req):
        if req.method not in ('GET', 'HEAD'):
            headers = self._getCacheHeaders(CACHE_BAD_URL)
            return HTTPMethodNotAllowed(request=req, headers=headers)
        # allow earlier middleware to override hash and obj_name
        hsh = env.get('swift.cdn_hash')
        object_name = env.get('swift.cdn_object_name')
        if not (hsh and object_name):
            for regex in self.cdn_regexes:
                match_obj = regex.match(req.url)
                if match_obj:
                    match_dict = match_obj.groupdict()
                    hsh = match_dict.get('cdn_hash')
                    object_name = match_dict.get('object_name')
                    break

        if not (hsh and object_name):
            headers = self._getCacheHeaders(CACHE_BAD_URL)
            return HTTPNotFound(request=req, headers=headers)
        cdn_obj_path = self._get_hsh_obj_path(hsh)
        hash_data = self._get_cdn_data(env, cdn_obj_path)
        if hash_data and hash_data.cdn_enabled:
            # this is a cdn enabled container, proxy req to swift
            swift_path = '/v1/%s/%s/%s' % (hash_data.account,
                                           hash_data.container, object_name)
            headers = self._getCdnHeaders(req)
            resp = make_pre_authed_request(env, req.method, swift_path,
                headers=headers, agent='SwiftOrigin').get_response(self.app)
            if resp.status_int == 304:
                return resp
            # we don't have to worry about the 401 case
            if resp.status_int == 404:
                return HTTPNotFound(request=req,
                    headers=self._getCacheHeaders(CACHE_404))
            if resp.status_int == 416:
                return HTTPRequestRangeNotSatisfiable(request=req,
                    headers=self._getCacheHeaders(CACHE_404))
            if resp.status_int in (200, 206):
                #TODO: not doing the check for content-length == None ok?
                if resp.content_length > self.max_cdn_file_size:
                    return HTTPBadRequest(request=req,
                        headers=self._getCacheHeaders(CACHE_404))
                cdn_resp = Response(request=req, app_iter=resp.app_iter)
                cdn_resp.status = resp.status_int
                cdn_resp.last_modified = resp.last_modified
                cdn_resp.etag = resp.etag
                cdn_resp.content_length = resp.content_length
                for header in ('Content-Range', 'Content-Encoding',
                               'Content-Disposition', 'Accept-Ranges',
                               'Content-Type'):
                    header_val = resp.headers.get(header)
                    if header_val:
                        cdn_resp.headers[header] = header_val

                cdn_resp.headers.update(self._getCacheHeaders(hash_data.ttl))

                return cdn_resp
            self.logger.exception('Unexpected response from Swift: %s, %s' %
                                  (resp.status, cdn_obj_path))
        return HTTPNotFound(request=req,
                            headers=self._getCacheHeaders(CACHE_404))

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import etag [as 别名]
        try:
            if_modified_since = request.if_modified_since
        except (OverflowError, ValueError):
            # catches timestamps before the epoch
            self.logger.increment("GET.errors")
            return HTTPPreconditionFailed(request=request)
        if if_modified_since and datetime.fromtimestamp(float(file.metadata["X-Timestamp"]), UTC) < if_modified_since:
            file.close()
            self.logger.timing_since("GET.timing", start_time)
            return HTTPNotModified(request=request)
        response = Response(app_iter=file, request=request, conditional_response=True)
        response.headers["Content-Type"] = file.metadata.get("Content-Type", "application/octet-stream")
        for key, value in file.metadata.iteritems():
            if key.lower().startswith("x-object-meta-") or key.lower() in self.allowed_headers:
                response.headers[key] = value
        response.etag = file.metadata["ETag"]
        response.last_modified = float(file.metadata["X-Timestamp"])
        response.content_length = file_size
        if response.content_length < self.keep_cache_size and (
            self.keep_cache_private
            or ("X-Auth-Token" not in request.headers and "X-Storage-Token" not in request.headers)
        ):
            file.keep_cache = True
        if "Content-Encoding" in file.metadata:
            response.content_encoding = file.metadata["Content-Encoding"]
        response.headers["X-Timestamp"] = file.metadata["X-Timestamp"]
        self.logger.timing_since("GET.timing", start_time)
        return request.get_response(response)

    @public
    def HEAD(self, request):