o /hH@szddlmZddlZddlZddlZddlZddlZddlZddlZddl 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*gdZ+Gddde(Z,GdddZ-  dGddddddddddeddddddddHd@dAZ. dIdJdEdFZ/dS)K) annotationsN) TracebackType)AnyCallableOptionalSequenceType) CloseCode)ServerExtensionFactory) enable_server_permessage_deflate)validate_subprotocols) USER_AGENT)RequestResponse) CONNECTINGOPENEvent)ServerProtocol) LoggerLikeOrigin Subprotocol) Connection)Deadline)serve unix_serveServerConnectionWebSocketServercsXeZdZdZdddfd d ZddedfdddZd fdd Zd!fdd 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_timeoutsocket socket.socketprotocolrr!Optional[float]returnNonecs$|t|_tj|||ddS)Nr ) threadingr request_rcvdsuper__init__)selfr"r$r! __class__O/var/www/html/govbot/env/lib/python3.10/site-packages/websockets/sync/server.pyr+7s  zServerConnection.__init__Nprocess_requestCOptional[Callable[[ServerConnection, Request], Optional[Response]]]process_responseMOptional[Callable[[ServerConnection, Request, Response], Optional[Response]]] server_header Optional[str]timeoutc Cs|j|s||jtd|jdur%||jtd|jt dd|_ |durez |||j|_ Wn(t yd}z||j _ |jjddd|j tjjd|_ WYd}~nd}~ww|j durr|j |j|_ |dur|||j jd <|durz |||j|j }Wn(t y}z||j _ |jjddd|j tjjd|_ WYd}~n d}~ww|dur||_ |j |j Wdn1swY|j jtur|j|j||j|j j dur|j j dS) z1 Perform the opening handshake. ztimed out during handshakeNz"connection closed during handshake)expected_statezopening handshake failedTexc_infozLFailed to open a WebSocket connection. See server log for more information. Server)r)wait close_socketrecv_events_threadjoin TimeoutErrorrequestConnectionError send_contextrresponse Exceptionr$ handshake_excloggererrorrejecthttp HTTPStatusINTERNAL_SERVER_ERRORacceptheaders send_responsestaterr!)r,r1r3r5r7excrDr/r/r0 handshakeFsb        *  zServerConnection.handshakeeventrcs<|jdurt|ts J||_|jdSt|dS)z. Process one incoming event. N)rA isinstancerr)setr* process_event)r,rSr-r/r0rVs zServerConnection.process_eventcs(z tW|jdS|jw)zI Read incoming data from the socket and process events. N)r* recv_eventsr)rUr,r-r/r0rWs zServerConnection.recv_events)r"r#r$rr!r%r&r') r1r2r3r4r5r6r7r%r&r')rSrr&r'r&r') __name__ __module__ __qualname____doc__r+rrRrVrW __classcell__r/r/r-r0rs Qrc@sPeZdZdZ ddd d Zd d dZd ddZd!ddZd"ddZd#ddZ 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"r#handler$Callable[[socket.socket, Any], None]rGOptional[LoggerLike]cCsF||_||_|durtd}||_tjdkr!t\|_ |_ dSdS)Nzwebsockets.serverwin32) r"r_logging getLoggerrGsysplatformospipeshutdown_watchershutdown_notifier)r,r"r_rGr/r/r0r+s  zWebSocketServer.__init__r&r'cCst}||jtjtjdkr||jtj |z |j \}}Wn t y1YdSwt j |j ||fd}|q)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() rbT)targetargsN) selectorsDefaultSelectorregisterr" EVENT_READrerfriselectrMOSErrorr(Threadr_start)r,pollersockaddrthreadr/r/r0 serve_forevers   zWebSocketServer.serve_forevercCs*|jtjdkrt|jddSdS)z@ See :meth:`socketserver.BaseServer.shutdown`. rbxN)r"closererfrgwriterjrXr/r/r0shutdowns  zWebSocketServer.shutdownintcCs |jS)z> See :meth:`socketserver.BaseServer.fileno`. )r"filenorXr/r/r0rs zWebSocketServer.filenocCs|SNr/rXr/r/r0 __enter__szWebSocketServer.__enter__exc_typeOptional[Type[BaseException]] exc_valueOptional[BaseException] tracebackOptional[TracebackType]cCs |dSr)r})r,rrrr/r/r0__exit__s zWebSocketServer.__exit__r)r"r#r_r`rGrarY)r&r~)r&r)rrrrrrr&r') rZr[r\r]r+ryr}rrrr/r/r/r0rs   rFdeflateri)rv ssl_contextunixpathorigins extensions subprotocolsselect_subprotocolr1r3r5 compression open_timeoutr!max_sizerGcreate_connectionr_"Callable[[ServerConnection], None]hostr6port Optional[int]rvOptional[socket.socket]rOptional[ssl.SSLContext]rboolrr$Optional[Sequence[Optional[Origin]]]r*Optional[Sequence[ServerExtensionFactory]]rOptional[Sequence[Subprotocol]]rTOptional[Callable[[ServerConnection, Sequence[Subprotocol]], Optional[Subprotocol]]]r1r2r3r4r5rrr%r!rrGrar Optional[Type[ServerConnection]]r&cs durt |dkrtn |durtd|dur"t|durAr9|dur0tdtj|tjd}nt||f}n|durItd durU j|ddd }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_connectrvr#rwrr&r'c s"t}zYs|tjtjd dur,||t|tj s#J| |dd} dur:d fdd }t |t d }dusKJ||d  |Wntyk|YdSwzWnty|jjd dd tjYdSwdS)NTr$rrSequence[Subprotocol]r&Optional[Subprotocol]cs$dusJ|jus J|Sr)r$)r$r) connectionrr/r0protocol_select_subprotocols  z@serve..conn_handler..protocol_select_subprotocol)rrrrrPrrGr zconnection handler failedr9)r$rrrr&r)r setsockoptr" IPPROTO_TCP TCP_NODELAY settimeoutr7rTssl SSLSocket do_handshakerrrRrEr{rGrHr INTERNAL_ERROR)rvrwdeadlinerr$r!rrr_rGrrrr1r3rr5rrr)rr0 conn_handlersZ        zserve..conn_handler)rvr#rwrr&r') r r ValueErrorr TypeErrorr" create_serverAF_UNIX wrap_socketr)r_rrrvrrrrrrrr1r3r5rrr!rrGrrr/rr0r s0{ * Tr!Callable[[ServerConnection], Any]kwargsrcKst|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/r0rsr)NN)*r_rrr6rrrvrrrrrrr6rrrrrrrrr1r2r3r4r5r6rr6rr%r!r%rrrGrarrr&rr)r_rrr6rrr&r)0 __future__rrJrcrgrmr"rrer(typesrtypingrrrrrwebsockets.framesr extensions.baser extensions.permessage_deflater rNr rhttp11rrr$rrrserverrrrrrrutilsr__all__rrrrr/r/r/r0sd          Zy