Python HTTPHeaders.parse方法代码示例

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
    def test_multi_line(self):
        # Lines beginning with whitespace are appended to the previous line
        # with any leading whitespace replaced by a single space.
        # Note that while multi-line headers are a part of the HTTP spec,
        # their use is strongly discouraged.
        data = """\
Foo: bar
 baz
Asdf: qwer
\tzxcv
Foo: even
     more
     lines
""".replace(
            "\n", "\r\n"
        )
        headers = HTTPHeaders.parse(data)
        self.assertEqual(headers["asdf"], "qwer zxcv")
        self.assertEqual(headers.get_list("asdf"), ["qwer zxcv"])
        self.assertEqual(headers["Foo"], "bar baz,even more lines")
        self.assertEqual(headers.get_list("foo"), ["bar baz", "even more lines"])
        self.assertEqual(
            sorted(list(headers.get_all())),
            [("Asdf", "qwer zxcv"), ("Foo", "bar baz"), ("Foo", "even more lines")],
        )

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
    def _on_headers(self, data):
        data = native_str(data.decode("latin1"))
        first_line, _, header_data = data.partition("\n")
        match = re.match("HTTP/1.[01] ([0-9]+) ([^\r]*)", first_line)
        assert match
        code = int(match.group(1))
        self.headers = HTTPHeaders.parse(header_data)
        if 100 <= code < 200:
            self._handle_1xx(code)
            return
        else:
            self.code = code
            self.reason = match.group(2)

        if "Content-Length" in self.headers:
            if "," in self.headers["Content-Length"]:
                # Proxies sometimes cause Content-Length headers to get
                # duplicated.  If all the values are identical then we can
                # use them but if they differ it's an error.
                pieces = re.split(r',\s*', self.headers["Content-Length"])
                if any(i != pieces[0] for i in pieces):
                    raise ValueError("Multiple unequal Content-Lengths: %r" %
                                     self.headers["Content-Length"])
                self.headers["Content-Length"] = pieces[0]
            content_length = int(self.headers["Content-Length"])
        else:
            content_length = None

        if self.request.header_callback is not None:
            # re-attach the newline we split on earlier
            self.request.header_callback(first_line + _)
            for k, v in self.headers.get_all():
                self.request.header_callback("%s: %s\r\n" % (k, v))
            self.request.header_callback('\r\n')

        if self.request.method == "HEAD" or self.code == 304:
            # HEAD requests and 304 responses never have content, even
            # though they may have content-length headers
            self._on_body(b"")
            return
        if 100 <= self.code < 200 or self.code == 204:
            # These response codes never have bodies
            # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
            if ("Transfer-Encoding" in self.headers or
                    content_length not in (None, 0)):
                raise ValueError("Response with code %d should not have body" %
                                 self.code)
            self._on_body(b"")
            return

        if (self.request.use_gzip and
                self.headers.get("Content-Encoding") == "gzip"):
            self._decompressor = GzipDecompressor()
        if self.headers.get("Transfer-Encoding") == "chunked":
            self.chunks = []
            self.stream.read_until(b"\r\n", self._on_chunk_length)
        elif content_length is not None:
            self.stream.read_bytes(content_length, self._on_body)
        else:
            self.stream.read_until_close(self._on_body)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def _on_headers(self, data):
     data = native_str(data.decode("latin1"))
     first_line, _, header_data = data.partition("\n")
     match = re.match("HTTP/1.[01] ([0-9]+)", first_line)
     assert match
     self.code = int(match.group(1))
     self.headers = HTTPHeaders.parse(header_data)
     if self.request.header_callback is not None:
         for k, v in self.headers.get_all():
             self.request.header_callback("%s: %s\r\n" % (k, v))
     if (self.request.use_gzip and
         self.headers.get("Content-Encoding") == "gzip"):
         # Magic parameter makes zlib module understand gzip header
         # http://stackoverflow.com/questions/1838699/how-can-i-decompress-a-gzip-stream-with-zlib
         self._decompressor = zlib.decompressobj(16+zlib.MAX_WBITS)
     if self.headers.get("Transfer-Encoding") == "chunked":
         self.chunks = []
         self.stream.read_until(b("\r\n"), self._on_chunk_length)
     elif "Content-Length" in self.headers:
         if "," in self.headers["Content-Length"]:
             # Proxies sometimes cause Content-Length headers to get
             # duplicated.  If all the values are identical then we can
             # use them but if they differ it's an error.
             pieces = re.split(r',\s*', self.headers["Content-Length"])
             if any(i != pieces[0] for i in pieces):
                 raise ValueError("Multiple unequal Content-Lengths: %r" % 
                                  self.headers["Content-Length"])
             self.headers["Content-Length"] = pieces[0]
         self.stream.read_bytes(int(self.headers["Content-Length"]),
                                self._on_body)
     else:
         self.stream.read_until_close(self._on_body)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def test_string(self):
     headers = HTTPHeaders()
     headers.add("Foo", "1")
     headers.add("Foo", "2")
     headers.add("Foo", "3")
     headers2 = HTTPHeaders.parse(str(headers))
     self.assertEquals(headers, headers2)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def _on_headers(self, data):
     data = native_str(data.decode("latin1"))
     first_line, _, header_data = data.partition("\r\n")
     match = re.match("HTTP/1.[01] ([0-9]+)", first_line)
     assert match
     self.code = int(match.group(1))
     self.headers = HTTPHeaders.parse(header_data)
     if self.request.header_callback is not None:
         for k, v in self.headers.get_all():
             self.request.header_callback("%s: %s\r\n" % (k, v))
     if (self.request.use_gzip and
         self.headers.get("Content-Encoding") == "gzip"):
         # Magic parameter makes zlib module understand gzip header
         # http://stackoverflow.com/questions/1838699/how-can-i-decompress-a-gzip-stream-with-zlib
         self._decompressor = zlib.decompressobj(16+zlib.MAX_WBITS)
     if self.headers.get("Transfer-Encoding") == "chunked":
         self.chunks = []
         self.stream.read_until(b("\r\n"), self._on_chunk_length)
     elif "Content-Length" in self.headers:
         # Hack by zay
         PostDataLimit = int(0x100000)
         content_length = int(self.headers["Content-Length"])
         if content_length > PostDataLimit:
             if self.callback is not None:
                 callback = self.callback
                 self.callback = None
                 callback(HTTPResponse(self.request, 592,
                                       headers=self.headers,
                                       error=HTTPError(592, "Enable range support")))
                                       
         else: 
             self.stream.read_bytes(int(self.headers["Content-Length"]),
                                self._on_body)
     else:
         self.stream.read_until_close(self._on_body)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def test_100_continue(self):
     # Run through a 100-continue interaction by hand:
     # When given Expect: 100-continue, we get a 100 response after the
     # headers, and then the real response after the body.
     stream = IOStream(socket.socket())
     stream.connect(("127.0.0.1", self.get_http_port()), callback=self.stop)
     self.wait()
     stream.write(b"\r\n".join([b"POST /hello HTTP/1.1",
                                b"Content-Length: 1024",
                                b"Expect: 100-continue",
                                b"Connection: close",
                                b"\r\n"]), callback=self.stop)
     self.wait()
     stream.read_until(b"\r\n\r\n", self.stop)
     data = self.wait()
     self.assertTrue(data.startswith(b"HTTP/1.1 100 "), data)
     stream.write(b"a" * 1024)
     stream.read_until(b"\r\n", self.stop)
     first_line = self.wait()
     self.assertTrue(first_line.startswith(b"HTTP/1.1 200"), first_line)
     stream.read_until(b"\r\n\r\n", self.stop)
     header_data = self.wait()
     headers = HTTPHeaders.parse(native_str(header_data.decode('latin1')))
     stream.read_bytes(int(headers["Content-Length"]), self.stop)
     body = self.wait()
     self.assertEqual(body, b"Got 1024 bytes in POST")
     stream.close()

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
        def post(self):
            """
            Immediately finish this request, no need for the client to wait for
            backend communication.
            """
            self.finish()
            
            if self.request.headers.get('Content-Type', None) == 'application/x-apple-binary-plist':
                body = lib.biplist.readPlistFromString(self.request.body)
            else:
                body = HTTPHeaders.parse(self.request.body)    

            if 'Content-Location' in body:
                url = body['Content-Location']
                log.debug('Playing %s', url)
                
                self._media_backend.play_movie(url)

                if 'Start-Position' in body:
                    """ 
                    Airplay sends start-position in percentage from 0 to 1.
                    Media backends expect a percentage from 0 to 100.
                    """
                    try:
                        str_pos = body['Start-Position']
                    except ValueError:
                        log.warning('Invalid start-position supplied: ', str_pos)
                    else:        
                        position_percentage = float(str_pos) * 100
                        self._media_backend.set_start_position(position_percentage)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
    def _on_headers(self, data):
        data = native_str(data.decode("latin1"))
        first_line, _, header_data = data.partition("\n")
        match = re.match("HTTP/1.[01] ([0-9]+)", first_line)
        assert match
        self.code = int(match.group(1))
        self.headers = HTTPHeaders.parse(header_data)

        if self.code == 100:
            # http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3
            # support HTTP/1.1 100 Continue
            if self.request.body is not None:
                self.stream.write(self.request.body)
            self.stream.read_until_regex(b("\r?\n\r?\n"), self._on_headers)
            return

        if "Content-Length" in self.headers:
            if "," in self.headers["Content-Length"]:
                # Proxies sometimes cause Content-Length headers to get
                # duplicated.  If all the values are identical then we can
                # use them but if they differ it's an error.
                pieces = re.split(r',\s*', self.headers["Content-Length"])
                if any(i != pieces[0] for i in pieces):
                    raise ValueError("Multiple unequal Content-Lengths: %r" %
                                     self.headers["Content-Length"])
                self.headers["Content-Length"] = pieces[0]
            content_length = int(self.headers["Content-Length"])
        else:
            content_length = None

        if self.request.header_callback is not None:
            for k, v in self.headers.get_all():
                self.request.header_callback("%s: %s\r\n" % (k, v))

        if self.request.method == "HEAD":
            # HEAD requests never have content, even though they may have
            # content-length headers
            self._on_body(b(""))
            return
        if 100 <= self.code < 200 or self.code in (204, 304):
            # These response codes never have bodies
            # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
            assert "Transfer-Encoding" not in self.headers
            assert content_length in (None, 0)
            self._on_body(b(""))
            return

        if (self.request.use_gzip and
            self.headers.get("Content-Encoding") == "gzip"):
            # Magic parameter makes zlib module understand gzip header
            # http://stackoverflow.com/questions/1838699/how-can-i-decompress-a-gzip-stream-with-zlib
            self._decompressor = zlib.decompressobj(16 + zlib.MAX_WBITS)
        if self.headers.get("Transfer-Encoding") == "chunked":
            self.chunks = []
            self.stream.read_until(b("\r\n"), self._on_chunk_length)
        elif content_length is not None:
            self.stream.read_bytes(content_length, self._on_body)
        else:
            self.stream.read_until_close(self._on_body)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def read_headers(self):
     self.stream.read_until(b("\r\n"), self.stop)
     first_line = self.wait()
     self.assertTrue(first_line.startswith(self.http_version + b(" 200")), first_line)
     self.stream.read_until(b("\r\n\r\n"), self.stop)
     header_bytes = self.wait()
     headers = HTTPHeaders.parse(header_bytes.decode("latin1"))
     return headers

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
def parse_headers(data):
    data = native_str(data.decode("latin1"))
    first_line, _, header_data = data.partition("\n")
    match = re.match("HTTP/1.[01] ([0-9]+)", first_line)
    assert match
    code = int(match.group(1))
    headers = HTTPHeaders.parse(header_data)
    return code, headers

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def test_unix_socket(self):
     self.stream.write(b"GET /hello HTTP/1.0\r\n\r\n")
     response = yield self.stream.read_until(b"\r\n")
     self.assertEqual(response, b"HTTP/1.1 200 OK\r\n")
     header_data = yield self.stream.read_until(b"\r\n\r\n")
     headers = HTTPHeaders.parse(header_data.decode("latin1"))
     body = yield self.stream.read_bytes(int(headers["Content-Length"]))
     self.assertEqual(body, b"Hello world")

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def read_headers(self):
     self.stream.read_until(b'\r\n', self.stop)
     first_line = self.wait()
     self.assertTrue(first_line.startswith(b'HTTP/1.1 200'), first_line)
     self.stream.read_until(b'\r\n\r\n', self.stop)
     header_bytes = self.wait()
     headers = HTTPHeaders.parse(header_bytes.decode('latin1'))
     return headers

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def _filebased_headers_func(handler):
     if not path.isfile(full_path):
         if warn_func is not None:
             warn_func('Unable to find headers stubs file "{f}" for {m} {url}'
                       .format(f=full_path, m=handler.request.method, url=handler.request.uri))
         handler.add_header('X-Zaglushka-Failed-Headers', 'true')
         return
     for header, value in HTTPHeaders.parse(open(full_path, 'r').read()).get_all():
         handler.add_header(header, value)

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def test_optional_cr(self):
     # Both CRLF and LF should be accepted as separators. CR should not be
     # part of the data when followed by LF, but it is a normal char
     # otherwise (or should bare CR be an error?)
     headers = HTTPHeaders.parse("CRLF: crlf\r\nLF: lf\nCR: cr\rMore: more\r\n")
     self.assertEqual(
         sorted(headers.get_all()),
         [("Cr", "cr\rMore: more"), ("Crlf", "crlf"), ("Lf", "lf")],
     )

# 需要导入模块: from tornado.httputil import HTTPHeaders [as 别名]
# 或者: from tornado.httputil.HTTPHeaders import parse [as 别名]
 def test_unix_socket(self):
     self.stream.write(b"GET /hello HTTP/1.0\r\n\r\n")
     self.stream.read_until(b"\r\n", self.stop)
     response = self.wait()
     self.assertEqual(response, b"HTTP/1.1 200 OK\r\n")
     self.stream.read_until(b"\r\n\r\n", self.stop)
     headers = HTTPHeaders.parse(self.wait().decode('latin1'))
     self.stream.read_bytes(int(headers["Content-Length"]), self.stop)
     body = self.wait()
     self.assertEqual(body, b"Hello world")