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

# 需要导入模块: 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)
            body["resourceURI"] = concat(self.uri_prefix, "/", self.entity_uri)
            body["entries"] = self._get_entry(data)

            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 __call__(self, req):
        if req.headers.get("X-Auth-Token"):
            # already has auth token
            pass
        else:
            # We expire the token every 10 minutes
            if time.time() - self.token_timestamp >= 600000:
                self.token_timestamp = time.time()
                self.token = None

            self.access_resource(req)

        if req.path == self.auth_id:
            res = Response()
            res.status = 200
            res.headers["Content-Type"] = "text/plain"
            res.body = str(self.tenant_id) + "\r\n"
            return res
        else:
            if self.sub_tenant_id:
                parts = req.environ.get("PATH_INFO").split("/")
                if len(parts) > 1 and self.tenant_id:
                    parts[1] = self.tenant_id
                    req.environ["PATH_INFO"] = "/".join(parts)
            return self.application

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers["Content-Type"] [as 别名]
 def GET(self, request):
     channel = request.GET["channel"]
     begin = request.GET["begin"]
     msg_hander = get_hander(channel)
     msg_json = msg_hander.get(begin)
     rs = Response()
     rs.headers["Content-Type"] = "application/json"
     rs.body = msg_json
     return rs

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers["Content-Type"] [as 别名]
 def hander(self, request):
     if not running:
         rs = Response()
         rs.headers["Content-Type"] = "application/json"
         rs.body = json.dumps("shutting down...")
         return rs
     method = request.method
     hander = getattr(self, method)
     return hander(request)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers["Content-Type"] [as 别名]
 def POST(self, request):
     channel = request.POST["channel"]
     msg = request.POST["msg"]
     channels.add(channel)
     msg_hander = get_hander(channel)
     point_json = msg_hander.post(msg)
     rs = Response()
     rs.headers["Content-Type"] = "application/json"
     rs.body = point_json
     return rs

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers["Content-Type"] [as 别名]
def demo_app(environ, start_response):
    req = Request(environ)

    body = "get_param: %s post_param: %s" % (
        req.GET.get("get_param", ""),
        req.POST.get("post_param", ""),
    )

    res = Response(body)
    res.headers["Content-Type"] = "text/plain"
    res.headers["X-Some-Header"] = "Foo Value"

    return res(environ, start_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 = 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"] = []
            images = content.get("images", [])
            for image in images:
                entry = {}
                entry["resourceURI"] = concat(self.uri_prefix, self.entity_uri, "Entry")
                entry["machineImage"] = {"href": concat(self.tenant_id, "/", "MachineImage/", image["id"])}
                entry["id"] = concat(self.tenant_id, "/", self.entity_uri, "Entry/", image["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 json_response(serializable, _disable_cors=False, *args, **kw):
    """
    Serializes a json objects and returns a webob.Response object with the
    serialized value as the response body and Content-Type: application/json.

    :param serializable: A json-serializable object

    Any extra arguments and keyword arguments are passed to the
    webob.Response.__init__ method.
    """
    response = Response(json.dumps(serializable), *args, **kw)
    response.headers["Content-Type"] = "application/json"

    if not _disable_cors:
        cors_headers = {
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
            "Access-Control-Allow-Headers": "Content-Type, X-Requested-With",
        }
        response.headers.update(cors_headers)

    return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers["Content-Type"] [as 别名]
    def chart(self, req):
        """Return a sparkline chart of the given type."""
        if Image is None or ImageDraw is None:
            # Cannot render
            return Response("Cannot render; PIL/Pillow is not installed", status="404 Not Found")
        typename = req.path_info_pop()
        data = self.history[typename]
        height = 20.0
        scale = height / max(data)
        im = Image.new("RGB", (len(data), int(height)), "white")
        draw = ImageDraw.Draw(im)
        draw.line([(i, int(height - (v * scale))) for i, v in enumerate(data)], fill="#009900")
        del draw

        f = BytesIO()
        im.save(f, "PNG")
        result = f.getvalue()

        res = Response()
        res.headers["Content-Type"] = "image/png"
        res.body = result
        return res

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

        query_string = env.get("QUERY_STRING", "")
        if len(query_string) > 0:
            params = parse_qs(query_string, True, False)
            new_qs = ""
            for key, value in params.items():
                if "value:bytes" == key.lower():
                    env["HTTP_RANGE"] = "bytes=" + "".join(value)
                else:
                    new_qs += key + "=" + "".join(value) + "&"
            env["QUERY_STRING"] = new_qs

        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

        if self.parent_name != "":
            body["parentURI"] = "/".join(
                ["", self.cdmi_root, self.account_name, self.container_name, self.parent_name, ""]
            )
        else:
            body["parentURI"] = "/".join(["", self.cdmi_root, self.account_name, self.container_name, ""])

        body["capabilitiesURI"] = "/".join(
            ["", self.cdmi_root, self.account_name, self.cdmi_capability_id, "dataobject/"]
        )

        body["completionStatus"] = "Complete"
        body["metadata"] = {}

        # Handling CDMI metadata
        body["metadata"] = self._process_metadata(headers)
        body["mimetype"] = headers.get("content-type", "")
        encoding = headers.get(Consts.VALUE_ENCODING, "7BIT")
        body["valuetransferencoding"] = encoding
        if encoding.lower() == Consts.ENCODING_BASE64 or "text/" not in body["mimetype"]:
            body["valuetransferencoding"] = Consts.ENCODING_BASE64
            body["value"] = base64.encodestring(object_body).strip("\n")
        else:
            body["value"] = object_body
        body["valuerange"] = "0-" + str(len(object_body) - 1)
        if env.get("HTTP_ACCEPT", "").find("multipart/") >= 0:
            # It is a multipart request, we need to make up the body
            boundary = "%.32x" % random.randint(0, 256 ** 16)
            res.body = "\r\n--" + boundary + "\r\n"
            res.body += "Content-Type: application/cdmi-object\r\n\r\n"
            value = body["value"]
            del body["value"]
            res.body += json.dumps(body, indent=2)
            res.body += "\r\n--" + boundary + "\r\n"
            res.body += "Content-Type: " + body["mimetype"] + "\r\n"
            res.body += "Content-Range: bytes 0-" + str(len(value) - 1) + "/" + str(len(value)) + "\r\n"
            res.body += "Content-Transfer-Encoding: " + body["valuetransferencoding"] + "\r\n\r\n"
            res.body += value
            res.body += "\r\n--" + boundary + "--"
            res.headers["Content-Type"] = "multipart/mixed;boundary=" + boundary
        else:
            res.body = json.dumps(body, indent=2)
            res.status_int = os_res.status_int

        return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import headers["Content-Type"] [as 别名]
 ):
     file.close()
     self.logger.timing_since("GET.timing", start_time)
     return HTTPPreconditionFailed(request=request)
 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)