o h ?@sdZddlZddlZddlmZddlmZmZddlm Z ddlm Z ddlm Z ddl m Z dd lmZddlZdd lmZmZmZmZmZmZmZmZmZejrYdd 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@sLeZdZdZdededdfddZ            d(d eeje ej gdffd e d e d e ee eefejfd e ede de ede ede ede ede ede ede eeddfddZedeefddZedeefddZd)ddZdejdeddfd d!Zd"ed#ej dej!fd$d%Z"d"eddfd&d'Z#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. argskwargsreturnNcOsdSN)selfrrrrF/var/www/vscode/kcb/lib/python3.10/site-packages/tornado/httpserver.py__init__szHTTPServer.__init__Frequest_callback no_keep_alivexheaders ssl_optionsprotocoldecompress_request chunk_sizemax_header_sizeidle_connection_timeout body_timeout max_body_sizemax_buffer_sizetrusted_downstreamc CsR||_||_||_t|||| pd| | |d|_tj||| |dt|_| |_ dS)Ni) decompressr#r$header_timeoutr'r&r)r r(read_chunk_size) rrr!r conn_paramsrrset _connectionsr))rrrrr r!r"r#r$r%r&r'r(r)rrr initializes(  zHTTPServer.initializecCtSrrclsrrrconfigurable_basezHTTPServer.configurable_basecCr1rr2r3rrrconfigurable_defaultr6zHTTPServer.configurable_defaultcs2|jrtt|j}|IdH|jsdSdS)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_connectionss z HTTPServer.close_all_connectionsstreamaddresscCs:t|||j|j}t||j|}|j|||dSr)_HTTPRequestContextr!r)rr-r/add start_serving)rr=r>contextr;rrr handle_streams   zHTTPServer.handle_stream server_conn request_conncCs>t|jtjr|j||}nt|j|}|jrt||}|Sr) isinstancerrHTTPServerConnectionDelegate start_request_CallableAdapterr _ProxyAdapter)rrDrEdelegaterrrrHs   zHTTPServer.start_requestcCs|jtt|dSr)r/removetypingcastr)rrDrrron_closeszHTTPServer.on_close) FFNNFNNNNNNNrN)$__name__ __module__ __qualname____doc__r rr rrGr HTTPServerRequestboolrr strssl SSLContextintfloatrr0 classmethodrr r5r7r<rIOStreamrrCobjectHTTPConnectionHTTPMessageDelegaterHrOrrrrr.s|m       ,   rc@seZdZdeejgdfdejddfddZdeej ej fdej de e dfd d Zd ede e dfd d ZdddZdddZdS)rIrNrErcCs"||_||_d|_d|_g|_dSr) connectionrrequestrK_chunks)rrrErrrrs  z_CallableAdapter.__init__ start_lineheaderscCs"tj|jttj||d|_dS)N)rardre)rrUrarMrNRequestStartLinerbrrdrerrrheaders_receiveds  z!_CallableAdapter.headers_receivedchunkcCs|j|dSr)rcappendrrirrr data_receiveds z_CallableAdapter.data_receivedcCs8|jdusJd|j|j_|j||jdS)N)rbjoinrcbody _parse_bodyrrrrrfinish s z_CallableAdapter.finishcCs|`dSr)rcrqrrron_connection_close&sz$_CallableAdapter.on_connection_closerP)rQrRrSr rrUr_rr rfResponseStartLine HTTPHeadersrrrhbytesrlrrrsrrrrrIs$     rIc @sheZdZ ddejdedeedeeeddf ddZ defd d Z d e j ddfd d Z dddZdS)r?Nr=r>r!r)rcCs||_|jdur|jj|_nd|_|jtjtjfvr$|dur$|d|_nd|_|r-||_n t|t j r7d|_nd|_|j|_ |j|_ t |pFg|_dS)Nrz0.0.0.0httpshttp)r>socketfamilyaddress_familyAF_INETAF_INET6 remote_ipr!rFr SSLIOStream_orig_remote_ip_orig_protocolr.r))rr=r>r!r)rrrr+s     z_HTTPRequestContext.__init__cCs8|jtjtjfvr |jSt|jtrt|jSt |jSr) r{ryr|r}r~rFr>rvrrWrqrrr__str__Ms    z_HTTPRequestContext.__str__recCs|d|j}ddt|dDD] }||jvrnq|d|}t|r+||_|d|d|j}|rA|dd}|d vrJ||_d Sd S) z2Rewrite the ``remote_ip`` and ``protocol`` fields.zX-Forwarded-Forcss|]}|VqdSr)strip).0candrrr ]sz6_HTTPRequestContext._apply_xheaders..,z X-Real-IpzX-SchemezX-Forwarded-Proto)rxrwN) getr~reversedsplitr)r is_valid_ipr!r)rreip 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)rr~rr!rqrrr_unapply_xheadersns z%_HTTPRequestContext._unapply_xheadersrrP)rQrRrSrr]rrrWrrrrrurrrrrrr?*s   " r?c@seZdZdejdejddfddZdeejej fdej de e dfd d Z d ede e dfd d ZdddZdddZdddZdS)rJrKrErNcCs||_||_dSr)rarK)rrKrErrrrys z_ProxyAdapter.__init__rdrecCs|jj||j||Sr)rarBrrKrhrgrrrrhsz_ProxyAdapter.headers_receivedricCs |j|Sr)rKrlrkrrrrls z_ProxyAdapter.data_receivedcC|j|dSr)rKrr_cleanuprqrrrrr  z_ProxyAdapter.finishcCrr)rKrsrrqrrrrsrz!_ProxyAdapter.on_connection_closecCs|jjdSr)rarBrrqrrrrsz_ProxyAdapter._cleanuprP)rQrRrSrr`r_rr rfrtrurrrhrvrlrrrsrrrrrrJxs&     rJ)%rTryrXtornado.escapertornado.http1connectionrrtornadorrrtornado.tcpserverr tornado.utilr rMr r r r rrrrr TYPE_CHECKINGrrGrr`rIr^r?rJrU HTTPRequestrrrrs(       , W&N "