+ V@i?Rt^RIt^RIt^RIHt^RIHtHt^RIH t ^RIH t ^RIH t ^RI H t ^RIHt^RIt^R IHtHtHtHtHtHtHtHtHt]P4'd^R IHt!R R ] ]] P84t!R R] P<4t!RR4t !RR] P<4t!] PDt#R#)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)Setca]tRt^.toRtV3RlRltRV3RlRllt]V3RlRl4t]V3R lR l4t V3R lR lt V3R lRlt V3RlRlt V3RlRlt RtVtR#) 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. c*<V^8dQhRS[RS[RR/#)argskwargsreturnN)r )format __classdict__s"4/usr/lib/python3/dist-packages/tornado/httpserver.py __annotate__HTTPServer.__annotate__s"  c S T cR#N)selfrrs&*,r__init__HTTPServer.__init__s r Nc<V^8dQhRS[S[PS[S[P.R3,3,RS[RS[RS[S[S[S[S[ 3,S[ P3,,RS[S[,RS[RS[S[ ,R S[S[ ,R S[S[ ,R S[S[ ,R S[S[ ,R S[S[ ,RS[S[S[,,RR/#)rrequest_callbackN no_keep_alivexheaders ssl_optionsprotocoldecompress_request chunk_sizemax_header_sizeidle_connection_timeout body_timeout max_body_sizemax_buffer_sizetrusted_downstreamr)r rHTTPServerConnectionDelegater HTTPServerRequestboolrr strr ssl SSLContextintfloatr)rrs"rrrs*5*5  1 1 h00147 8 : *5  *5*5eDcNCNN$BCD*53-*5!*5SM*5"#*5"*%*5uo*5 }*5 "#!*5"%T#Y/#*5$ %*5r c WnW0nWPn\TTTT ;'gRV V VR7Vn\ P !VVV VR7\4VnWn R#)i) decompressr.r/header_timeoutr2r1r))r+r3read_chunk_sizeN) r(r*r,r conn_paramsrr%set _connectionsr4)r$r(r)r*r+r,r-r.r/r0r1r2r3r4s&&&&&&&&&&&&&&r initializeHTTPServer.initializesl.!1  4)!+2::d'%'   #+&   E"4r c0<V^8dQhRS[S[,/#rrrr )rrs"rrrs$|"4r c\#r"rclss&rconfigurable_baseHTTPServer.configurable_baser c0<V^8dQhRS[S[,/#rGrH)rrs"rrrsT,%7r c\#r"rJrKs&rconfigurable_defaultHTTPServer.configurable_defaultrOr c<V^8dQhRR/#rrNr#)rrs"rrrsTr c "VP'd9\\VP44pVP4GRjxL KJR#L5i)aClose 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)rCnextiterclose)r$conns& rclose_all_connections HTTPServer.close_all_connectionssAT../0D**,    sA1AA Ac><V^8dQhRS[PRS[RR/#)rstreamaddressrN)rIOStreamr)rrs"rrrs(!!H$5$5!!$!r c\WVPVP4p\WPV4pVP P V4VPV4R#r")_HTTPRequestContextr,r4rrArCadd start_serving)r$r^r_contextrZs&&& r handle_streamHTTPServer.handle_streamsS% T]]D,C,C %V-=-=wG d# 4 r cT<V^8dQhRS[RS[PRS[P/#)r server_conn request_connr)objectrHTTPConnectionHTTPMessageDelegate)rrs"rrrs1  ! 191H1H   % % r c\VP\P4'dVPP W4pM\ VPV4pVP 'd \W24pV#r") isinstancer(rr5 start_request_CallableAdapterr* _ProxyAdapter)r$rirjdelegates&&& rrpHTTPServer.start_requests] d++X-R-R S S,,::;UH'(=(=|LH ===$X$>#?#EF --   r cHW nWnRVnRVn.VnR#r") connectionr(requestrs_chunks)r$r(rjs&&&rr%_CallableAdapter.__init__s$ ' 0   r c<V^8dQhRS[S[PS[P3,RS[PRS[S[R,,/#r start_lineheadersrNr rRequestStartLineResponseStartLine HTTPHeadersrr)rrs"rrrsN  (33X5O5OOP %%  )D/ " r c\P!VP\P!\P V4VR7VnR#))rrrN)rr6rrxryrrr$rrs&&&rheaders_received!_CallableAdapter.headers_receiveds9  11{{8#<#&>B"?r c <V^8dQhRS[/#rG)r8)rrs"rrrMs % % %r c VP\P\P39d VP#\ VP \4'd\VP 4#\VP 4#r") rrrrrror_rrr8rs&r__str___HTTPRequestContext.__str__MsX   6>>6??"C C>> !  e , ,dll+ +t||$ $r c8<V^8dQhRS[PRR/#)rrrN)rr)rrs"rrrXs!))x';';))r c VPRVP4pR\VPR444FpW P9gKM VPRV4p\ P !V4'dW nVPRVPRVP44pV'd'VPR4R,P4pVR 9d W0nR#R#) z2Rewrite the ``remote_ip`` and ``protocol`` fields.zX-Forwarded-Forc3@"TFqP4xK R#5ir")strip).0cands& r 6_HTTPRequestContext._apply_xheaders..]sD,CD::<<,Cs,z X-Real-IpzX-SchemezX-Forwarded-ProtoN)rr) getrreversedsplitr4r is_valid_ipr,r)r$rip proto_headers&& r_apply_xheaders#_HTTPRequestContext._apply_xheadersXs[[*DNN ;DHRXXc],CDB000E[[b )   r " "N{{  $7G  (--c226<<>L , ,(M -r c<V^8dQhRR/#rUr#)rrs"rrrns,,4,r c JVPVnVPVnR#)zUndo changes from `_apply_xheaders`. Xheaders are per-request so they should not leak to the next request on the same connection. N)rrrr,rs&r_unapply_xheaders%_HTTPRequestContext._unapply_xheadersns --++ r )rrr_rr,rr4r") r|r}r~rr%rrrrrrs@rrbrb*s0 @ @D % %)),,,r rbca]tRtRtoV3RlRltV3RlRltV3RlRltV3RlR ltV3R lR ltV3R lR lt Rt Vt R#)rrixcR<V^8dQhRS[PRS[PRR/#)rrsrjrN)rrmrl)rrs"rr_ProxyAdapter.__annotate__ys5!!..!--!  !r cW nWnR#r"rrs)r$rsrjs&&&rr%_ProxyAdapter.__init__ys ' r c<V^8dQhRS[S[PS[P3,RS[PRS[S[R,,/#rr)rrs"rrrsSCC(33X5O5OOPC%%C )D/ " Cr cVPPPV4VPP W4#r")rrerrsrrs&&&rr_ProxyAdapter.headers_receiveds1 //8}}--jBBr cD<V^8dQhRS[RS[S[R,,/#rr)rrs"rrrs$2252Xio-F2r c8VPPV4#r")rsrrs&&rr_ProxyAdapter.data_receiveds}}**511r c<V^8dQhRR/#rUr#)rrs"rrrsr cZVPP4VP4R#r")rsr_cleanuprs&rr_ProxyAdapter.finishs  r c<V^8dQhRR/#rUr#)rrs"rrrsTr cZVPP4VP4R#r")rsrrrs&rr!_ProxyAdapter.on_connection_closes ))+ r c<V^8dQhRR/#rUr#)rrs"rrrs44$4r cNVPPP4R#r")rrerrs&rr_ProxyAdapter._cleanups 113r rN) r|r}r~rr%rrrrrrrrs@rrrrrxsC!!CC2244r rr)$rrr9tornado.escapertornado.http1connectionrrtornadorrrtornado.tcpserverr tornado.utilr rxr r r r rrrrr TYPE_CHECKINGrr5rrmrqrbrrr6 HTTPRequestr#r rrs  %T'% UUU SRL(*O*OSRl#x33#LK,K,\4H004D(( r