U lu f ?@sdZddlZddlZddlmZddlmZmZddlm Z ddlm Z ddlm Z ddl m Z dd lmZddlZdd lmZmZmZmZmZmZmZmZmZejrdd lmZGd d d e ee jZGddde jZGddde Z!Gddde jZ"e j#Z$dS)aA non-blocking, single-threaded HTTP server. Typical applications have little direct interaction with the `HTTPServer` class except to start a server at the beginning of the process (and even that is often done indirectly via `tornado.web.Application.listen`). .. versionchanged:: 4.0 The ``HTTPRequest`` class that used to live in this module has been moved to `tornado.httputil.HTTPServerRequest`. The old name remains as an alias. N) native_str)HTTP1ServerConnectionHTTP1ConnectionParameters)httputil)iostream)netutil) TCPServer) Configurable) UnionAnyDictCallableListTypeTupleOptional Awaitable)Setc@seZdZdZeeddddZdeeje ej gdffe e e ee eefejfe ee e ee ee ee ee ee ee eedddd Zeeed d d Zeeed d dZdd ddZejeddddZeej ej!dddZ"eddddZ#dS) HTTPServeraA non-blocking, single-threaded HTTP server. A server is defined by a subclass of `.HTTPServerConnectionDelegate`, or, for backwards compatibility, a callback that takes an `.HTTPServerRequest` as an argument. The delegate is usually a `tornado.web.Application`. `HTTPServer` supports keep-alive connections by default (automatically for HTTP/1.1, or for HTTP/1.0 when the client requests ``Connection: keep-alive``). If ``xheaders`` is ``True``, we support the ``X-Real-Ip``/``X-Forwarded-For`` and ``X-Scheme``/``X-Forwarded-Proto`` headers, which override the remote IP and URI scheme/protocol for all requests. These headers are useful when running Tornado behind a reverse proxy or load balancer. The ``protocol`` argument can also be set to ``https`` if Tornado is run behind an SSL-decoding proxy that does not set one of the supported ``xheaders``. By default, when parsing the ``X-Forwarded-For`` header, Tornado will select the last (i.e., the closest) address on the list of hosts as the remote host IP address. To select the next server in the chain, a list of trusted downstream hosts may be passed as the ``trusted_downstream`` argument. These hosts will be skipped when parsing the ``X-Forwarded-For`` header. To make this server serve SSL traffic, send the ``ssl_options`` keyword argument with an `ssl.SSLContext` object. For compatibility with older versions of Python ``ssl_options`` may also be a dictionary of keyword arguments for the `ssl.SSLContext.wrap_socket` method.:: ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_ctx.load_cert_chain(os.path.join(data_dir, "mydomain.crt"), os.path.join(data_dir, "mydomain.key")) HTTPServer(application, ssl_options=ssl_ctx) `HTTPServer` initialization follows one of three patterns (the initialization methods are defined on `tornado.tcpserver.TCPServer`): 1. `~tornado.tcpserver.TCPServer.listen`: single-process:: async def main(): server = HTTPServer() server.listen(8888) await asyncio.Event.wait() asyncio.run(main()) In many cases, `tornado.web.Application.listen` can be used to avoid the need to explicitly create the `HTTPServer`. While this example does not create multiple processes on its own, when the ``reuse_port=True`` argument is passed to ``listen()`` you can run the program multiple times to create a multi-process service. 2. `~tornado.tcpserver.TCPServer.add_sockets`: multi-process:: sockets = bind_sockets(8888) tornado.process.fork_processes(0) async def post_fork_main(): server = HTTPServer() server.add_sockets(sockets) await asyncio.Event().wait() asyncio.run(post_fork_main()) The ``add_sockets`` interface is more complicated, but it can be used with `tornado.process.fork_processes` to run a multi-process service with all worker processes forked from a single parent. ``add_sockets`` can also be used in single-process servers if you want to create your listening sockets in some way other than `~tornado.netutil.bind_sockets`. Note that when using this pattern, nothing that touches the event loop can be run before ``fork_processes``. 3. `~tornado.tcpserver.TCPServer.bind`/`~tornado.tcpserver.TCPServer.start`: simple **deprecated** multi-process:: server = HTTPServer() server.bind(8888) server.start(0) # Forks multiple sub-processes IOLoop.current().start() This pattern is deprecated because it requires interfaces in the `asyncio` module that have been deprecated since Python 3.10. Support for creating multiple processes in the ``start`` method will be removed in a future version of Tornado. .. versionchanged:: 4.0 Added ``decompress_request``, ``chunk_size``, ``max_header_size``, ``idle_connection_timeout``, ``body_timeout``, ``max_body_size`` arguments. Added support for `.HTTPServerConnectionDelegate` instances as ``request_callback``. .. versionchanged:: 4.1 `.HTTPServerConnectionDelegate.start_request` is now called with two arguments ``(server_conn, request_conn)`` (in accordance with the documentation) instead of one ``(request_conn)``. .. versionchanged:: 4.2 `HTTPServer` is now a subclass of `tornado.util.Configurable`. .. versionchanged:: 4.5 Added the ``trusted_downstream`` argument. .. versionchanged:: 5.0 The ``io_loop`` argument has been removed. N)argskwargsreturncOsdSN)selfrrrr6/tmp/pip-unpacked-wheel-bmg6zs32/tornado/httpserver.py__init__szHTTPServer.__init__F)request_callback no_keep_alivexheaders ssl_optionsprotocoldecompress_request chunk_sizemax_header_sizeidle_connection_timeout body_timeout max_body_sizemax_buffer_sizetrusted_downstreamrc CsR||_||_||_t|||| p d| | |d|_tj||| |dt|_| |_ dS)Ni) decompressr#r$Zheader_timeoutr'r&r)r r(Zread_chunk_size) rrr!r conn_paramsrrset _connectionsr))rrrrr r!r"r#r$r%r&r'r(r)rrr initializes( zHTTPServer.initializercCstSrrclsrrrconfigurable_baseszHTTPServer.configurable_basecCstSrr0r1rrrconfigurable_defaultszHTTPServer.configurable_defaultcs(|jr$tt|j}|IdHqdS)a&Close all open connections and asynchronously wait for them to finish. This method is used in combination with `~.TCPServer.stop` to support clean shutdowns (especially for unittests). Typical usage would call ``stop()`` first to stop accepting new connections, then ``await close_all_connections()`` to wait for existing connections to finish. This method does not currently close open websocket connections. Note that this method is a coroutine and must be called with ``await``. N)r-nextiterclose)rconnrrrclose_all_connectionssz HTTPServer.close_all_connections)streamaddressrcCs:t|||j|j}t||j|}|j|||dSr)_HTTPRequestContextr!r)rr+r-addZ start_serving)rr:r;contextr8rrr handle_streams zHTTPServer.handle_stream) server_conn request_connrcCs>t|jtjr|j||}n t|j|}|jr:t||}|Sr) isinstancerrHTTPServerConnectionDelegate start_request_CallableAdapterr _ProxyAdapter)rr@rAdelegaterrrrDs   zHTTPServer.start_request)r@rcCs|jtt|dSr)r-removetypingcastr)rr@rrron_closeszHTTPServer.on_close) FFNNFNNNNNNN)$__name__ __module__ __qualname____doc__r rr rrCr HTTPServerRequestboolrr strssl SSLContextintfloatrr. classmethodrr r3r4r9rIOStreamrr?objectHTTPConnectionHTTPMessageDelegaterDrKrrrrr.sZm  ,  rc@seZdZeejgdfejddddZeej ej fej e e ddddZee e ddd d Zdd d d Zdd ddZdS)rEN)rrArcCs"||_||_d|_d|_g|_dSr) connectionrrequestrG_chunks)rrrArrrrs z_CallableAdapter.__init__ start_lineheadersrcCs"tj|jttj||d|_dS)N)r\r`ra)rrPr\rIrJRequestStartLiner]rr`rarrrheaders_receiveds  z!_CallableAdapter.headers_receivedchunkrcCs|j|dSr)r^appendrrfrrr data_receiveds z_CallableAdapter.data_receivedr/cCs8|jdk std|j|j_|j||jdS)N)r]AssertionErrorjoinr^bodyZ _parse_bodyrrrrrfinish s z_CallableAdapter.finishcCs|`dSr)r^rnrrron_connection_close&sz$_CallableAdapter.on_connection_close)rLrMrNr rrPrZrr rbResponseStartLine HTTPHeadersrrrdbytesrirorprrrrrEs  rEc@s`eZdZd ejeeeeeeddddZ edddZ e j ddd d Z ddd d ZdS)r<N)r:r;r!r)rcCs||_|jdk r|jj|_nd|_|jtjtjfkrH|dk rH|d|_nd|_|rZ||_nt|t j rnd|_nd|_|j|_ |j|_ t |pg|_dS)Nrz0.0.0.0httpshttp)r;socketfamilyaddress_familyAF_INETAF_INET6 remote_ipr!rBrZ SSLIOStream_orig_remote_ip_orig_protocolr,r))rr:r;r!r)rrrr+s$    z_HTTPRequestContext.__init__r/cCs<|jtjtjfkr|jSt|jtr.t|jSt |jSdSr) rxrvryrzr{rBr;rsrrRrnrrr__str__Ms   z_HTTPRequestContext.__str__)rarcCs|d|j}ddt|dDD]}||jkr&q:q&|d|}t|rV||_|d|d|j}|r|dd}|d kr||_d S) z2Rewrite the ``remote_ip`` and ``protocol`` fields.zX-Forwarded-Forcss|]}|VqdSr)strip).0Zcandrrr ]sz6_HTTPRequestContext._apply_xheaders..,z X-Real-IpzX-SchemezX-Forwarded-Proto)rurtN) getr{reversedsplitr)rZ is_valid_ipr!r)rraipZ proto_headerrrr_apply_xheadersXs    z#_HTTPRequestContext._apply_xheaderscCs|j|_|j|_dS)zUndo changes from `_apply_xheaders`. Xheaders are per-request so they should not leak to the next request on the same connection. N)r|r{r}r!rnrrr_unapply_xheadersnsz%_HTTPRequestContext._unapply_xheaders)N)rLrMrNrrXrrrRrrr~rrrrrrrrrr<*s  " r<c@seZdZejejddddZeejej fej e e ddddZ ee e ddd d Zdd d d Zdd ddZdd ddZdS)rFN)rGrArcCs||_||_dSr)r\rG)rrGrArrrrysz_ProxyAdapter.__init__r_cCs|jj||j||Sr)r\r>rrGrdrcrrrrdsz_ProxyAdapter.headers_receivedrecCs |j|Sr)rGrirhrrrrisz_ProxyAdapter.data_receivedr/cCs|j|dSr)rGro_cleanuprnrrrros z_ProxyAdapter.finishcCs|j|dSr)rGrprrnrrrrps z!_ProxyAdapter.on_connection_closecCs|jjdSr)r\r>rrnrrrrsz_ProxyAdapter._cleanup)rLrMrNrr[rZrr rbrqrrrrrdrsrirorprrrrrrFxs  rF)%rOrvrSZtornado.escaperZtornado.http1connectionrrZtornadorrrZtornado.tcpserverrZ tornado.utilr rIr r r r rrrrr TYPE_CHECKINGrrCrr[rErYr<rFrPZ HTTPRequestrrrrs&       , W&N"