U
|
[ ±daÝ ã @ s d dl Z d dlmZ d dlmZ d dlmZ d dlmZ d dl Z d dl
|
Z
|
d dl Z d dl Z d dl Z d dlZd dlmZmZ d dlZd dlZd dlmZ d dlmZmZ d d lmZ d dl m Z d d
|
l m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( d dl)Ze*e+e,ej- .d ¡d k Z/d Z0dZ1dZ2dZ3e
|
4d¡Z5dd Z6G dd dZ7edde1e2e0e0dddZ8dde1e2dddZ9dAdde1e2e0e0dd d Z:dBdde1e2dd d Z;d d! Z<dde1e2dd"d#Z=e1e2fd$d%Z>de1e2e0e0ej?d&d'd(Z@G d)d* d*eAZBG d+d, d,eBZCG d-d. d.eBZDG d/d0 d0eAZEG d1d2 d2eBZFG d3d4 d4ZGG d5d6 d6ZHG d7d8 d8ZId9d: ZJG d;d< d<ejKjLZMG d=d> d>ZNG d?d@ d@ZOdS )Cé N)Ú OrderedDict)Úasynccontextmanager)Úpartial)Ú
|
ip_address)ÚListÚOptional)ÚBaseExceptionGroup)ÚConnectionTypeÚ WSConnection)ÚConnectionState) ÚAcceptConnectionÚ BytesMessageÚCloseConnectionÚPingÚPongÚRejectConnectionÚ
|
RejectDataÚRequestÚ TextMessageÚ.)r é r é< é i i ztrio-websocketc C s t | tjrd S | S ©N©Ú
|
isinstanceÚtrioZ Cancelled©Úexc© r úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio_websocket/_impl.pyÚ_ignore_cancel* s r! c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
|
Ú_preserve_current_exceptiona A context manager which should surround an ``__exit__`` or
|
``__aexit__`` handler or the contents of a ``finally:``
|
block. It ensures that any exception that was being handled
|
upon entry is not masked by a `trio.Cancelled` raised within
|
the body of the context manager.
|
|
https://github.com/python-trio/trio/issues/1559
|
https://gitter.im/python-trio/general?at=5faf2293d37a1a13d6a582cf
|
©Ú_armedc C s
|
d| _ d S ©NFr# ©Úselfr r r Ú__init__: s z$_preserve_current_exception.__init__c C s t ¡ d d k | _d S )Nr )ÚsysÚexc_infor$ r& r r r Ú __enter__= s z%_preserve_current_exception.__enter__c C sP |d ks| j sdS tr&tj t|¡}n"t|tr@| dd ¡}nt|}|d kS )NFc S s t | tj S r r r r r r Ú<lambda>G ó z6_preserve_current_exception.__exit__.<locals>.<lambda>) r$ Ú_TRIO_MULTI_ERRORr Z
|
MultiErrorÚfilterr! r r Zsubgroup)r' ÚtyÚvalueÚtbZfiltered_exceptionr r r Ú__exit__@ s
|
z$_preserve_current_exception.__exit__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__r( r+ r3 r r r r r" . s
|
r" )Ú subprotocolsÚ extra_headersÚmessage_queue_sizeÚmax_message_sizeÚconnect_timeoutÚdisconnect_timeoutc C sø t ¡ 4 I dH Ø}
|
z:t |¡& t|
|
| |||||||d I dH } W 5 Q R X W nB t jk
|
rh tdY n( tk
|
r } z
|
t| W 5 d} ~ X Y nX z
|
| V W 5 z(t | ¡ | ¡ I dH W 5 Q R X W n t jk
|
rà t dY nX X W 5 Q I dH R X dS )aÇ
|
Open a WebSocket client connection to a host.
|
|
This async context manager connects when entering the context manager and
|
disconnects when exiting. It yields a
|
:class:`WebSocketConnection` instance.
|
|
:param str host: The host to connect to.
|
:param int port: The port to connect to.
|
:param str resource: The resource, i.e. URL path.
|
:param Union[bool, ssl.SSLContext] use_ssl: If this is an SSL context, then
|
use that context. If this is ``True`` then use default SSL context. If
|
this is ``False`` then disable SSL.
|
:param subprotocols: An iterable of strings representing preferred
|
subprotocols.
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing
|
HTTP header key/value pairs to send with the connection request. Note
|
that headers used by the WebSocket protocol (e.g.
|
``Sec-WebSocket-Accept``) will be overwritten.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:param float connect_timeout: The number of seconds to wait for the
|
connection before timing out.
|
:param float disconnect_timeout: The number of seconds to wait when closing
|
the connection before timing out.
|
:raises HandshakeError: for any networking error,
|
client-side timeout (:exc:`ConnectionTimeout`, :exc:`DisconnectionTimeout`),
|
or server rejection (:exc:`ConnectionRejected`) during handshakes.
|
N©Úuse_sslr9 r: r; r< )
|
r Ú open_nurseryZ
|
fail_afterÚconnect_websocketZ TooSlowErrorÚConnectionTimeoutÚOSErrorÚHandshakeErrorÚacloseÚDisconnectionTimeout) ÚhostÚportÚresourcer@ r9 r: r; r< r= r> Z new_nurseryÚ
|
connectionÚer r r Úopen_websocketM s, % ü
|
|
rM )r9 r: r; r< c
|
à sæ |dkrt ¡ } n(|dkr d} nt|t jr2|} ntdt d| dkrLdnd|||¡ | dkrtt ||¡I dH }
|
ntj ||| ddI dH }
|
|d kr|} n| d
|
| } t
|
|
|
t t j | |||||d } | | j¡ | j ¡ I dH | S ) aÉ
|
Return an open WebSocket client connection to a host.
|
|
This function is used to specify a custom nursery to run connection
|
background tasks in. The caller is responsible for closing the connection.
|
|
If you don't need a custom nursery, you should probably use
|
:func:`open_websocket` instead.
|
|
:param nursery: A Trio nursery to run background tasks in.
|
:param str host: The host to connect to.
|
:param int port: The port to connect to.
|
:param str resource: The resource, i.e. URL path.
|
:param Union[bool, ssl.SSLContext] use_ssl: If this is an SSL context, then
|
use that context. If this is ``True`` then use default SSL context. If
|
this is ``False`` then disable SSL.
|
:param subprotocols: An iterable of strings representing preferred
|
subprotocols.
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing
|
HTTP header key/value pairs to send with the connection request. Note
|
that headers used by the WebSocket protocol (e.g.
|
``Sec-WebSocket-Accept``) will be overwritten.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:rtype: WebSocketConnection
|
TFNz1`use_ssl` argument must be bool or ssl.SSLContextz Connecting to ws%s://%s:%d%sÚ Ús)Ú ssl_contextÚhttps_compatible)éP é» ú:©rH ÚpathÚclient_subprotocolsÚclient_extra_headersr; r< )ÚsslÚcreate_default_contextr Ú
|
SSLContextÚ TypeErrorÚloggerÚdebugr Zopen_tcp_streamZopen_ssl_over_tcp_streamÚWebSocketConnectionr
|
r ÚCLIENTÚ
|
start_soonÚ _reader_taskÚ_open_handshakeÚwait) ÚnurseryrH rI rJ r@ r9 r: r; r< rP ÚstreamZ host_headerrK r r r rB sD
|
ÿ ÿ ú rB c C s. t | |\}} }
|
}t|| |
|
|||||||d
|
S )au
|
Open a WebSocket client connection to a URL.
|
|
This async context manager connects when entering the context manager and
|
disconnects when exiting. It yields a
|
:class:`WebSocketConnection` instance.
|
|
:param str url: A WebSocket URL, i.e. `ws:` or `wss:` URL scheme.
|
:param ssl_context: Optional SSL context used for ``wss:`` URLs. A default
|
SSL context is used for ``wss:`` if this argument is ``None``.
|
:type ssl_context: ssl.SSLContext or None
|
:param subprotocols: An iterable of strings representing preferred
|
subprotocols.
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing
|
HTTP header key/value pairs to send with the connection request. Note
|
that headers used by the WebSocket protocol (e.g.
|
``Sec-WebSocket-Accept``) will be overwritten.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:param float connect_timeout: The number of seconds to wait for the
|
connection before timing out.
|
:param float disconnect_timeout: The number of seconds to wait when closing
|
the connection before timing out.
|
:raises HandshakeError: for any networking error,
|
client-side timeout (:exc:`ConnectionTimeout`, :exc:`DisconnectionTimeout`),
|
or server rejection (:exc:`ConnectionRejected`) during handshakes.
|
)r@ r9 r: r; r< r= r> )Ú _url_to_hostrM ) ÚurlrP r9 r: r; r< r= r> rH rI rJ r r r Úopen_websocket_urlÈ s "
|
üri c
|
à s2 t ||\}}} }t| ||| |||||d I dH S )a
|
Return an open WebSocket client connection to a URL.
|
|
This function is used to specify a custom nursery to run connection
|
background tasks in. The caller is responsible for closing the connection.
|
|
If you don't need a custom nursery, you should probably use
|
:func:`open_websocket_url` instead.
|
|
:param nursery: A nursery to run background tasks in.
|
:param str url: A WebSocket URL.
|
:param ssl_context: Optional SSL context used for ``wss:`` URLs.
|
:type ssl_context: ssl.SSLContext or None
|
:param subprotocols: An iterable of strings representing preferred
|
subprotocols.
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing
|
HTTP header key/value pairs to send with the connection request. Note
|
that headers used by the WebSocket protocol (e.g.
|
``Sec-WebSocket-Accept``) will be overwritten.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:rtype: WebSocketConnection
|
r? N)rg rB )
|
re rh rP r9 r: r; r< rH rI rJ r r r Úconnect_websocket_urlò s
|
ýrj c C s t | } tj | ¡}|jdkr&td|dkr:|jdk}n|jdkrLtd|j}|jdk rd|j}n |rldnd}|j}|s~d }d
|
| kr|d
|
|j 7 }||||fS ) a
|
Convert a WebSocket URL to a (host,port,resource) tuple.
|
|
The returned ``ssl_context`` is either the same object that was passed in,
|
or if ``ssl_context`` is None, then a bool indicating if a default SSL
|
context needs to be created.
|
|
:param str url: A WebSocket URL.
|
:type ssl_context: ssl.SSLContext or None
|
:returns: A tuple of ``(host, port, resource, ssl_context)``.
|
)ÚwsÚwssz,WebSocket URL scheme must be "ws:" or "wss:"Nrl rk z+SSL context must be None for ws: URL schemerS rR ú/ú?)
|
ÚstrÚurllibÚparseÚurlsplitÚschemeÚ
|
ValueErrorÚhostnamerI rV Úquery)rh rP ÚpartsrH rI Zpath_qsr r r rg s$
|
|
|
rg c
|
à s> t |ttj||||||d}| |j¡ |j ¡ I dH |S )a
|
Wrap an arbitrary stream in a WebSocket connection.
|
|
This is a low-level function only needed in rare cases. In most cases, you
|
should use :func:`open_websocket` or :func:`open_websocket_url`.
|
|
:param nursery: A Trio nursery to run background tasks in.
|
:param stream: A Trio stream to be wrapped.
|
:type stream: trio.abc.Stream
|
:param str host: A host string that will be sent in the ``Host:`` header.
|
:param str resource: A resource string, i.e. the path component to be
|
accessed on the server.
|
:param subprotocols: An iterable of strings representing preferred
|
subprotocols.
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing
|
HTTP header key/value pairs to send with the connection request. Note
|
that headers used by the WebSocket protocol (e.g.
|
``Sec-WebSocket-Accept``) will be overwritten.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:rtype: WebSocketConnection
|
rU N)r_ r
|
r r` ra rb rc rd ) re rf rH rJ r9 r: r; r< rK r r r Úwrap_client_stream: s û rx c à s4 t |ttj||d}| |j¡ | ¡ I dH }|S )aÀ
|
Wrap an arbitrary stream in a server-side WebSocket.
|
|
This is a low-level function only needed in rare cases. In most cases, you
|
should use :func:`serve_websocket`.
|
|
:param nursery: A nursery to run background tasks in.
|
:param stream: A stream to be wrapped.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:type stream: trio.abc.Stream
|
:rtype: WebSocketRequest
|
©r; r< N)r_ r
|
r ÚSERVERra rb Ú _get_request)re rf r; r< rK Úrequestr r r Úwrap_server_streama s ý r} )Úhandler_nurseryr; r< r= r> Ú task_statusc à sf |dkrt tj||d}
|
nt tj|||dd}
|
|
|
I dH } t| | |||||d} | j| dI dH dS )u
|
Serve a WebSocket over TCP.
|
|
This function supports the Trio nursery start protocol: ``server = await
|
nursery.start(serve_websocket, â¦)``. It will block until the server
|
is accepting connections and then return a :class:`WebSocketServer` object.
|
|
Note that if ``host`` is ``None`` and ``port`` is zero, then you may get
|
multiple listeners that have *different port numbers!*
|
|
:param handler: An async function that is invoked with a request
|
for each new connection.
|
:param host: The host interface to bind. This can be an address of an
|
interface, a name that resolves to an interface address (e.g.
|
``localhost``), or a wildcard address like ``0.0.0.0`` for IPv4 or
|
``::`` for IPv6. If ``None``, then all local interfaces are bound.
|
:type host: str, bytes, or None
|
:param int port: The port to bind to.
|
:param ssl_context: The SSL context to use for encrypted connections, or
|
``None`` for unencrypted connection.
|
:type ssl_context: ssl.SSLContext or None
|
:param handler_nursery: An optional nursery to spawn handlers and background
|
tasks in. If not specified, a new nursery will be created internally.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
:param float connect_timeout: The number of seconds to wait for a client
|
to finish connection handshake before timing out.
|
:param float disconnect_timeout: The number of seconds to wait for a client
|
to finish the closing handshake before timing out.
|
:param task_status: Part of Trio nursery start protocol.
|
:returns: This function runs until cancelled.
|
N)rH T)rH rQ ©r~ r; r< r= r> ©r )r r Úopen_tcp_listenersZopen_ssl_over_tcp_listenersÚWebSocketServerÚrun) ÚhandlerrH rI rP r~ r; r< r= r> r r Ú listenersÚserverr r r Úserve_websocket| s ' ÿ ýr c @ s e Zd ZdZdS )rE z^
|
There was an error during connection or disconnection with the websocket
|
server.
|
N©r4 r5 r6 r7 r r r r rE ° s rE c @ s e Zd ZdZdS )rC z<There was a timeout when connecting to the websocket server.Nr r r r r rC ¶ s rC c @ s e Zd ZdZdS )rG zAThere was a timeout when disconnecting from the websocket server.Nr r r r r rG ¹ s rG c s( e Zd ZdZ fddZdd Z ZS )ÚConnectionClosedzv
|
A WebSocket operation cannot be completed because the connection is closed
|
or in the process of closing.
|
c s t ¡ || _dS ©zX
|
Constructor.
|
|
:param reason:
|
:type reason: CloseReason
|
N)Úsuperr( Úreason)r' r ©Ú __class__r r r( Á s
|
zConnectionClosed.__init__c C s | j j d| j dS )ú Return representation. ú<ú>)r r4 r r& r r r Ú__repr__Ë s zConnectionClosed.__repr__©r4 r5 r6 r7 r( r Ú __classcell__r r r r r ¼ s
|
r c s( e Zd ZdZ fddZdd Z ZS )ÚConnectionRejectedzq
|
A WebSocket connection could not be established because the server rejected
|
the connection attempt.
|
c s t ¡ || _|| _|| _dS r )r r( Ú status_codeÚheadersÚbody)r' r r r r r r r( Õ s
|
zConnectionRejected.__init__c C s | j j d| j dS )r z <status_code=r )r r4 r r& r r r r ä s zConnectionRejected.__repr__r r r r r r Ð s r c @ sD e Zd ZdZdd Zedd Zedd Zedd Zd
|
d Z d S ) Ú CloseReasonz8 Contains information about why a WebSocket was closed. c C s || _ zt |¡j| _W nz tk
|
r d| kr<dkrHn nd| _nFd| kr\dkrhn nd| _n&d| kr|dkrn nd | _nd
|
| _Y nX || _d S ) z]
|
Constructor.
|
|
:param int code:
|
:param Optional[str] reason:
|
éè i· Z RFC_RESERVEDi¸ i Z IANA_RESERVEDi i ZPRIVATE_RESERVEDZ INVALID_CODEN)Ú_codeÚ wsframeprotor ÚnameÚ_namert Ú_reason©r' Úcoder r r r r( ë s zCloseReason.__init__c C s | j S )z% (Read-only) The numeric close code. )r r& r r r r¢ s zCloseReason.codec C s | j S )z, (Read-only) The human-readable close code. )r r& r r r r s zCloseReason.namec C s | j S )z) (Read-only) An arbitrary reason string. )r r& r r r r
|
s zCloseReason.reasonc C s& | j j d| j d| j d| j dS )z$ Show close code, name, and reason. z<code=z, name=z , reason=r )r r4 r¢ r r r& r r r r s zCloseReason.__repr__N)
|
r4 r5 r6 r7 r( Úpropertyr¢ r r r r r r r r é s
|
|
|
r c @ s( e Zd ZdZdd Zdd Zdd ZdS ) ÚFuturez: Represents a value that will be available in the future. c C s d| _ t ¡ | _dS )z Constructor. N)Ú_valuer ÚEventÚ _value_eventr& r r r r( s zFuture.__init__c C s || _ | j ¡ dS )zT
|
Set a value, which will notify any waiters.
|
|
:param value:
|
N)r¥ r§ Úset)r' r1 r r r Ú set_value s zFuture.set_valuec à s | j ¡ I dH | jS )z|
|
Wait for this future to have a value, then return it.
|
|
:returns: The value set by ``set_value()``.
|
N)r§ rd r¥ r& r r r Ú
|
wait_value% s zFuture.wait_valueN)r4 r5 r6 r7 r( r© rª r r r r r¤ s r¤ c @ st e Zd ZdZdd Zedd Zedd Zedd Zed
|
d Z ed d Z
|
dddddZ dddddZ dS )ÚWebSocketRequestzß
|
Represents a handshake presented by a client to a server.
|
|
The server may modify the handshake or leave it as is. The server should
|
call ``accept()`` to finish the handshake and obtain a connection object.
|
c C s || _ || _dS )zz
|
Constructor.
|
|
:param WebSocketConnection connection:
|
:type event: wsproto.events.Request
|
N)Ú _connectionÚ_event)r' rK Úeventr r r r( 6 s zWebSocketRequest.__init__c C s | j jS )zi
|
HTTP headers represented as a list of (name, value) pairs.
|
|
:rtype: list[tuple]
|
)r r: r& r r r r @ s zWebSocketRequest.headersc C s | j jS )z>
|
The requested URL path.
|
|
:rtype: str
|
)r Útargetr& r r r rV I s zWebSocketRequest.pathc C s t | jjS )zZ
|
A tuple of protocols proposed by the client.
|
|
:rtype: tuple[str]
|
)Útupler r9 r& r r r Úproposed_subprotocolsR s z&WebSocketRequest.proposed_subprotocolsc C s | j jS )zS
|
The connection's local endpoint.
|
|
:rtype: Endpoint or str
|
)r¬ Úlocalr& r r r r² [ s zWebSocketRequest.localc C s | j jS )zT
|
The connection's remote endpoint.
|
|
:rtype: Endpoint or str
|
)r¬ Úremoter& r r r r³ d s zWebSocketRequest.remoteN©Ú subprotocolr: c à s* |dkr g }| j | j||¡I dH | j S )a
|
Accept the request and return a connection object.
|
|
:param subprotocol: The selected subprotocol for this connection.
|
:type subprotocol: str or None
|
:param extra_headers: A list of 2-tuples containing key/value pairs to
|
send as HTTP headers.
|
:type extra_headers: list[tuple[bytes,bytes]] or None
|
:rtype: WebSocketConnection
|
N)r¬ Ú_acceptr )r' rµ r: r r r Úacceptm s zWebSocketRequest.accept)r: r c à s* |pg }|pd}| j |||¡I dH dS )a#
|
Reject the handshake.
|
|
:param int status_code: The 3 digit HTTP status code. In order to be
|
RFC-compliant, this should NOT be 101, and would ideally be an
|
appropriate code in the range 300-599.
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples
|
containing key/value pairs to send as HTTP headers.
|
:param body: If provided, this data will be sent in the response
|
body, otherwise no response body will be sent.
|
:type body: bytes or None
|
r- N)r¬ Ú_reject)r' r r: r r r r Úreject} s zWebSocketRequest.reject) r4 r5 r6 r7 r( r£ r rV r± r² r³ r· r¹ r r r r r« / s
|
|
|
|
|
|
r« c C sl d\}}t | tjr | j}nt | tjr4| jj}d}|r`|rD| ¡ n| ¡ ^}}}t|||}nt | }|S )a*
|
Construct an endpoint from a stream.
|
|
:param trio.Stream stream:
|
:param bool local: If true, return local endpoint. Otherwise return remote.
|
:returns: An endpoint instance or ``repr()`` for streams that cannot be
|
represented as an endpoint.
|
:rtype: Endpoint or str
|
r% T)
|
r r Z SocketStreamÚsocketZ SSLStreamZtransport_streamÚ getsocknameÚ getpeernameÚEndpointÚrepr)rf r² rº Úis_sslÚaddrrI Ú_Zendpointr r r Ú_get_stream_endpoint s
|
r c @ sP e Zd ZdZe ¡ ZddddeedddZ e
|
dd Z e
|
dd Z e
|
d
|
d Z e
|
d d Ze
|
dd Ze
|
dd Ze
|
dd Ze
|
dd ZdEddZdd Zdd ZdFd d ZdGd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Z d+d, Z dHd-d.Z d/d0 Z d1d2 Z d3d4 Z!d5d6 Z"d7d8 Z#d9d: Z$d;d< Z%d=d> Z&d?d@ Z'dAdB Z(dCdD Z)dS )Ir_ z A WebSocket connection. NrU c C sÊ d| _ t| jj| _|| _t ¡ | _|| _ d| _
|
g | _ || _ d| _ |jr`t||||pVg d| _nd| _|| _d| _d| _d| _d| _d| _t |¡\| _| _t | _t | _ t ¡ | _ t ¡ | _ d| _!dS )a
|
Constructor.
|
|
Generally speaking, users are discouraged from directly instantiating a
|
``WebSocketConnection`` and should instead use one of the convenience
|
functions in this module, e.g. ``open_websocket()`` or
|
``serve_websocket()``. This class has some tricky internal logic and
|
timing that depends on whether it is an instance of a client connection
|
or a server connection. The convenience functions handle this complexity
|
for you.
|
|
:param SocketStream stream:
|
:param ws_connection wsproto.WSConnection:
|
:param str host: The hostname to send in the HTTP request headers. Only
|
used for client connections.
|
:param str path: The URL path for this connection.
|
:param list client_subprotocols: A list of desired subprotocols. Only
|
used for client connections.
|
:param list[tuple[bytes,bytes]] client_extra_headers: Extra headers to
|
send with the connection request. Only used for client connections.
|
:param int message_queue_size: The maximum number of messages that will be
|
buffered in the library's internal message queue.
|
:param int max_message_size: The maximum message size as measured by
|
``len()``. If a message is received that is larger than this size,
|
then the connection is closed with code 1009 (Message Too Big).
|
Nr T)rH r¯ r9 r: r- )"Ú _close_reasonÚnextr Ú CONNECTION_IDÚ_idÚ_streamr ZStrictFIFOLockÚ _stream_lockÚ_wsprotoÚ _message_sizeÚ_message_partsÚ_max_message_sizeÚ_reader_runningÚclientr Ú_initial_requestÚ_pathÚ _subprotocolÚ_handshake_headersÚ_reject_statusÚ_reject_headersÚ _reject_bodyZopen_memory_channelÚ _send_channelÚ _recv_channelr Ú_pingsr¤ Ú_connection_proposalr¦ rc Ú_close_handshakeÚ#_for_testing_peer_closed_connection) r' rf Z ws_connectionrH rV rW rX r; r< r r r r( ¬ s:
|
þ
|
ÿ
|
|
z WebSocketConnection.__init__c C s | j S )z
|
(Read-only) The reason why the connection was closed, or ``None`` if the
|
connection is still open.
|
|
:rtype: CloseReason
|
)rà r& r r r Úclosedð s zWebSocketConnection.closedc C s | j jS )z( (Read-only) Is this a client instance? ©rÉ rÎ r& r r r Ú is_clientú s z WebSocketConnection.is_clientc C s
|
| j j S )z( (Read-only) Is this a server instance? rÝ r& r r r Ú is_serverÿ s z WebSocketConnection.is_serverc C s t | jddS )zX
|
The local endpoint of the connection.
|
|
:rtype: Endpoint or str
|
T©r² ©r rÇ r& r r r r² s zWebSocketConnection.localc C s t | jddS )zY
|
The remote endpoint of the connection.
|
|
:rtype: Endpoint or str
|
Frà rá r& r r r r³ s zWebSocketConnection.remotec C s | j S )zº
|
The requested URL path. For clients, this is set when the connection is
|
instantiated. For servers, it is set after the handshake completes.
|
|
:rtype: str
|
)rÐ r& r r r rV s zWebSocketConnection.pathc C s | j S )zË
|
(Read-only) The negotiated subprotocol, or ``None`` if there is no
|
subprotocol.
|
|
This is only valid after the opening handshake is complete.
|
|
:rtype: str or None
|
)rÑ r& r r r rµ s
|
z WebSocketConnection.subprotocolc C s | j S )zÞ
|
The HTTP headers that were sent by the remote during the handshake,
|
stored as 2-tuples containing key/value pairs. Header keys are always
|
lower case.
|
|
:rtype: tuple[tuple[str,str]]
|
)rÒ r& r r r Úhandshake_headers, s z%WebSocketConnection.handshake_headersr c à s( t | ||¡I dH W 5 Q R X dS )a7
|
Close the WebSocket connection.
|
|
This sends a closing frame and suspends until the connection is closed.
|
After calling this method, any further I/O on this WebSocket (such as
|
``get_message()`` or ``send_message()``) will raise
|
``ConnectionClosed``.
|
|
This method is idempotent: it may be called multiple times on the same
|
connection without any errors.
|
|
:param int code: A 4-digit code number indicating the type of closure.
|
:param str reason: An optional string describing the closure.
|
N)r" Ú_acloser¡ r r r rF 7 s zWebSocketConnection.aclosec à s° | j r
|
d S zzv| jjtjkrBtdd | _ | t||d¡I d H n | jjtj tj
|
fkr`| j ¡ | j ¡ I d H | j ¡ I d H W n tk
|
r Y nX W 5 | ¡ I d H X d S )Nr ©r¢ r )rÃ Ú _close_streamrÉ Ústater ÚOPENr Ú_sendr Z
|
CONNECTINGZ REJECTINGrÚ r¨ r× rF rd r r¡ r r r rã I s
|
ÿ
|
|
zWebSocketConnection._aclosec à sB z| j ¡ I dH }W n( tjtjfk
|
r< t| jdY nX |S )a£
|
Receive the next WebSocket message.
|
|
If no message is available immediately, then this function blocks until
|
a message is ready.
|
|
If the remote endpoint closes the connection, then the caller can still
|
get messages sent prior to closing. Once all pending messages have been
|
retrieved, additional calls to this method will raise
|
``ConnectionClosed``. If the local endpoint closes the connection, then
|
pending messages are discarded and calls to this method will immediately
|
raise ``ConnectionClosed``.
|
|
:rtype: str or bytes
|
:raises ConnectionClosed: if the connection is closed.
|
N)r× Zreceiver ÚClosedResourceErrorZ EndOfChannelr rà )r' Úmessager r r Ú get_messagec s
|
z WebSocketConnection.get_messagec à s~ | j rt| j || jkr*td| d|dkrDt dt d¡¡}t ¡ }|| j|< |
|
t |d¡I dH | ¡ I dH dS )aA
|
Send WebSocket ping to remote endpoint and wait for a correspoding pong.
|
|
Each in-flight ping must include a unique payload. This function sends
|
the ping and then waits for a corresponding pong from the remote
|
endpoint.
|
|
*Note: If the remote endpoint recieves multiple pings, it is allowed to
|
send a single pong. Therefore, the order of calls to ``ping()`` is
|
tracked, and a pong will wake up its corresponding ping as well as all
|
previous in-flight pings.*
|
|
:param payload: The payload to send. If ``None`` then a random 32-bit
|
payload is created.
|
:type payload: bytes or None
|
:raises ConnectionClosed: if connection is closed.
|
:raises ValueError: if ``payload`` is identical to another in-flight
|
ping.
|
zPayload value z is already in flight.Nz!Ié ©Úpayload) rà r rØ rt ÚstructÚpackÚrandomÚ getrandbitsr r¦ rè r rd )r' rî r® r r r Úpingz s
|
|
|
zWebSocketConnection.pingc à s* | j rt| j | t|d¡I dH dS )zè
|
Send an unsolicted pong.
|
|
:param payload: The pong's payload. If ``None``, then no payload is
|
sent.
|
:type payload: bytes or None
|
:raises ConnectionClosed: if connection is closed
|
rí N)rà r rè r )r' rî r r r Úpong s
|
zWebSocketConnection.pongc à sX | j rt| j t|tr&t|d}n t|tr<t|d}ntd| |¡I dH dS )zÈ
|
Send a WebSocket message.
|
|
:param message: The message to send.
|
:type message: str or bytes
|
:raises ConnectionClosed: if connection is closed, or being closed
|
©Údataz message must be str or bytesN) rà r r ro r Úbytesr rt rè )r' rê r® r r r Ú send_message¦ s
|
|
|
z WebSocketConnection.send_messagec C s | j r
|
dnd}| d| j S )z Connection ID and type. rÎ r ú-)rÞ rÆ )r' Útype_r r r Ú__str__¸ s zWebSocketConnection.__str__c à s6 || _ |j| _| t| j |d¡I dH | j ¡ dS )ah
|
Accept the handshake.
|
|
This method is only applicable to server-side connections.
|
|
:param wsproto.events.Request request:
|
:param subprotocol:
|
:type subprotocol: str or None
|
:param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples
|
containing key/value pairs to send as HTTP headers.
|
r´ N)rÑ r¯ rÐ rè r rc r¨ )r' r| rµ r: r r r r¶ ½ s
|
ÿzWebSocketConnection._acceptc à sz |r | dtt| d¡f¡ t||t|d}| |¡I dH |r`t|d}| |¡I dH tdd| _ | j
|
¡ dS )a¤
|
Reject the handshake.
|
|
:param int status_code: The 3 digit HTTP status code. In order to be
|
RFC-compliant, this must not be 101, and should be an appropriate
|
code in the range 300-599.
|
:param list[tuple[bytes,bytes]] headers: A list of 2-tuples containing
|
key/value pairs to send as HTTP headers.
|
:param bytes body: An optional response body.
|
zContent-lengthÚascii)r r Úhas_bodyNrõ iî z Rejected WebSocket handshake) Úappendro ÚlenÚencoder Úboolrè r r rà rÚ r¨ )r' r r r Z reject_connZ reject_bodyr r r r¸ Ï s ÿ
|
zWebSocketConnection._rejectc à sX t jj}| jjtjkr*| j t|j d¡ | j
|
dkrD| |¡I dH d| _ | j ¡ dS )zÿ
|
If a stream is closed outside of this class, e.g. due to network
|
conditions or because some other code closed our stream object, then we
|
cannot perform the close handshake. We just need to clean up internal
|
state.
|
)r¢ NF)r r ZABNORMAL_CLOSURErÉ ræ r rç Úsendr r1 rà Ú_close_web_socketrÍ rÚ r¨ )r' Z close_reasonr r r Ú_abort_web_socketå s
|
z%WebSocketConnection._abort_web_socketc à sH d| _ z&t | j ¡ I dH W 5 Q R X W n tjk
|
rB Y nX dS )z Close the TCP connection. FN)rÍ r" rÇ rF r ÚBrokenResourceErrorr& r r r rå ö s z!WebSocketConnection._close_streamc à s8 t ||| _t| j}t d| |¡ | j ¡ I dH dS )zÃ
|
Mark the WebSocket as closed. Close the message channel so that if any
|
tasks are suspended in get_message(), they will wake up with a
|
ConnectionClosed exception.
|
z%s websocket closed %rN)r rà r r] r^ rÖ rF )r' r¢ r r r r r r s
|
z%WebSocketConnection._close_web_socketc à s: | j std| jdkr td| j ¡ I dH }d| _|S )zÊ
|
Return a proposal for a WebSocket handshake.
|
|
This method can only be called on server connections and it may only be
|
called one time.
|
|
:rtype: WebSocketRequest
|
z1This method is only valid for server connections.NzTNo proposal available. Did you call this method multiple times or at the wrong time?)rß Ú RuntimeErrorrÙ rª )r' Úproposalr r r r{ s
|
z WebSocketConnection._get_requestc à s t | |}| j |¡ dS )z¿
|
Handle a connection request.
|
|
This method is async even though it never awaits, because the event
|
dispatch requires an async function.
|
|
:param event:
|
N)r« rÙ r© )r' r® r r r r Ú_handle_request_event s
|
z)WebSocketConnection._handle_request_eventc à s" |j | _t|j| _| j ¡ dS )zi
|
Handle an AcceptConnection event.
|
|
:param wsproto.eventsAcceptConnection event:
|
N)rµ rÑ r° r: rÒ rc r¨ ©r' r® r r r Ú _handle_accept_connection_event) s z3WebSocketConnection._handle_accept_connection_eventc à s0 |j | _t|j| _|js,t| j| jdddS )zI
|
Handle a RejectConnection event.
|
|
:param event:
|
N©r )r rÓ r° r rÔ rý r r r r r Ú _handle_reject_connection_event3 s
|
ÿz3WebSocketConnection._handle_reject_connection_eventc à s. | j |j7 _ |jr*t| j| j| j ddS )zC
|
Handle a RejectData event.
|
|
:param event:
|
r N)rÕ rö Z body_finishedr rÓ rÔ r r r r Ú_handle_reject_data_event? s
|
|
ÿz-WebSocketConnection._handle_reject_data_eventc à s | j jtjkrVt|j|jp d| _| jrB| j ¡ t
|
d¡I dH | | ¡ ¡I dH | |j|jpfd¡I dH | j ¡ | jr| ¡ I dH dS )z]
|
Handle a close event.
|
|
:param wsproto.events.CloseConnection event:
|
Nr )rÉ ræ r ZREMOTE_CLOSINGr r¢ r rà rÛ r¨ r Úsleeprè Úresponser rÚ rß rå r r r r Ú _handle_close_connection_eventJ s
|
|
z2WebSocketConnection._handle_close_connection_eventc à sè | j t|j7 _ | j |j¡ | j | jkrd| j d}d| _ g | _td|| _| t d|d¡I dH | j
|
¡ I dH d| _ n`|j rät|trdnd | j¡}d| _ g | _z| j |¡I dH W n tjtjfk
|
râ Y nX dS )
|
z
|
Handle a message event.
|
|
:param event:
|
:type event: wsproto.events.BytesMessage or wsproto.events.TextMessage
|
z Exceeded maximum message size: z bytesr iñ rä NFr- rN )rÊ rÿ rö rË rþ rÌ r rà rè r r× rF rÍ Zmessage_finishedr r ÚjoinrÖ r r ré r )r' r® ÚerrÚmsgr r r Ú_handle_message_eventa s( ÿz)WebSocketConnection._handle_message_eventc à s( t d| |j¡ | | ¡ ¡I dH dS )z¼
|
Handle a PingReceived event.
|
|
Wsproto queues a pong frame automatically, so this handler just needs to
|
send it.
|
|
:param wsproto.events.Ping event:
|
z
|
%s ping %rN)r] r^ rî rè r r r r r Ú_handle_ping_event s z&WebSocketConnection._handle_ping_eventc à s~ t |j}z| j| }W n tk
|
r. Y dS X | jrz| j d¡\}}||krRdnd}t d| ||¡ | ¡ ||kr0qzq0dS )aÝ
|
Handle a PongReceived event.
|
|
When a pong is received, check if we have any ping requests waiting for
|
this pong response. If the remote endpoint skipped any earlier pings,
|
then we wake up those skipped pings, too.
|
|
This function is async even though it never awaits, because the other
|
event handlers are async, too, and event dispatch would be more
|
complicated if some handlers were sync.
|
|
:param event:
|
Nr z [skipped] ú z %s pong%s%r)r÷ rî rØ ÚKeyErrorÚpopitemr] r^ r¨ )r' r® rî ÚkeyÚskippedr r r Ú_handle_pong_event s
|
z&WebSocketConnection._handle_pong_eventc à s$ t | jt| jt| jt| jt| j t
|
| j t | j t| jt| ji }| jrrz| | j¡I dH W n tk
|
rp d| _Y nX | jr| j ¡ D ]v}t|}z(|| }t d| |¡ ||I dH W q tk
|
rÚ t d| |¡ Y q tk
|
rø d| _Y qüY qX qz| j t ¡I dH }W n2 t j t j!fk
|
rD | "¡ I dH Y qY nX t#|dkrt d| ¡ | jj$t%j&kr| "¡ I dH qt d| t#|¡ | jj$t%j&krrz| j '|¡ W qr t(j)j*k
|
r } z:t d| |¡ |j+rò| |j+¡I dH | ,¡ I dH W 5 d}~X Y qrX qrt d | ¡ dS )
|
zA A background task that reads network data and generates events. NFz%s received event: %sz$%s received unknown event type: "%s"r z*%s received zero bytes (connection closed)z%s received %d bytesz %s remote protocol error: %sz%s reader task finished)-r r
|
r r r r r r r r r r r r r r r rÏ rè r rÍ rÉ ÚeventsÚtyper] r^ r ÚwarningrÇ Z receive_someÚ RECEIVE_BYTESr r ré r rÿ ræ r ZCLOSEDZ receive_dataÚwsprotoZ utilitiesZRemoteProtocolErrorZ
|
event_hintrå )r' Úhandlersr® Z
|
event_typer
rö r r r r rb ¨ s| ÷ ÿÿ ÿ"z WebSocketConnection._reader_taskc
|
à s | j |¡}| j4 I dH f t d| t|¡ z| j |¡I dH W n6 tj tj
|
fk
|
rz | ¡ I dH t | j dY nX W 5 Q I dH R X dS )a
|
Send an event to the remote WebSocket.
|
|
The reader task and one or more writers might try to send messages at
|
the same time, so this method uses an internal lock to serialize
|
requests to send data.
|
|
:param wsproto.events.Event event:
|
Nz%s sending %d bytes)rÉ r rÈ r] r^ rÿ rÇ Zsend_allr r ré r r rà )r' r® rö r r r rè ç s
|
zWebSocketConnection._send)r N)N)N)N)*r4 r5 r6 r7 Ú itertoolsÚcountrÅ ÚMESSAGE_QUEUE_SIZEÚMAX_MESSAGE_SIZEr( r£ rÜ rÞ rß r² r³ rV rµ râ rF rã rë ró rô rø rû r¶ r¸ r rå r r{ r r
|
r r r r r r rb rè r r r r r_ § s^ ý D
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
?r_ c @ s, e Zd ZdZdd Zedd Zdd ZdS ) r½ z# Represents a connection endpoint. c C s t || _|| _|| _d S r )r ÚaddressrI r¿ )r' r& rI r¿ r r r r( ý s
|
zEndpoint.__init__c C sx | j r
|
dnd}| jdkr | j r.| jdkr4| j r4d}ndt| j }| jjdkrb| d| j | S | d | j d
|
| S ) zT Return a URL representation of a TCP endpoint, e.g.
|
``ws://127.0.0.1:80``. rl rk rR rS rN rT é z://z://[ú])r¿ rI ro r& Úversion)r' rs Zport_strr r r rh s ÿÿ z Endpoint.urlc C s d| j d| j d| j dS )z! Return endpoint info as string. zEndpoint(address="z", port=z , is_ssl=ú))r& rI r¿ r& r r r r s zEndpoint.__repr__N)r4 r5 r6 r7 r( r£ rh r r r r r r½ û s
|
|
r½ c @ sV e Zd ZdZdeeeedddZedd Z edd Z
|
e j d
|
d d Z d d ZdS )r zé
|
WebSocket server.
|
|
The server class handles incoming connections on one or more ``Listener``
|
objects. For each incoming connection, it creates a ``WebSocketConnection``
|
instance and starts some background tasks,
|
Nr c C sB t |dkrtd|| _|| _|| _|| _|| _|| _|| _dS )a
|
Constructor.
|
|
Note that if ``host`` is ``None`` and ``port`` is zero, then you may get
|
multiple listeners that have _different port numbers!_ See the
|
``listeners`` property.
|
|
:param handler: the async function called with a :class:`WebSocketRequest`
|
on each new connection. The call will be made
|
once the HTTP handshake completes, which notably implies that the
|
connection's `path` property will be valid.
|
:param listeners: The WebSocket will be served on each of the listeners.
|
:param handler_nursery: An optional nursery to spawn connection tasks
|
inside of. If ``None``, then a new nursery will be created
|
internally.
|
:param float connect_timeout: The number of seconds to wait for a client
|
to finish connection handshake before timing out.
|
:param float disconnect_timeout: The number of seconds to wait for a client
|
to finish the closing handshake before timing out.
|
r z)Listeners must contain at least one item.N) rÿ rt Ú_handlerÚ_handler_nurseryÚ
|
_listenersÚ_message_queue_sizerÌ Ú_connect_timeoutÚ_disconnect_timeout)r' r
r r~ r; r< r= r> r r r r( ! s zWebSocketServer.__init__c C sV t | jdkrtd| jd }z|jW S tk
|
rP tdt| dY nX dS )a§ Returns the requested or kernel-assigned port number.
|
|
In the case of kernel-assigned port (requested with port=0 in the
|
constructor), the assigned port will be reflected after calling
|
starting the `listen` task. (Technically, once listen reaches the
|
"started" state.)
|
|
This property only works if you have a single listener, and that
|
listener must be socket-based.
|
r z>Cannot get port because this server has more than 1 listeners.r z"This socket does not have a port: N)rÿ r- r r rI ÚAttributeErrorr¾ )r' Úlistenerr r r rI C s
|
zWebSocketServer.portc C s~ g }| j D ]n}d\}}t|tjr*|j}nt|tjrB|jj}d}|rj| ¡ }| t |d |d |¡ q
|
| t
|
|¡ q
|
|S )a
|
Return a list of listener metadata. Each TCP listener is represented as
|
an ``Endpoint`` instance. Other listener types are represented by their
|
``repr()``.
|
|
:returns: Listeners
|
:rtype list[Endpoint or str]:
|
r% Tr r ) r- r r ZSocketListenerrº Z SSLListenerZtransport_listenerr» rþ r½ r¾ )r' r r2 rº r¿ Zsocknamer r r r X s
|
|
zWebSocketServer.listenersr c
|
à s t ¡ 4 I dH d}tt j| j| j| jd}| |¡I dH t dd
|
dd | j D ¡¡ | | ¡ t ¡ I dH W 5 Q I dH R X dS )u¯
|
Start serving incoming connections requests.
|
|
This method supports the Trio nursery start protocol: ``server = await
|
nursery.start(server.run, â¦)``. It will block until the server is
|
accepting connections and then return a :class:`WebSocketServer` object.
|
|
:param task_status: Part of the Trio nursery start protocol.
|
:returns: This method never returns unless cancelled.
|
N)r~ zListening on %sú,c S s g | ] }t |qS r )ro )Ú.0Úlr r r Ú
|
<listcomp> s z'WebSocketServer.run.<locals>.<listcomp>)r rA r Úserve_listenersÚ_handle_connectionr- r, Ústartr] r^ r r ÚstartedZ sleep_forever)r' r re r7 r r r r q s þÿ
|
zWebSocketServer.runc à sâ t ¡ 4 I dH Â}t|ttj| j| jd}| |j ¡ t
|
| j ¡}| ¡ I dH }W 5 Q R X |j r|j ¡ | ¡ I dH W 5 Q I dH R £ dS z| |¡I dH W 5 t
|
| j¡ | ¡ I dH W 5 Q R X X W 5 Q I dH R X dS )zÇ
|
Handle an incoming connection by spawning a connection background task
|
and a handler task inside a new nursery.
|
|
:param stream:
|
:type stream: trio.abc.Stream
|
Nry )r rA r_ r
|
r rz r. rÌ ra rb Z move_on_afterr/ r{ Zcancelled_caughtZ cancel_scopeÚcancelrF r0 r+ )r' rf re rK Z connect_scoper| r r r r8 s" ý
|
z"WebSocketServer._handle_connection)r4 r5 r6 r7 r$ r% Ú CONN_TIMEOUTr( r£ rI r r ÚTASK_STATUS_IGNOREDr r8 r r r r r s ý "
|
|
r )N)N)Pr) Ú collectionsr Ú
|
contextlibr Ú functoolsr Ú ipaddressr r" Úloggingrñ rY rï Ú urllib.parserp Útypingr r r Ztrio.abcZexceptiongroupr r r r
|
Zwsproto.connectionr Zwsproto.frame_protocolZframe_protocolr Zwsproto.eventsr r r r r r r r r Zwsproto.utilitiesr° ÚmapÚintÚ __version__Úsplitr. r< r$ r% r Ú getLoggerr] r! r" rM rB ri rj rg rx r} r= r Ú ExceptionrE rC rG r r r r¤ r« r ÚabcZ AsyncResourcer_ r½ r r r r r Ú<module> sª ,
|
ý; þ @ ý * þ $% þ ( ÿ
|
ý 4,` X
|
