Python HTTPHeaders.items方法代码示例

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import items [as 别名]
def request_to_curl_string(request):
    def _escape_apos(s):
        return s.replace("'", "'\"'\"'")

    try:
        if request.body:
            request.body.decode('ascii')
        is_binary_data = False
    except UnicodeError:
        is_binary_data = True

    curl_headers = HTTPHeaders(request.headers)
    if request.body and 'Content-Length' not in curl_headers:
        curl_headers['Content-Length'] = len(request.body)

    if is_binary_data:
        curl_echo_data = "echo -e {} |".format(repr(request.body))
        curl_data_string = '--data-binary @-'
    else:
        curl_echo_data = ''
        curl_data_string = "--data '{}'".format(_escape_apos(str(request.body))) if request.body else ''

    return "{echo} curl -X {method} '{url}' {headers} {data}".format(
        echo=curl_echo_data,
        method=request.method,
        url=request.url,
        headers=' '.join("-H '{}: {}'".format(k, _escape_apos(str(v))) for k, v in curl_headers.items()),
        data=curl_data_string
    ).strip()

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import items [as 别名]
 def test_pickle_roundtrip(self):
     headers = HTTPHeaders()
     headers.add('Set-Cookie', 'a=b')
     headers.add('Set-Cookie', 'c=d')
     headers.add('Content-Type', 'text/html')
     pickled = pickle.dumps(headers)
     unpickled = pickle.loads(pickled)
     self.assertEqual(sorted(headers.get_all()), sorted(unpickled.get_all()))
     self.assertEqual(sorted(headers.items()), sorted(unpickled.items()))

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import items [as 别名]
def test_proxy_pack_httprequest():
    method = "POST"
    uri = "/testapp/event1"
    version = 'HTTP/1.0'
    h = HTTPHeaders({"content-type": "text/html", "Ab": "blabla"})
    body = "BODY"
    host = "localhost"
    req = HTTPServerRequest(method=method, uri=uri,
                            version=version, headers=h, connection=_FakeConnection(),
                            body=body, host=host)
    res = pack_httprequest(req)
    assert res[0] == method, "method has been parsed unproperly"
    assert res[1] == uri, "uri has been parsed unproperly"
    assert res[2] == "1.0", "version has been parsed unproperly %s" % res[2]
    assert res[3] == h.items(), "headers has been parsed unproperly %s" % res[3]
    assert res[4] == body, "body has been parsed unproperly"

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import items [as 别名]
    def set_default_headers(self):
        """
        Set any headers passed as tornado_settings['headers'].

        By default sets Content-Security-Policy of frame-ancestors 'self'.
        Also responsible for setting content-type header
        """
        # wrap in HTTPHeaders for case-insensitivity
        headers = HTTPHeaders(self.settings.get('headers', {}))
        headers.setdefault("X-JupyterHub-Version", __version__)

        for header_name, header_content in headers.items():
            self.set_header(header_name, header_content)

        if 'Access-Control-Allow-Headers' not in headers:
            self.set_header('Access-Control-Allow-Headers', 'accept, content-type, authorization')
        if 'Content-Security-Policy' not in headers:
            self.set_header('Content-Security-Policy', self.content_security_policy)
        self.set_header('Content-Type', self.get_content_type())

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import items [as 别名]
class ProxyHandler(web.RequestHandler):

    def initialize(self):
        self.proxy_headers = HTTPHeaders()
        # create a new client for each request
        self.http_client = AsyncHTTPClient(max_clients=1)
        self.in_request_headers = False
        self.id = id(self)
        self.request_data = None

    def validate_request(self, request_data):
        if self.request.headers.get("X-Proxy-Agent") == X_Proxy_Agent:
            self.set_status(403, "recursion rejected")
            return False

        try:
            RequstDataValidator.validate(request_data)
        except ValidationError as err:
            self.set_status(400, "/%s: %s" % (
                "::".join(err.path), err.message
            ))
            return False
        return True

    def get_post_request_data(self):
        try:
            request_data = json.loads(self.request.body.decode("utf-8"))
        except ValueError as err:
            self.set_status(400, str(err))
            return
        return request_data

    def _set_proxy_headers(self):
        for k, v in self.proxy_headers.items():
            if k not in RESPONSE_EXCLUDE_HEADERS:
                logger.debug(
                    "[%s] write header %s: %s", self.id, k, v,
                )
                self.set_header(k, v)

    def _streaming_callback(self, chunk):
        if self._finished:
            return

        if not self._headers_written:
            self._set_proxy_headers()
            self.flush()
        self.in_request_headers = False
        self.write(chunk)
        logger.debug("[%s] chunk length %s", self.id, len(chunk))

    def _header_callback(self, header_line):
        if not self.in_request_headers:
            start_line = parse_response_start_line(header_line)
            self.set_status(start_line.code, start_line.reason)
            self.in_request_headers = True
        elif not HTTPHeaderEndLineRex.match(header_line):
            self.proxy_headers.parse_line(header_line)

    def _get_request_body(self, request_data):
        post_type = request_data.get("post_type")
        data = request_data.get("data")
        if data is None:
            return None

        if post_type == "form":
            body = urlencode(data or {})
        elif post_type == "json":
            body = json.dumps(data)
        elif post_type == "string" and isinstance(data, basestring):
            body = native_str(data)
        else:
            body = None
        return body

    @gen.coroutine
    def _get_keystone_auth_headers(self, auth_info, validate_cert=True):
        try:
            response = yield self.http_client.fetch(
                auth_info.get("auth_url"), method="POST",
                headers={"Content-Type": "application/json"},
                validate_cert=validate_cert,
                body=json.dumps({
                    "auth": {
                        "passwordCredentials": {
                            "username": auth_info.get("user_name"),
                            "password": auth_info.get("password"),
                        },
                        "tenantName": auth_info.get("tenant_name"),
                    }
                })
            )
        except Exception as err:
            logger.info(err)
            self.set_status(503, "keystone auth error")
            raise gen.Return()

        if response.error or response.code != 200:
            logger.info("keystone auth error")
            self.set_status(407, "keystone auth error")
#.........这里部分代码省略.........