Python Response.headers['Content-Type']方法代码示例

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def log_hit(self):
        # Make sure we get plain strings, not unicode
        #self.request.charset = None 
        cur = self.request.str_GET.get('cur', None)
        ref = self.request.str_GET.get('ref', None)
        title = self.request.str_GET.get('title', None)

        if not cur:
            cur = self.request.headers.get('referer', None)
        
        if cur is not None:
            cur = get_unicode(unquote_plus(cur))
        if ref is not None:
            ref = get_unicode(unquote_plus(ref))
        if title is not None:
            title = get_unicode(unquote_plus(title)).strip()

        response = Response()
        response.headers['Content-Type'] = "image/gif"
        response.headers['Expires'] = "Sat, 26 Jul 1997 05:00:00 GMT"
        response.headers['Cache-Control'] = "no-cache, must-revalidate"
        response.body = self._image

        if not cur:
            return response

        visitor_ip = self.request.headers.get('X-Forwarded-For', None)
        if visitor_ip is None:
            visitor_ip = self.request.remote_addr

        hit = Hit(self._conf, cur, referrer=ref, title=title,
            visitor_ip=visitor_ip)
        if hit.is_whitelisted() and not hit.is_blacklisted():
            self._storage.add_hit(hit)
        return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['SERVER_PORT'] = self.conf.get('volume_endpoint_port')
        env['SCRIPT_NAME'] = '/v1'
        env['HTTP_HOST'] = '%s:%s' % \
            (self.conf.get('volume_endpoint_host'),
             self.conf.get('volume_endpoint_port'))
        env['CONTENT_LENGTH'] = 0

        status, headers, body, status_code = access_resource(env, 'GET',
            '/v1' + self.os_path, True, None, None)

        if status:
            data = json.loads(body).get('volume')

            body = {}
            body['id'] = '/'.join([self.tenant_id, 'Volume', parts[0]])
            match_up(body, data, 'name', 'display_name')
            match_up(body, data, 'description', 'display_description')
            match_up(body, data, 'created', 'created_at')
            match_up(body, data, 'capacity', 'size')
            body['capacity'] = int(body['capacity']) * 1000000
            body['state'] = map_volume_state(data['status'])
            body['bootable'] = 'false'
            body['type'] = 'http://schemas.dmtf.org/cimi/1/mapped'

            operations = []
            operations.append(self._create_op('delete',
                '/'.join([self.tenant_id, 'volume',
                          parts[0]])))
            body['operations'] = operations


            if self.res_content_type == 'application/xml':
                response_data = {'Volume': body}
            else:
                body['resourceURI'] = '/'.join([self.uri_prefix,
                                                self.entity_uri])
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = status_code
            resp.body = new_content
            return resp
        else:
            resp = Response()
            resp.status = status_code
            resp.body = 'Volume could not be found'
            return resp

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = copy.copy(req.environ)

        env['SCRIPT_NAME'] = self.os_version
        env['PATH_INFO'] = self.os_path
        # we will always use json format to get Nova information
        env['HTTP_ACCEPT'] = 'application/json'

        # need to remove this header, otherwise, it will always take the
        # original request accept content type
        if env.has_key('nova.best_content_type'):
            env.pop('nova.best_content_type')
        new_req = Request(env)

        res = new_req.get_response(self.app)
        if res.status_int == 200:
            content = json.loads(res.body)
            body = {}
            body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
            body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri)
            body['entries'] = []
            flavors = content.get('flavors',[])
            for flavor in flavors:
                entry = {}
                entry['resourceURI'] = concat(self.uri_prefix,
                                            self.entity_uri, 'Entry')
                entry['machineConfiguration'] = \
                    {'href': concat(self.tenant_id,
                                    '/', 'MachineConfiguration/',
                                    flavor['id'])}
                entry['id'] = concat(self.tenant_id, '/',
                                     self.entity_uri, 'Entry/',
                                     flavor['id'])

                body['entries'].append(entry)

            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
 def get_component(self):
     filepath = self.request.GET.get('file', None)
     if '..' in filepath.split('/'):
         return self.httperror(status=400, body="Bad Request")
     mimetype = mimetypes.guess_type(filepath, False)
     component = self._load_component(filepath)
     if component is None:
         return self.httperror()
     response = Response()
     response.headers['Content-Type'] = mimetype[0]
     response.body = component
     return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env['SERVER_PORT'] = self.conf.get('volume_endpoint_port')
        env['SCRIPT_NAME'] = '/v1'
        env['HTTP_HOST'] = '%s:%s'%(self.conf.get('volume_endpoint_host'),
                                    self.conf.get('volume_endpoint_port'))

        status, headers, body = access_resource(env, 'GET',
                                               '/v1/' + self.os_path,
                                               True, None)
        if status:
            content = json.loads(body)
            body = {}
            body['resourceURI'] = '/'.join([self.uri_prefix.rstrip('/'),
                                            self.entity_uri])
            body['id'] = '/'.join([self.tenant_id, self.entity_uri])
            body['volumes'] = []
            volumes = content.get('volumes', [])
            for volume in volumes:
                entry = {}
                entry['resourceURI'] = '/'.join([self.uri_prefix.rstrip('/'),
                                                 'Volume'])
                entry['id'] = '/'.join([self.tenant_id, 'Volume',
                                        volume['id']])

                body['volumes'].append(entry)

            body['count'] = len(body['volumes'])
            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            resp = Response()
            resp.status = 404
            return resp

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def _capability(self, env, start_response):
        res = Response()
        res.status = 200
        res.headers['Content-Type'] = Consts.CDMI_APP_CAPABILITY
        res.headers[Consts.CDMI_VERSION] = Consts.CDMI_VERSION_VALUE

        body = {}
        body['objectType'] = Consts.CDMI_APP_CAPABILITY
        body['objectName'] = self.account_name
        body['capabilities'] = {}
        body['capabilities']['cdmi_list_children'] = True
        body['capabilities']['cdmi_create_container'] = True

        res.body = json.dumps(body, indent=2)
        return res

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

        res, is_container, headers, children = \
            self._check_resource_attribute(env, start_response)

        if res:
            return res

        res = Response()
        res.status = 200
        res.headers['Content-Type'] = Consts.CDMI_APP_CAPABILITY
        res.headers[Consts.CDMI_VERSION] = Consts.CDMI_VERSION_VALUE

        body = {}
        body['objectType'] = Consts.CDMI_APP_CAPABILITY

        if self.object_name:
            body['parentURI'] = concat_parts(self.cdmi_capability_id,
                                             self.account_name,
                                             self.container_name,
                                             self.parent_name) + '/'
        else:
            body['parentURI'] = concat_parts(self.cdmi_capability_id,
                                             self.account_name) + '/'

        body['capabilities'] = {}
        if is_container:
            if self.object_name:
                body['objectName'] = self.object_name + '/'
            else:
                body['objectName'] = self.container_name + '/'

            body['capabilities']['cdmi_list_children'] = True
            body['capabilities']['cdmi_read_metadata'] = True
            body['capabilities']['cdmi_modify_metadata'] = True
            body['capabilities']['cdmi_create_dataobject'] = True
            body['capabilities']['cdmi_delete_container'] = True
            body['capabilities']['cdmi_create_container'] = True
        else:
            body['objectName'] = self.object_name
            body['capabilities']['cdmi_read_value'] = True
            body['capabilities']['cdmi_read_metadata'] = True
            body['capabilities']['cdmi_modify_value'] = True
            body['capabilities']['cdmi_modify_metadata'] = True
            body['capabilities']['cdmi_delete_dataobject'] = True

        res.body = json.dumps(body, indent=2)
        return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        new_req = self._fresh_request(req)

        res = new_req.get_response(self.app)
        if res.status_int == 200:
            content = json.loads(res.body)
            body = {}
            body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
            body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri)
            body['entries'] = []
            machines = content.get('servers',[])
            for machine in machines:
                entry = {}
                entry['resourceURI'] = concat(self.uri_prefix,
                                            self.entity_uri, 'Entry')
                entry['machine'] = {'href': concat(self.tenant_id,
                                                   '/', 'Machine/',
                                                   machine['id'])}
                entry['id'] = concat(self.tenant_id, '/',
                                     self.entity_uri, 'Entry/',
                                     machine['id'])

                body['entries'].append(entry)

            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id, '/',
                                self.entity_uri, '/',
                                self.machine_id, '/',
                                self.address_key, '/',
                                self.machine_ip)
            adds = {}
            match_up(adds, data, 'addr', 'addresses/'+self.address_key)
            ips = adds.get('addr')
            if ips:
                for ip in ips:
                    if self.machine_ip == ip.get('addr'):
                        body['ip'] = self.machine_ip

            if self.res_content_type == 'application/xml':
                response_data = {'Address': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = '/'.join([self.os_path, self.image_id])

        new_req = Request(env)
        res = new_req.get_response(self.app)
        if res.status_int == 200:
            image = json.loads(res.body).get('image')
            if image:
                body = {}
                body['type'] = 'IMAGE'
                body['id'] = '/'.join([self.tenant_id, self.entity_uri,
                                       self.image_id])
                match_up(body, image, 'name', 'name')
                match_up(body, image, 'created', 'created')
                match_up(body, image, 'updated', 'updated')
                body['state'] = map_image_state(image['status'])
                body['imageLocation'] = body['id']

            if self.res_content_type == 'application/xml':
                response_data = {self.entity_uri: body}
            else:
                body['resourceURI'] = '/'.join([self.uri_prefix,
                                                self.entity_uri])
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res

        return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [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 headers['Content-Type'] [as 别名]
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """
        body = {}
        body['id'] = concat(self.tenant_id,
                            '/', self.entity_uri)
        body['name'] = self.entity_uri
        body['description'] = 'Cloud Entry Point'
        body['baseURI'] = concat(req.host_url, self.request_prefix, '/')

        body['machineConfigs'] = {'href':
                '/'.join([self.tenant_id, 'MachineConfigurationCollection'])}

        body['machines'] = {'href':
                '/'.join([self.tenant_id, 'MachineCollection'])}

        body['machineImages'] = {'href':
                '/'.join([self.tenant_id, 'MachineImageCollection'])}

        body['volumes'] = {'href':
                '/'.join([self.tenant_id, 'VolumeCollection'])}

        if self.res_content_type == 'application/xml':
            response_data = {'CloudEntryPoint': body}
        else:
            body['resourceURI'] = concat(self.uri_prefix,
                                   self.entity_uri)
            response_data = body

        new_content = make_response_data(response_data,
                                         self.res_content_type,
                                         self.metadata,
                                         self.uri_prefix)
        resp = Response()
        self._fixup_cimi_header(resp)
        resp.headers['Content-Type'] = self.res_content_type
        resp.status = 200
        resp.body = new_content
        return resp

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
def test_content_type_params_set_value_dict_empty():
    res = Response()
    res.headers['Content-Type'] = 'foo;bar'
    res.content_type_params = None
    eq_(res.headers['Content-Type'], 'foo')

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
def json_response(data):
    response = Response(json.dumps(data))
    response.headers['Content-Type'] = 'application/json'
    return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers['Content-Type'] [as 别名]
    def POST(self, req, *parts):
        """
        Handle POST machine request which will create a machine
        """

        try:
            request_data = get_request_data(req.body, self.req_content_type)
        except Exception as error:
            return get_err_response('MalformedBody')

        if request_data:
            data = request_data.get('body').get('MachineCreate')
            if not data:
                data = request_data.get('body')
            if data:
                new_body = {}
                match_up(new_body, data, 'name', 'name')

                keys = {'/cimiv1': '/v2',
                        'machineConfig': 'flavors',
                        'machineImage': 'images'}

                match_up(new_body, data, 'imageRef',
                         'machineTemplate/machineImage/href')
                new_body['imageRef'] = sub_path(new_body.get('imageRef'),
                                                keys)

                match_up(new_body, data, 'flavorRef',
                         'machineTemplate/machineConfig/href')
                new_body['flavorRef'] = sub_path(new_body.get('flavorRef'),
                                                 keys)

                new_req = self._fresh_request(req)

                adminPass = data.get('credentials', {}).get('password')
                if adminPass:
                    new_body['adminPass'] = adminPass

                new_req.body = json.dumps({'server':new_body})
                resp = new_req.get_response(self.app)
                if resp.status_int == 201:
                    # resource created successfully, we redirect the request
                    # to query machine
                    resp_data = json.loads(resp.body)
                    id = resp_data.get('server').get('id')
                    env = self._fresh_env(req)
                    env['PATH_INFO'] = concat(self.request_prefix,
                                              '/', self.tenant_id,
                                              '/servers/', id)
                    env['REQUEST_METHOD'] = 'GET'
                    new_req = Request(env)
                    resp = new_req.get_response(self.app)
                    resp.status = 201
                elif resp.status_int == 202:
                    resp_body_data = json.loads(resp.body).get('server')
                    id = resp_body_data.get('id')
                    resp_data = {}
                    match_up(resp_data, data, 'name', 'name')
                    match_up(resp_data, data, 'description', 'description')
                    resp_data['id'] = concat(self.tenant_id, '/machine/', id)
                    resp_data['credentials'] = {'userName': 'root',
                        'password': resp_body_data.get('adminPass')}
                    if self.res_content_type == 'application/xml':
                        response_data = {'Machine': resp_data}
                    else:
                        response_data = resp_data

                    new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.machine_metadata,
                                             self.uri_prefix)
                    resp = Response()
                    self._fixup_cimi_header(resp)
                    resp.headers['Content-Type'] = self.res_content_type
                    resp.status = 202
                    resp.body = new_content
                return resp
            else:
                return get_err_response('BadRequest')
        else:
            return get_err_response('BadRequest')