U
|
M ±d«g ã @ sf d dl mZmZmZmZmZmZmZmZm Z ddl
|
m Z m Z m Z mZmZmZmZ ddlmZmZmZ ddlmZmZ ddlmZ ddlm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z(m)Z) dd l*m+Z+m,Z, d
|
d d gZ-G d d d e)e)dZ.G dd d e)e)dZ/dZ0e eef e1dddZ2e3e eef ee4e ed ee5 f f dddZ6G dd
|
d
|
Z7dS )é ) ÚAnyÚCallableÚcastÚDictÚListÚOptionalÚTupleÚTypeÚUnioné )ÚConnectionClosedÚDataÚ EndOfMessageÚEventÚInformationalResponseÚRequestÚResponse)Úget_comma_headerÚhas_expect_100_continueÚset_comma_header)ÚREADERSÚ ReadersType)Ú ReceiveBuffer)
|
Ú_SWITCH_CONNECTÚ_SWITCH_UPGRADEÚCLIENTÚConnectionStateÚDONEÚERRORÚMIGHT_SWITCH_PROTOCOLÚ SEND_BODYÚSERVERÚSWITCHED_PROTOCOL)ÚLocalProtocolErrorÚRemoteProtocolErrorÚSentinel)ÚWRITERSÚ WritersTypeÚ
|
ConnectionÚ NEED_DATAÚPAUSEDc @ s e Zd ZdS )r) N©Ú__name__Ú
|
__module__Ú __qualname__© r/ r/ úFd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\h11/_connection.pyr) ( s )Ú metaclassc @ s e Zd ZdS )r* Nr+ r/ r/ r/ r0 r* , s i @ ©ÚeventÚreturnc C s0 t | jd}d|krdS t| dddk r,dS dS )Nó
|
connectionó closeFÚ http_versionó 1.1T)r ÚheadersÚgetattr)r3 Ú
|
connectionr/ r/ r0 Ú _keep_aliveH s r< r/ )Úrequest_methodr3 r4 c C s t |ttfkstt |tkrf|jdksT| dksT| dkrXd|j krPdk rXn ndS |jdksftt|jd}|r|dgkstd S t|jd
|
}|rªd t|d ffS t |tkrºdS d S d S )N)éÌ i0 ó HEADó CONNECTéÈ é, )úcontent-length)r ó transfer-encodingó chunked)Úchunkedr/ ó content-lengthrC r )úhttp/1.0r/ )Útyper r ÚAssertionErrorÚ status_coder r9 Úint)r= r3 Ztransfer_encodingsZcontent_lengthsr/ r/ r0 Ú _body_framingQ s2 ÿþý ýý
|
rM c @ sæ e Zd ZdZefee eddddZe e
|
ee ee f dddZ e ee dd d
|
Z e ee dd d Z e edd dZddddZee ddddZeeee dddZee eddddZee ee eeef eedef dd d Zd3e
|
ee ee f ee dd d d Z e e e ef dd!d"Z e dd#d$d%Z eeee! ee" f dd&d'Z#eeee! ee" f dd(d)Z$eee dd*d+Z%eee&e dd,d-Z'ddd.d/Z(e)e)d0d1d2Z*dS )4r( aB An object encapsulating the state of an HTTP connection.
|
|
Args:
|
our_role: If you're implementing a client, pass :data:`h11.CLIENT`. If
|
you're implementing a server, pass :data:`h11.SERVER`.
|
|
max_incomplete_event_size (int):
|
The maximum number of bytes we're willing to buffer of an
|
incomplete event. In practice this mostly sets a limit on the
|
maximum size of the request/response line + headers. If this is
|
exceeded, then :meth:`next_event` will raise
|
:exc:`RemoteProtocolError`.
|
|
N)Úour_roleÚmax_incomplete_event_sizer4 c C s || _ |ttfkr td |¡|| _| |tkr:t| _nt| _t | _| | jd t
|
¡| _ | | jd t ¡| _ t | _d| _d | _d | _d| _d S )Nz#expected CLIENT or SERVER, not {!r}F)Ú_max_incomplete_event_sizer r! Ú
|
ValueErrorÚformatrN Ú
|
their_roler Ú_cstateÚ_get_io_objectr& Ú_writerr Ú_readerr Ú_receive_bufferÚ_receive_buffer_closedÚtheir_http_versionÚ_request_methodÚ"client_is_waiting_for_100_continue)ÚselfrN rO r/ r/ r0 Ú__init__ s zConnection.__init__)r4 c C s t | jjS )zA dictionary like::
|
|
{CLIENT: <client state>, SERVER: <server state>}
|
|
See :ref:`state-machine` for details.
|
|
)ÚdictrT Ústates©r] r/ r/ r0 r` Â s zConnection.statesc C s | j j| j S )zjThe current state of whichever role we are playing. See
|
:ref:`state-machine` for details.
|
)rT r` rN ra r/ r/ r0 Ú our_stateÍ s zConnection.our_statec C s | j j| j S )znThe current state of whichever role we are NOT playing. See
|
:ref:`state-machine` for details.
|
)rT r` rS ra r/ r/ r0 Ú their_stateÔ s zConnection.their_statec C s | j tko| jS ©N)rS r r\ ra r/ r/ r0 Ú!they_are_waiting_for_100_continueÛ s z,Connection.they_are_waiting_for_100_continuec C s4 t | jj}| j ¡ d| _| jr&t| |¡ dS )a Attempt to reset our connection state for a new request/response
|
cycle.
|
|
If both client and server are in :data:`DONE` state, then resets them
|
both to :data:`IDLE` state in preparation for a new request/response
|
cycle on this same connection. Otherwise, raises a
|
:exc:`LocalProtocolError`.
|
|
See :ref:`keepalive-and-pipelining`.
|
|
N)r_ rT r` Ústart_next_cycler[ r\ rJ Ú_respond_to_state_changes)r] Ú
|
old_statesr/ r/ r0 rf ß s
|
|
|
zConnection.start_next_cycle)Úroler4 c C s& t | jj}| j |¡ | |¡ d S rd )r_ rT r` Z process_errorrg )r] ri rh r/ r/ r0 Ú_process_erroró s zConnection._process_errorr2 c C sT t |tkr|jdkrtS t |tkrPt| jjkrPd|j krHdk rPn ntS d S )Née rA rB )rI r rK r r r rT Zpending_switch_proposals)r] r3 r/ r/ r0 Ú_server_switch_eventø s
|
ÿ þþ
|
z Connection._server_switch_event)ri r3 r4 c C s\ t | jj}|tkrNt|tkrN|jdkr6| j t¡ t |j
|
drN| j t ¡ d }|t krd| |¡}| j |t||¡ t|tkr|j| _|| jkrÄt|tttfkrÄtttttf |}|j| _t|ttfkrôtttttf |sô| j ¡ t|tkrt|rd| _t|ttfkr*d| _|tkrLt|tt fkrLd| _| ||¡ d S )Nr@ s upgradeTF) r_ rT r` r rI r ÚmethodZ process_client_switch_proposalr r r9 r r! rl Z process_eventr[ rS r r r r
|
r7 rZ r< Zprocess_keep_alive_disabledr r\ r r rg )r] ri r3 rh Zserver_switch_eventr/ r/ r0 Ú_process_event s<
|
|
ýÿ
|
zConnection._process_event.)ri r3 Úio_dictr4 c C sZ | j j| }|tkrHttt| jtttt f |\}}|t | | S |
|
||f¡S d S rd ) rT r` r rM r Úbytesr[ r
|
r r Úget)r] ri r3 ro ÚstateÚ framing_typeÚargsr/ r/ r0 rU 4 s
|
ÿzConnection._get_io_object)rh r3 r4 c C sH | j || j kr"| | j|t¡| _| j|| j krD| | j|t¡| _d S rd ) rb rN rU r& rV rc rS r rW )r] rh r3 r/ r/ r0 rg J s z$Connection._respond_to_state_changesc C s t | j| jfS )ab Data that has been received, but not yet processed, represented as
|
a tuple with two elements, where the first is a byte-string containing
|
the unprocessed data itself, and the second is a bool that is True if
|
the receive connection was closed.
|
|
See :ref:`switching-protocols` for discussion of why you'd want this.
|
)rp rX rY ra r/ r/ r0 Ú trailing_dataU s zConnection.trailing_data)Údatar4 c C s, |r"| j rtd| j|7 _nd| _ dS )aØ Add data to our internal receive buffer.
|
|
This does not actually do any processing on the data, just stores
|
it. To trigger processing, you have to call :meth:`next_event`.
|
|
Args:
|
data (:term:`bytes-like object`):
|
The new data that was just received.
|
|
Special case: If *data* is an empty byte-string like ``b""``,
|
then this indicates that the remote side has closed the
|
connection (end of file). Normally this is convenient, because
|
standard Python APIs like :meth:`file.read` or
|
:meth:`socket.recv` use ``b""`` to indicate end-of-file, while
|
other failures to read are indicated using other mechanisms
|
like raising :exc:`TimeoutError`. When using such an API you
|
can just blindly pass through whatever you get from ``read``
|
to :meth:`receive_data`, and everything will work.
|
|
But, if you have an API where reading an empty string is a
|
valid non-EOF condition, then you need to be aware of this and
|
make sure to check for such strings and avoid passing them to
|
:meth:`receive_data`.
|
|
Returns:
|
Nothing, but after calling this you should call :meth:`next_event`
|
to parse the newly received data.
|
|
Raises:
|
RuntimeError:
|
Raised if you pass an empty *data*, indicating EOF, and then
|
pass a non-empty *data*, indicating more data that somehow
|
arrived after the EOF.
|
|
(Calling ``receive_data(b"")`` multiple times is fine,
|
and equivalent to calling it once.)
|
|
z(received close, then received more data?TN)rY Ú RuntimeErrorrX )r] rv r/ r/ r0 Ú receive_data` s
|
'zConnection.receive_datac C s | j }|tkr| jrtS |tks(|tkr,tS | jd k s:t| | j¡}|d krx| jsx| jrxt | jdrr| j
|
¡ }nt }|d krt }|S )NÚread_eof) rc r rX r* r r" rW rJ rY Úhasattrry r r) )r] rr r3 r/ r/ r0 Ú_extract_next_receive_event s z&Connection._extract_next_receive_eventc
|
C s¼ | j tkrtdz`| ¡ }|ttfkr<| | jtt |¡ |tkrnt
|
| j | j kr`tddd| j rntd|W S tk
|
r¶ } z&| | j¡ t|tr¤| ¡ n W 5 d}~X Y nX dS )aF Parse the next event out of our receive buffer, update our internal
|
state, and return it.
|
|
This is a mutating operation -- think of it like calling :func:`next`
|
on an iterator.
|
|
Returns:
|
: One of three things:
|
|
1) An event object -- see :ref:`events`.
|
|
2) The special constant :data:`NEED_DATA`, which indicates that
|
you need to read more data from your socket and pass it to
|
:meth:`receive_data` before this method will be able to return
|
any more events.
|
|
3) The special constant :data:`PAUSED`, which indicates that we
|
are not in a state where we can process incoming data (usually
|
because the peer has finished their part of the current
|
request/response cycle, and you have not yet called
|
:meth:`start_next_cycle`). See :ref:`flow-control` for details.
|
|
Raises:
|
RemoteProtocolError:
|
The peer has misbehaved. You should close the connection
|
(possibly after sending some kind of 4xx response).
|
|
Once this method returns :class:`ConnectionClosed` once, then all
|
subsequent calls will also return :class:`ConnectionClosed`.
|
|
If this method raises any exception besides :exc:`RemoteProtocolError`
|
then that's a bug -- if it happens please file a bug report!
|
|
If this method raises any exception then it also sets
|
:attr:`Connection.their_state` to :data:`ERROR` -- see
|
:ref:`error-handling` for discussion.
|
|
z+Can't receive data when peer state is ERRORzReceive buffer too longi¯ )Zerror_status_hintz#peer unexpectedly closed connectionN)rc r r$ r{ r) r* rn rS r r ÚlenrX rP rY Ú BaseExceptionrj Ú
|
isinstancer# Z!_reraise_as_remote_protocol_error)r] r3 Úexcr/ r/ r0 Ú
|
next_eventª s( (
|
ÿ
|
|
zConnection.next_eventc C s$ | |¡}|dkrdS d |¡S dS )a³ Convert a high-level event into bytes that can be sent to the peer,
|
while updating our internal state machine.
|
|
Args:
|
event: The :ref:`event <events>` to send.
|
|
Returns:
|
If ``type(event) is ConnectionClosed``, then returns
|
``None``. Otherwise, returns a :term:`bytes-like object`.
|
|
Raises:
|
LocalProtocolError:
|
Sending this event at this time would violate our
|
understanding of the HTTP/1.1 protocol.
|
|
If this method raises any exception then it also sets
|
:attr:`Connection.our_state` to :data:`ERROR` -- see
|
:ref:`error-handling` for discussion.
|
|
Nó )Úsend_with_data_passthroughÚjoin)r] r3 Ú data_listr/ r/ r0 Úsendë s
|
zConnection.sendc C s | j tkrtdzbt|tkr*| |¡}| j}| | j|¡ t|t krPW dS |dk s\t
|
g }|||j |W S W n | | j¡ Y nX dS )ah Identical to :meth:`send`, except that in situations where
|
:meth:`send` returns a single :term:`bytes-like object`, this instead
|
returns a list of them -- and when sending a :class:`Data` event, this
|
list is guaranteed to contain the exact object you passed in as
|
:attr:`Data.data`. See :ref:`sendfile` for discussion.
|
|
z'Can't send data when our state is ERRORN) rb r r# rI r Ú&_clean_up_response_headers_for_sendingrV rn rN r rJ Úappendrj )r] r3 Úwriterr r/ r/ r0 r s
|
|
|
z%Connection.send_with_data_passthroughc C s | | j¡ dS )záNotify the state machine that we failed to send the data it gave
|
us.
|
|
This causes :attr:`Connection.our_state` to immediately become
|
:data:`ERROR` -- see :ref:`error-handling` for discussion.
|
|
N)rj rN ra r/ r/ r0 Ú send_failed' s zConnection.send_failed)Úresponser4 c C sæ t |tkst|j}d}tt| j}|dkr2d}t||\}}|dkrt|dg }| j d ksh| j dk rt|dg }| jdkrd}nt|dd g}| j
|
j r|rÐt t |d
|
}| d ¡ | d ¡ t|d
|
t|}t||j|j|jd S )NFr? s GET)rF rH rG r8 rD TrE r5 s
|
keep-aliver6 )r9 rK r7 Úreason)rI r rJ r9 r rp r[ rM r rZ rT Ú
|
keep_aliveÚsetr ÚdiscardÚaddÚsortedrK r7 r )r] r r9 Z
|
need_closeZmethod_for_choosing_headersrs Ú_r; r/ r/ r0 r @ s2
|
|
|
üz1Connection._clean_up_response_headers_for_sending)N)+r, r- r. Ú__doc__Ú!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr r% rL r^ Úpropertyr r` rb rc Úboolre rf rj r r rl rn r
|
r r' r r rU rg r rp ru rx r) r* r{ r r
r r r r r r/ r/ r/ r0 r( sP ýü '
|
2
|
û ýü
|
0þ A!N)8Útypingr r r r r r r r r
|
Z_eventsr r r r r r r Ú_headersr r r Ú_readersr r Z_receivebufferr Ú_stater r r r r r r r r! r" Z_utilr# r$ r% Ú_writersr& r' Ú__all__r) r* r r r< rp ÚstrrL rM r( r/ r/ r/ r0 Ú<module> s" ,$ 0
|
|
|
þ :
|
