| Server IP : 107.13.46.68 / Your IP : 216.73.216.232 Web Server : Apache/2.4.58 (Ubuntu) System : Linux mariOS 6.8.0-51-generic #52-Ubuntu SMP PREEMPT_DYNAMIC Thu Dec 5 13:09:44 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 8.3.6 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /lib/python3/dist-packages/tornado/__pycache__/ |
Upload File : |
�
��fe ? � �x � d Z ddlZddlZddlmZ ddlmZmZ ddlm Z ddlm
Z
ddlm Z ddl m
Z
dd lmZ ddlZdd
lmZmZmZmZmZmZmZmZmZ ej4 rdd lmZ G d � d
e
ee j8 � Z G d� de j< � Z G d� de � Z! G d� de j< � Z"e jF Z$y)a� A 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)�HTTP1ServerConnection�HTTP1ConnectionParameters)�httputil)�iostream)�netutil)� TCPServer)� Configurable) �Union�Any�Dict�Callable�List�Type�Tuple�Optional� Awaitable)�Setc �� � e Zd ZdZdededdfd�Z d deej e ej gdf f de d e d
e ee
eef ej f d e e d e d
e e de e de e de e de e de e de ee ddf d�Zedee fd�� Zedee fd�� Zd d�Zdej8 de ddfd�Z de d ej@ dejB fd �Z"de ddfd �Z#y)!�
HTTPServera� A 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.
�args�kwargs�returnNc � � y �N� )�selfr r s �4/usr/lib/python3/dist-packages/tornado/httpserver.py�__init__zHTTPServer.__init__� s � �
� �request_callback�
no_keep_alive�xheaders� ssl_options�protocol�decompress_request�
chunk_size�max_header_size�idle_connection_timeout� body_timeout�
max_body_size�max_buffer_size�trusted_downstreamc �� � || _ || _ || _ t |||| xs d| |
|�� | _ t j | || |�� t � | _ |
| _ y )Ni )�
decompressr' r( �header_timeoutr+ r* r" )r$ r, �read_chunk_size)
r! r# r% r � conn_paramsr r �set� _connectionsr- )r r! r" r# r$ r% r& r' r( r) r* r+ r, r- s r �
initializezHTTPServer.initialize� sq � �. !1�� � ��
� ��
�4�)�!� +�2�:�d�'�%�'�
��� ��� �#� +� &�
� �E���"4�� r c � � t S r �r ��clss r �configurable_basez HTTPServer.configurable_base� � � ��r c � � t S r r7 r8 s r �configurable_defaultz HTTPServer.configurable_default� r; r c � � K � | j rDt t | j � � }|j � � d{ ��� | j r�Cyy7 ��w)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)r4 �next�iter�close)r �conns r �close_all_connectionsz HTTPServer.close_all_connections� sE � �� � � � ���T� .� .�/�0�D��*�*�,� � � � � �
�s �>A� A�A�A�stream�addressc �� � t ||| j | j � }t || j |� }| j
j
|� |j | � y r )�_HTTPRequestContextr% r- r r2 r4 �add�
start_serving)r rD rE �contextrB s r �
handle_streamzHTTPServer.handle_stream� sW � �%� �G�T�]�]�D�,C�,C�
�� %�V�T�-=�-=�w�G�� ��� � �d�#� ���4� r � server_conn� request_connc �� � t | j t j � r | j j ||� }nt | j |� }| j r t ||� }|S r )�
isinstancer! r � HTTPServerConnectionDelegate�
start_request�_CallableAdapterr# �
_ProxyAdapter)r rL rM �delegates r rQ zHTTPServer.start_request� s\ � � �d�+�+�X�-R�-R� S��,�,�:�:�;� �U�H�'��(=�(=�|�L�H� �=�=�$�X�|�<�H��r c �j � | j j t j t |� � y r )r4 �remove�typing�castr )r rL s r �on_closezHTTPServer.on_close s" � � ��� � ����-B�K�!P�Qr ) FFNNFNNNNNNN�r N)$�__name__�
__module__� __qualname__�__doc__r r r r rP r �HTTPServerRequest�boolr r
�str�ssl�
SSLContext�int�floatr r5 � classmethodr r
r: r= rC r �IOStreamr rK �object�HTTPConnection�HTTPMessageDelegaterQ rY r r r r r . s� � �k�Z
�c�
�S�
�T�
� $� �GK�"&�#(�$(�)-�37�(,�'+�)-�26�#*5� � � 1� 1� �h�0�0�1�4�7� 8�
:�
�*5� �
*5� �*5� �e�D��c��N�C�N�N�$B� C�D�*5� �3�-�*5� !�*5� �S�M�*5� "�#� �*5� "*�%� �*5� �u�o� *5� ��}� *5� "�#� �!*5�" %�T�#�Y� /�#*5�$
�%*5�X ��$�|�"4� � �� ��T�,�%7� � �� �&!�H�$5�$5� !�� !�$� !� �!� �19�1H�1H� � � %� %� �R�F� R�t� Rr r c �� � e Zd Zdeej
gdf dej ddfd�Zdeej ej f dej de e
d fd�Zd ede e
d fd
�Zd
d �Zd
d �Zy)rR r! NrM r c �J � || _ || _ d | _ d | _ g | _ y r )�
connectionr! �requestrT �_chunks)r r! rM s r r z_CallableAdapter.__init__ s( � �
'��� 0�� ��� � ��
��� r �
start_line�headersc � � t j | j t j t j
|� |�� | _ y )N)rm rp rq )r r_ rm rW rX �RequestStartLinern �r rp rq s r �headers_receivedz!_CallableAdapter.headers_received s9 � �
�1�1���� �{�{�8�#<�#<�j�I��
�� �
r �chunkc �: � | j j |� y r )ro �append�r rv s r �
data_receivedz _CallableAdapter.data_received s � � � � ���E�"�r c �� � | j �J �dj | j � | j _ | j j � | j | j � y )Nr )rn �joinro �body� _parse_bodyr! �r s r �finishz_CallableAdapter.finish sM � ��|�|�'�'�'� �H�H�T�\�\� 2�� � �� � � � � �"� � � �d�l�l�+r c � � | ` y r )ro r s r �on_connection_closez$_CallableAdapter.on_connection_close& s � � �Lr rZ )r[ r\ r] r r r_ ri r r rs �ResponseStartLine� HTTPHeadersr r ru �bytesrz r� r� r r r rR rR s� � � �"�H�$>�$>�#?��#E�F� � �-�-� �
� �
��(�3�3�X�5O�5O�O�P�
� �%�%�
�
�)�D�/� "�
��5� �X�i��o�-F� �,� r rR c � � e Zd Z d dej dedee deee ddf
d�Z defd�Z
d e j ddfd
�Z
d
d �Zy)rG NrD rE r% r- r c �� � || _ |j � |j j | _ nd | _ | j t j t j
fv r
|� |d | _ nd| _ |r|| _ n)t |t j � rd| _ nd| _ | j | _ | j | _ t |xs g � | _ y )Nr z0.0.0.0�https�http)rE �socket�family�address_family�AF_INET�AF_INET6� remote_ipr% rO r � SSLIOStream�_orig_remote_ip�_orig_protocolr3 r- )r rD rE r% r- s r r z _HTTPRequestContext.__init__+ s� � � �� � �=�=� $�"(�-�-�"6�"6�D� �"&�D� �
� � �F�N�N�F�O�O�#D� D��#� $�Q�Z�D�N� '�D�N� � $�D�M�
��� 4� 4�
5� #�D�M� "�D�M� #�~�~�� � "�m�m���"%�&8�&>�B�"?�� r c � � | j t j t j fv r | j S t | j t � rt | j � S t | j � S r )
r� r� r� r� r� rO rE r� r ra r s r �__str__z_HTTPRequestContext.__str__M sU � � � � �6�>�>�6�?�?�"C� C��>�>� !�
�� � �e�
,� �d�l�l�+� +��t�|�|�$� $r rq c � � |j d| j � }d� t |j d� � D � D ] }|| j vs� n |j d|� }t j |� r|| _ |j d|j d| j � � }|r"|j d� d j � }|dv r|| _ y y )
z2Rewrite the ``remote_ip`` and ``protocol`` fields.zX-Forwarded-Forc 3 �< K � | ] }|j � �� � y �wr )�strip)�.0�cands r � <genexpr>z6_HTTPRequestContext._apply_xheaders.<locals>.<genexpr>] s � �� �D�D�4�:�:�<�D�s � �,z X-Real-IpzX-SchemezX-Forwarded-Proto���)r� r� N) �getr� �reversed�splitr- r � is_valid_ipr% r� )r rq �ip� proto_headers r �_apply_xheadersz#_HTTPRequestContext._apply_xheadersX s� � � �[�[�*�D�N�N�
;��D�H�R�X�X�c�]�,C�D� �B���0�0�0�� � �[�[��b�
)�� � � �r� "� �D�N� �{�{� �� � �$7�� � �G�
� � � (�-�-�c�2�2�6�<�<�>�L� �,� ,� (�D�M� -r c �H � | j | _ | j | _ y)z�Undo 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% r s r �_unapply_xheadersz%_HTTPRequestContext._unapply_xheadersn s � � �-�-��� �+�+��
r r rZ )r[ r\ r] r rg r r ra r r r� r r� r� r� r r r rG rG * s� � � 37� @��!�!� @� � @� �3�-� @�
%�T�#�Y� /� @�
�
@�D %�� %�)�x�';�';� )�� )�,,r rG c �� � e Zd Zdej dej
ddfd�Zdeej ej f dej de e d fd�Z
d ede e d fd
�Zdd �Zdd �Zdd
�Zy)rS rT rM r Nc � � || _ || _ y r )rm rT )r rT rM s r r z_ProxyAdapter.__init__y s � �
'��� ��
r rp rq c � � | j j j |� | j j ||� S r )rm rJ r� rT ru rt s r ru z _ProxyAdapter.headers_received� s3 � �
��� � �/�/��8��}�}�-�-�j�'�B�Br rv c �8 � | j j |� S r )rT rz ry s r rz z_ProxyAdapter.data_received� s � ��}�}�*�*�5�1�1r c �X � | j j � | j � y r )rT r� �_cleanupr s r r� z_ProxyAdapter.finish� s � � �
�
� � � � �
�
�r c �X � | j j � | j � y r )rT r� r� r s r r� z!_ProxyAdapter.on_connection_close� s � � �
�
�)�)�+� �
�
�r c �L � | j j j � y r )rm rJ r� r s r r� z_ProxyAdapter._cleanup� s � � ��� � �1�1�3r rZ )r[ r\ r] r rj ri r r rs r� r� r r ru r� rz r� r� r� r r r rS rS x s� � �!��.�.�!� �-�-�!�
� !�C��(�3�3�X�5O�5O�O�P�C� �%�%�C�
�)�D�/� "� C�2�5� 2�X�i��o�-F� 2���4r rS )%r^ r� rb �tornado.escaper �tornado.http1connectionr r �tornador r r �tornado.tcpserverr � tornado.utilr
rW r r r
r r r r r r �
TYPE_CHECKINGr rP r rj rR rh rG rS r_ � HTTPRequestr r r �<module>r� s� ��
� �
� %� T� � � � '� %�
� U� U� U� ����SR��L�(�*O�*O� SR�l#�x�3�3� #�LK,�&� K,�\ 4�H�0�0� 4�D �(�(� r