File: //lib64/python3.6/site-packages/tornado/__pycache__/httpserver.cpython-36.opt-1.pyc
3
��f]< � @ s d Z ddlZddlZddlmZ ddlmZmZ ddlm Z ddlm
Z
ddlm Z ddl m
Z
dd lmZ ddlZdd
lmZmZmZmZmZmZmZmZmZ ejr�dd lmZ G d d
� d
e
ee j �Z G dd� de j �Z G dd� de �Z!G dd� de j �Z"e j#Z$dS )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 @ s� e Zd ZdZeedd�dd�Zdeeje ej
gdf f e e ee e
ef ejf e
e eeeeeeee
dd�dd �Zeee d
�d d ��Zeee d
�d
d��Zdd
�dd�Zeje dd�dd�Z e ej ej d�dd�Z!e dd�dd�Z"dS )�
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.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`: simple single-process::
server = HTTPServer(app)
server.listen(8888)
IOLoop.current().start()
In many cases, `tornado.web.Application.listen` can be used to avoid
the need to explicitly create the `HTTPServer`.
2. `~tornado.tcpserver.TCPServer.bind`/`~tornado.tcpserver.TCPServer.start`:
simple multi-process::
server = HTTPServer(app)
server.bind(8888)
server.start(0) # Forks multiple sub-processes
IOLoop.current().start()
When using this interface, an `.IOLoop` must *not* be passed
to the `HTTPServer` constructor. `~.TCPServer.start` will always start
the server on the default singleton `.IOLoop`.
3. `~tornado.tcpserver.TCPServer.add_sockets`: advanced multi-process::
sockets = tornado.netutil.bind_sockets(8888)
tornado.process.fork_processes(0)
server = HTTPServer(app)
server.add_sockets(sockets)
IOLoop.current().start()
The `~.TCPServer.add_sockets` interface is more complicated,
but it can be used with `tornado.process.fork_processes` to
give you more flexibility in when the fork happens.
`~.TCPServer.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`.
.. 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)�args�kwargs�returnc O s d S )N� )�selfr r r r �"/usr/lib64/python3.6/httpserver.py�__init__� s zHTTPServer.__init__F)�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_downstreamr c C sR || _ || _|| _t|||| p d| |
|d�| _tj| || |d� t� | _|
| _ d S )Ni )Z
decompressr" r# Zheader_timeoutr& r% r )r r' Zread_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( r r r �
initialize� s$
zHTTPServer.initialize)r c C s t S )N)r )�clsr r r �configurable_base� s z HTTPServer.configurable_basec C s t S )N)r )r- r r r �configurable_default� s z HTTPServer.configurable_defaultc � s, x&| j r&tt| j ��}|j� I dH qW dS )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 caled with ``await``.
N)r+ �next�iter�close)r �connr r r �close_all_connections� s z HTTPServer.close_all_connections)�stream�addressr c C s: t ||| j| j�}t|| j|�}| jj|� |j| � d S )N)�_HTTPRequestContextr r( r r) r+ �addZ
start_serving)r r5 r6 �contextr3 r r r �
handle_stream� s
zHTTPServer.handle_stream)� server_conn� request_connr c C s> t | jtj�r | jj||�}n t| j|�}| jr:t||�}|S )N)�
isinstancer r � HTTPServerConnectionDelegate�
start_request�_CallableAdapterr �
_ProxyAdapter)r r; r< �delegater r r r? � s
zHTTPServer.start_request)r; r c C s | j jtjt|�� d S )N)r+ �remove�typing�castr )r r; r r r �on_close� s zHTTPServer.on_close) FFNNFNNNNNNN)#�__name__�
__module__� __qualname__�__doc__r r r
r r> r
�HTTPServerRequest�boolr �str�sslZ
SSLContext�int�floatr r, � classmethodr r r. r/ r4 r �IOStreamr r: �object�HTTPConnection�HTTPMessageDelegater? rF r r r r r . s0 ` H r c @ s� e Zd Zeejgdf ejdd�dd�Zeej ej
f ej e e
d d�dd�Zee e
d d�d d
�Zdd �d d
�Zdd �dd�ZdS )r@ N)r r< r c C s" || _ || _d | _d | _g | _d S )N)�
connectionr �requestrB �_chunks)r r r< r r r r � s
z_CallableAdapter.__init__)�
start_line�headersr c C s" t j| jtjt j|�|d�| _d S )N)rV rY rZ )r rK rV rD rE �RequestStartLinerW )r rY rZ r r r �headers_received s
z!_CallableAdapter.headers_received)�chunkr c C s | j j|� d S )N)rX �append)r r] r r r �
data_received s z _CallableAdapter.data_received)r c C s* dj | j�| j_| jj� | j| j� d S )N� )�joinrX rW ZbodyZ _parse_bodyr )r r r r �finish s
z_CallableAdapter.finishc C s | ` d S )N)rX )r r r r �on_connection_close s z$_CallableAdapter.on_connection_close)rG rH rI r
r rK rT r r
r[ �ResponseStartLine� HTTPHeadersr r r\ �bytesr_ rb rc r r r r r@ � s r@ c @ s\ e Zd Zd
ejeee ee dd�dd�Z ed�dd�Z
e j dd�d d
�Z
dd�d d �ZdS )r7 N)r5 r6 r r( r c C s� || _ |jd k r |jj| _nd | _| jtjtjfkrH|d k rH|d | _nd| _|rZ|| _nt|t j
�rnd| _nd| _| j| _ | j| _ t
|p�g �| _d S )Nr z0.0.0.0�https�http)r6 �socketZfamily�address_family�AF_INET�AF_INET6� remote_ipr r= r Z SSLIOStream�_orig_remote_ip�_orig_protocolr* r( )r r5 r6 r r( r r r r s
z _HTTPRequestContext.__init__)r c C s< | j tjtjfkr| jS t| jt�r.t| j�S t | j�S d S )N)
rj ri rk rl rm r= r6 rf r rM )r r r r �__str__A s
z_HTTPRequestContext.__str__)rZ r c C s� |j d| j�}x,dd� t|jd��D �D ]}|| jkr(P q(W |j d|�}tj|�rX|| _|j d|j d| j��}|r�|jd�d j� }|d
kr�|| _d S )z2Rewrite the ``remote_ip`` and ``protocol`` fields.zX-Forwarded-Forc s s | ]}|j � V qd S )N)�strip)�.0Zcandr r r � <genexpr>Q s z6_HTTPRequestContext._apply_xheaders.<locals>.<genexpr>�,z X-Real-IpzX-SchemezX-Forwarded-Proto� rh rg N���)rh rg ) �getrm �reversed�splitr( r Z is_valid_ipr rq )r rZ ZipZ proto_headerr r r �_apply_xheadersL s
z#_HTTPRequestContext._apply_xheadersc C s | j | _| j| _dS )z�Undo changes from `_apply_xheaders`.
Xheaders are per-request so they should not leak to the next
request on the same connection.
N)rn rm ro r )r r r r �_unapply_xheadersb s z%_HTTPRequestContext._unapply_xheaders)N)rG rH rI r rR r r rM r r rp r re rz r{ r r r r r7 s
r7 c @ s� e Zd Zejejdd�dd�Zeejej f ej
e e d d�dd�Z
ee e d d�d d
�Zdd �d d
�Zdd �dd�Zdd �dd�ZdS )rA N)rB r< r c C s || _ || _d S )N)rV rB )r rB r< r r r r m s z_ProxyAdapter.__init__)rY rZ r c C s | j jj|� | jj||�S )N)rV r9 rz rB r\ )r rY rZ r r r r\ u s z _ProxyAdapter.headers_received)r] r c C s | j j|�S )N)rB r_ )r r] r r r r_ s z_ProxyAdapter.data_received)r c C s | j j� | j� d S )N)rB rb �_cleanup)r r r r rb � s
z_ProxyAdapter.finishc C s | j j� | j� d S )N)rB rc r| )r r r r rc � s
z!_ProxyAdapter.on_connection_closec C s | j jj� d S )N)rV r9 r{ )r r r r r| � s z_ProxyAdapter._cleanup)rG rH rI r rU rT r r
r[ rd re r r r\ rf r_ rb rc r| r r r r rA l s rA )%rJ ri rN Ztornado.escaper Ztornado.http1connectionr r Ztornador r r Ztornado.tcpserverr Z tornado.utilr rD r
r r r
r r r r r Z
TYPE_CHECKINGr r> r rU r@ rS r7 rA rK Z HTTPRequestr r r r �<module> s& , K&N"