Python HTTPHeaders.parse_line方法代码示例

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [as 别名]
def headers_parse_simple(headers: str) -> HTTPHeaders:
    h = HTTPHeaders()
    for line in headers.split("\n"):
        if line.endswith("\r"):
            line = line[:-1]
        if line:
            h.parse_line(line)
    return h

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [as 别名]
def parse_headers(data):
    headers = HTTPHeaders()

    for line in data.splitlines():
        if line:
            try:
                headers.parse_line(line)
            except Exception, e:
                break

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [as 别名]
 def _curl_header_callback(
     self,
     headers: httputil.HTTPHeaders,
     header_callback: Callable[[str], None],
     header_line_bytes: bytes,
 ) -> None:
     header_line = native_str(header_line_bytes.decode("latin1"))
     if header_callback is not None:
         self.io_loop.add_callback(header_callback, header_line)
     # header_line as returned by curl includes the end-of-line characters.
     # whitespace at the start should be preserved to allow multi-line headers
     header_line = header_line.rstrip()
     if header_line.startswith("HTTP/"):
         headers.clear()
         try:
             (__, __, reason) = httputil.parse_response_start_line(header_line)
             header_line = "X-Http-Reason: %s" % reason
         except httputil.HTTPInputError:
             return
     if not header_line:
         return
     headers.parse_line(header_line)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [as 别名]
 def read_headers(self):
     parser = HTTPHeaders()
     lastkey = None
     count = 0
     while True:
         line = yield self.stream.read_until(b'\r\n',max_bytes=self.max_header_length)
         if len(line) == 2:
             break
         self.readed += len(line)
         count += 1
         line = line.decode('utf-8')
         if self.max_headers and count > self.max_headers:
             raise iostream.UnsatisfiableReadError("Too many headers "+line+' '+json.dumps(parser))
         parser.parse_line(line)
         if lastkey is None:
             lastkey = parser._last_key
         elif lastkey != parser._last_key:
             self.request.received_header(lastkey,parser[lastkey])
             lastkey = parser._last_key
     self.request.request_headers = parser
     self.request.received_headers()
     note('received all headers')
     raise gen.Return(parser)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [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")
#.........这里部分代码省略.........

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [as 别名]
def headers_parse_re(headers: str) -> HTTPHeaders:
    h = HTTPHeaders()
    for line in _CRLF_RE.split(headers):
        if line:
            h.parse_line(line)
    return h

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse_line [as 别名]

#.........这里部分代码省略.........
                          method=self.request.method,
                          body=self.request.body,
                          headers=self.request.headers,
                          follow_redirects=False,
                          if_modified_since=cache_time,
                          allow_nonstandard_methods=True,
                          connect_timeout=int(self.settings['proxy']['timeout']),
                          request_timeout=2 ** 31 - 1,
                          header_callback=self.process_header,
                          streaming_callback=self.process_body,
                          callback=self.process_finish)

    def process_header(self, line):
        header = line.strip()
        app_log.debug('response header %s', header)
        if header:
            if self.req_headers is None:
                self.req_headers = HTTPHeaders()
                _, status, _ = header.split(' ', 2)
                status = int(status)

                if status == 599:
                    # network error but cache file exists
                    if self.cache_file.exists():
                        status = 200
                elif status == 304:
                    status = 200
                elif status == 200:
                    app_log.debug('prepare temp file for %s', self.req_path)
                    self.cache_fd = NamedTemporaryFile(dir=str(self.cache_dir), delete=False)

                self.set_status(status)
            else:
                self.req_headers.parse_line(line)
            return

        for header in ('Date', 'Cache-Control', 'Server', 'Content-Type', 'Location'):
            val = self.req_headers.get(header)
            if val:
                self.set_header(header, val)

        if 'content-encoding' not in self.req_headers:
            val = self.req_headers.get('Content-Length')
            if val:
                self.set_header('Content-Length', val)

        self.flush()

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

        if self.cache_fd is not None:
            self.cache_fd.write(chunk)

        self.write(chunk)
        self.flush()

    def process_finish(self, response):
        app_log.debug('process finish %s', self.req_path)
        if self._finished or self.cache_used:
            app_log.debug('skip process finish')
            return

        app_log.info('code %s fo %s', response.code, self.request.uri)