U MfH@sddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZmZmZddlmZddlmZddlmZdd lmZdd lmZdd lmZmZdd lmZm Z m!Z!dd l"m#Z#ddl m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddddgZ+Gddde(Z,GdddZ-d2ddddddddddeddddddddddd d!d"dd#d$d%d&d'd(ddd)d)dd*d+dd,d-dZ.d3d.dd/dd0d1dZ/dS)4) annotationsN) TracebackType)AnyCallableOptionalSequenceType) CloseCode)ServerExtensionFactory) enable_server_permessage_deflate)validate_subprotocols) USER_AGENT)RequestResponse) CONNECTINGOPENEvent)ServerProtocol) LoggerLikeOrigin Subprotocol) Connection)Deadlineserve unix_serveServerConnectionWebSocketServercsxeZdZdZdddddddfd d Zd d ed fd d ddddddZdddfdd Zddfdd ZZ S)ra Threaded implementation of a WebSocket server connection. :class:`ServerConnection` provides :meth:`recv` and :meth:`send` methods for receiving and sending messages. It supports iteration to receive messages:: for message in websocket: process(message) The iterator exits normally when the connection is closed with close code 1000 (OK) or 1001 (going away) or without a close code. It raises a :exc:`~websockets.exceptions.ConnectionClosedError` when the connection is closed with any other code. Args: socket: Socket connected to a WebSocket client. protocol: Sans-I/O connection. close_timeout: Timeout for closing the connection in seconds.  close_timeout socket.socketrOptional[float]None)socketprotocolr!returncs$|t|_tj|||ddS)Nr ) threadingr request_rcvdsuper__init__)selfr%r&r! __class__:/tmp/pip-unpacked-wheel-yzabpfcc/websockets/sync/server.pyr+7s zServerConnection.__init__NCOptional[Callable[[ServerConnection, Request], Optional[Response]]]MOptional[Callable[[ServerConnection, Request, Response], Optional[Response]]] Optional[str])process_requestprocess_response server_headertimeoutr'c Cs|j|s&||jtd|jdkrJ||jtd|jt d2d|_ |dk rz|||j|_ WnNt k r}z0||j _ |jjddd|j tjjd|_ W5d}~XYnX|j dkr|j |j|_ |dk r||j jd <|dk rxz|||j|j }WnPt k rf}z0||j _ |jjddd|j tjjd|_ W5d}~XYnX|dk rx||_ |j |j W5QRX|j jtk r|j|j||j|j j dk r|j j dS) z1 Perform the opening handshake. ztimed out during handshakeNz"connection closed during handshake)Zexpected_statezopening handshake failedTexc_infozLFailed to open a WebSocket connection. See server log for more information. Server)r)waitZ close_socketZrecv_events_threadjoin TimeoutErrorrequestConnectionErrorZ send_contextrresponse Exceptionr&Z handshake_excloggererrorrejecthttp HTTPStatusINTERNAL_SERVER_ERRORacceptheadersZ send_responsestaterr!)r,r4r5r6r7excr@r/r/r0 handshakeFsV         zServerConnection.handshaker)eventr'cs:|jdkr*t|tst||_|jn t|dS)z. Process one incoming event. N)r> isinstancerAssertionErrorr)setr* process_event)r,rMr-r/r0rQs   zServerConnection.process_eventr'cs ztW5|jXdS)zI Read incoming data from the socket and process events. N)r)rPr* recv_eventsr,r-r/r0rSszServerConnection.recv_events) __name__ __module__ __qualname____doc__r+rrLrQrS __classcell__r/r/r-r0rsQc@speZdZdZdddddddZd d d d Zd d d dZdd ddZdd ddZdddd dddZ dS)ra WebSocket server returned by :func:`serve`. This class mirrors the API of :class:`~socketserver.BaseServer`, notably the :meth:`~socketserver.BaseServer.serve_forever` and :meth:`~socketserver.BaseServer.shutdown` methods, as well as the context manager protocol. Args: socket: Server socket listening for new connections. handler: Handler for one connection. Receives the socket and address returned by :meth:`~socket.socket.accept`. logger: Logger for this server. Nr"z$Callable[[socket.socket, Any], None]Optional[LoggerLike])r%handlerrBcCsB||_||_|dkrtd}||_tjdkr>t\|_ |_ dS)Nzwebsockets.serverwin32) r%r[logging getLoggerrBsysplatformospipeshutdown_watchershutdown_notifier)r,r%r[rBr/r/r0r+s  zWebSocketServer.__init__r$rRcCst}||jtjtjdkr2||jtj|z|j \}}Wnt k rdYqYnXt j |j ||fd}|q2dS)a See :meth:`socketserver.BaseServer.serve_forever`. This method doesn't return. Calling :meth:`shutdown` from another thread stops the server. Typical use:: with serve(...) as server: server.serve_forever() r\)targetargsN) selectorsDefaultSelectorregisterr% EVENT_READr_r`rcselectrHOSErrorr(Threadr[start)r,Zpollersockaddrthreadr/r/r0 serve_forevers   zWebSocketServer.serve_forevercCs&|jtjdkr"t|jddS)z@ See :meth:`socketserver.BaseServer.shutdown`. r\xN)r%closer_r`rawriterdrTr/r/r0shutdowns  zWebSocketServer.shutdownintcCs |jS)z> See :meth:`socketserver.BaseServer.fileno`. )r%filenorTr/r/r0rxszWebSocketServer.filenocCs|SNr/rTr/r/r0 __enter__szWebSocketServer.__enter__zOptional[Type[BaseException]]zOptional[BaseException]zOptional[TracebackType])exc_type exc_value tracebackr'cCs |dSry)rv)r,r{r|r}r/r/r0__exit__szWebSocketServer.__exit__)N) rUrVrWrXr+rrrvrxrzr~r/r/r/r0rs Fdeflateri)ro ssl_contextunixpathorigins extensions subprotocolsselect_subprotocolr4r5r6 compression open_timeoutr!max_sizerBcreate_connectionz"Callable[[ServerConnection], None]r3z Optional[int]zOptional[socket.socket]zOptional[ssl.SSLContext]boolz$Optional[Sequence[Optional[Origin]]]z*Optional[Sequence[ServerExtensionFactory]]zOptional[Sequence[Subprotocol]]zTOptional[Callable[[ServerConnection, Sequence[Subprotocol]], Optional[Subprotocol]]]r1r2r#rZz Optional[Type[ServerConnection]])r[hostportrorrrrrrrr4r5r6rrr!rrBrr'cs dk rt |dkr"tn|dk r8td|dkrDt|dkrrr|dkr`tdtj|tjd}qt||f}n|dk rtd dk r j|ddd }d d d d  fdd }t ||S)aH Create a WebSocket server listening on ``host`` and ``port``. Whenever a client connects, the server creates a :class:`ServerConnection`, performs the opening handshake, and delegates to the ``handler``. The handler receives a :class:`ServerConnection` instance, which you can use to send and receive messages. Once the handler completes, either normally or with an exception, the server performs the closing handshake and closes the connection. :class:`WebSocketServer` mirrors the API of :class:`~socketserver.BaseServer`. Treat it as a context manager to ensure that it will be closed and call the :meth:`~WebSocketServer.serve_forever` method to serve requests:: def handler(websocket): ... with websockets.sync.server.serve(handler, ...) as server: server.serve_forever() Args: handler: Connection handler. It receives the WebSocket connection, which is a :class:`ServerConnection`, in argument. host: Network interfaces the server binds to. See :func:`~socket.create_server` for details. port: TCP port the server listens on. See :func:`~socket.create_server` for details. sock: Preexisting TCP socket. ``sock`` replaces ``host`` and ``port``. You may call :func:`socket.create_server` to create a suitable TCP socket. ssl_context: Configuration for enabling TLS on the connection. origins: Acceptable values of the ``Origin`` header, for defending against Cross-Site WebSocket Hijacking attacks. Include :obj:`None` in the list if the lack of an origin is acceptable. extensions: List of supported extensions, in order in which they should be negotiated and run. subprotocols: List of supported subprotocols, in order of decreasing preference. select_subprotocol: Callback for selecting a subprotocol among those supported by the client and the server. It receives a :class:`ServerConnection` (not a :class:`~websockets.server.ServerProtocol`!) instance and a list of subprotocols offered by the client. Other than the first argument, it has the same behavior as the :meth:`ServerProtocol.select_subprotocol ` method. process_request: Intercept the request during the opening handshake. Return an HTTP response to force the response or :obj:`None` to continue normally. When you force an HTTP 101 Continue response, the handshake is successful. Else, the connection is aborted. process_response: Intercept the response during the opening handshake. Return an HTTP response to force the response or :obj:`None` to continue normally. When you force an HTTP 101 Continue response, the handshake is successful. Else, the connection is aborted. server_header: Value of the ``Server`` response header. It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to :obj:`None` removes the header. compression: The "permessage-deflate" extension is enabled by default. Set ``compression`` to :obj:`None` to disable it. See the :doc:`compression guide <../../topics/compression>` for details. open_timeout: Timeout for opening connections in seconds. :obj:`None` disables the timeout. close_timeout: Timeout for closing connections in seconds. :obj:`None` disables the timeout. max_size: Maximum size of incoming messages in bytes. :obj:`None` disables the limit. logger: Logger for this server. It defaults to ``logging.getLogger("websockets.server")``. See the :doc:`logging guide <../../topics/logging>` for details. create_connection: Factory for the :class:`ServerConnection` managing the connection. Set it to a wrapper or a subclass to customize connection handling. Nrzunsupported compression: zmissing path argument)familyz(path and sock arguments are incompatibleTF) server_sidedo_handshake_on_connectr"rr$)rorpr'c s.t}zs |tjtjd dk rX||t|tj sFt | |dd} dk r|dddd fdd }t |t d}dk st ||d  |Wntk r|YdSXz Wn2tk r |jjd dd tjYn XdS) NTrzSequence[Subprotocol]zOptional[Subprotocol])r&rr'cs$dk s t|jkst|Sry)rOr&)r&r) connectionrr/r0protocol_select_subprotocols z@serve..conn_handler..protocol_select_subprotocol)rrrrrJrrBr zconnection handler failedr8)r setsockoptr% IPPROTO_TCP TCP_NODELAY settimeoutr7rNssl SSLSocketrO do_handshakerrrLrArtrBrCr INTERNAL_ERROR)rorpdeadlinerr&r!rrr[rBrrrr4r5rr6rrr)rr0 conn_handlersV    zserve..conn_handler) r r ValueErrorr TypeErrorr% create_serverAF_UNIX wrap_socketr)r[rrrorrrrrrrr4r5r6rrr!rrBrrr/rr0r s0{  2Tz!Callable[[ServerConnection], Any]r)r[rkwargsr'cKst|f|dd|S)a Create a WebSocket server listening on a Unix socket. This function is identical to :func:`serve`, except the ``host`` and ``port`` arguments are replaced by ``path``. It's only available on Unix. It's useful for deploying a server behind a reverse proxy such as nginx. Args: handler: Connection handler. It receives the WebSocket connection, which is a :class:`ServerConnection`, in argument. path: File system path to the Unix socket. T)rr)r)r[rrr/r/r0rs)NN)N)0 __future__rrEr]rargr%rr_r(typesrtypingrrrrrZwebsockets.framesr Zextensions.baser Zextensions.permessage_deflater rIr rZhttp11rrr&rrrserverrrrrrrutilsr__all__rrrrr/r/r/r0sb           Z:y