Python websockets.serve() Examples

def serve(ws, path):
    cluster_name = await ws.recv()
    cluster_name = cluster_name.decode()
    if cluster_name in CLIENTS:
        print(f"! Cluster[{cluster_name}] attempted reconnection")
        await ws.close(4029, "already connected")
        return
    CLIENTS[cluster_name] = ws
    try:
        await ws.send(b'{"status":"ok"}')
        print(f'$ Cluster[{cluster_name}] connected successfully')
        async for msg in ws:
            print(f'< Cluster[{cluster_name}]: {msg}')
            await dispatch(msg)
    finally:
        CLIENTS.pop(cluster_name)
        print(f'$ Cluster[{cluster_name}] disconnected') 

def start(self):
        self.log.info("Starting Daemon Server")

        def master_close_cb():
            asyncio.ensure_future(self.stop())

        try:
            asyncio.get_running_loop().add_signal_handler(
                signal.SIGINT, master_close_cb
            )
            asyncio.get_running_loop().add_signal_handler(
                signal.SIGTERM, master_close_cb
            )
        except NotImplementedError:
            self.log.info("Not implemented")

        self.websocket_server = await websockets.serve(
            self.safe_handle, "localhost", 55400
        )

        self.log.info("Waiting Daemon WebSocketServer closure")
        print("Daemon server started", flush=True)
        await self.websocket_server.wait_closed()
        self.log.info("Daemon WebSocketServer closed") 

def start_websocket_server(open_port):
    event_loop = asyncio.new_event_loop()

    def run_server():
        async def empty_server(websocket, path):
            data = await websocket.recv()
            await asyncio.sleep(0.02)
            await websocket.send(data)
        server = websockets.serve(empty_server, '127.0.0.1', open_port, loop=event_loop)
        event_loop.run_until_complete(server)
        event_loop.run_forever()

    thd = Thread(target=run_server)
    thd.start()
    try:
        yield
    finally:
        event_loop.call_soon_threadsafe(event_loop.stop) 

def on_connect(self, ws, client_id) -> tuple:
        """create a websocket server object connected to port"""
        
        try:
            port = self.available_ports.pop()
            logger.debug(f"Selected port {port}")
        except:
            logger.warning("No more ports available")
            await ws.send(json.dumps({"result": False}))
            return
        
        try:
            server = await websockets.serve(
                    self.update_handler, device_ip, port)
            logger.info(f"Server created for '{client_id}' on port {port}")
            await ws.send(json.dumps({"result": port}))
            return server, port

        except:
            logger.critical(f"Failed to create server for client '{client_id}'")
            await ws.send(json.dumps({"port":False})) 

def run():
    mp = None
    if config["MAIL"]["START_MAILER"]:
        mp = Popen(['python3', mailer])
    try:
        start_server = websockets.serve(server.server, config["SERVER"]["INTERFACE"], config["SERVER"]["PORT"])
        if config["SERVER"]["RELOAD_ON_CHANGE"]:
            asyncio.async(reloader(mp))
        loop = asyncio.get_event_loop()
        asyncio.async(start_server) 
        if config["IPN"]["START_IPN_SERVER"]:
            asyncio.async(ipn.init(loop)) 
        ext = config["SERVER"].get("EXT", None)
        if ext is not None:
            load_extensions(ext)
        loop.run_forever()

    finally:
        if mp is not None:
            mp.terminate() 

def run_realtime(cls):
        event_loop = asyncio.new_event_loop()
        asyncio.set_event_loop(event_loop)  # required by asyncio_redis

        userlog_settings = util.get_userlog_settings()
        uri = websockets.parse_uri(userlog_settings.websocket_address)
        start_server = websockets.serve(
            realtime.userlog, uri.host, uri.port, loop=event_loop)

        stop_server = asyncio.Future(loop=event_loop)
        cls.stop_realtime_server = lambda: event_loop.call_soon_threadsafe(
            lambda: stop_server.set_result(True))

        realtime_server = event_loop.run_until_complete(start_server)
        event_loop.run_until_complete(stop_server)
        realtime_server.close()
        event_loop.run_until_complete(realtime_server.wait_closed())

        event_loop.close() 

def setUpClass(cls):
        """Initial class level setup."""
        super().setUpClass()

        # Launch the mock server.
        start_server = websockets.serve(websocket_handler, TEST_IP_ADDRESS, int(VALID_PORT))
        cls.server = asyncio.get_event_loop().run_until_complete(start_server) 

def create_socket(self, host: str, port: int):
        self.server_socket = websockets.serve(self.manage_messages, host, port) 

def test_send_command_can_trigger_on_event_prior_to_commmand_containing_event_id(event_loop, chrome_tab):

    msg_id = 4
    frame_id = '3228.1'
    url = 'http://example.com'

    chrome_tab._message_id = msg_id - 1
    f = page.Frame(frame_id, 'test', url, 'test', 'text/html')
    p = page.Page.navigate(url)
    fe = page.FrameNavigatedEvent(f)

    ack = {'id': msg_id, 'result': {'frameId': frame_id}}
    triggers = {
        msg_id: [ack]
    }

    end_msg = copy.copy(p[0])
    end_msg['id'] = msg_id
    q = queue.Queue()
    q.put(end_msg)

    initial_msgs = [fe]

    test_server = init_test_server(triggers, initial_msgs=initial_msgs, expected=q)
    start_server = websockets.serve(test_server, TEST_HOST, TEST_PORT)
    server = await start_server
    await chrome_tab.connect()

    log.info('Sending command and awaiting...')
    result = await chrome_tab.send_command(p, await_on_event_type=page.FrameNavigatedEvent)
    assert result.get('ack') is not None
    assert result.get('event') is not None
    event = result.get('event')
    assert isinstance(event, page.FrameNavigatedEvent)
    assert event.frame.id == f.id
    assert event.frame.url == f.url

    server.close()
    await server.wait_closed() 

def test_send_command_can_trigger_on_event_after_commmand_containing_event_id(event_loop, chrome_tab):
    msg_id = 4
    frame_id = '3228.1'
    url = 'http://example.com'

    chrome_tab._message_id = msg_id - 1
    f = page.Frame(frame_id, 'test', url, 'test', 'text/html')
    p = page.Page.navigate(url)
    fe = page.FrameNavigatedEvent(f)

    ack = {'id': msg_id, 'result': {'frameId': frame_id}}
    triggers = {
        msg_id: [ack, delay_s(1), fe]
    }

    end_msg = copy.copy(p[0])
    end_msg['id'] = msg_id
    q = queue.Queue()
    q.put(end_msg)
    q.put(copy.copy(end_msg))

    test_server = init_test_server(triggers, expected=q)
    start_server = websockets.serve(test_server, TEST_HOST, TEST_PORT)
    server = await start_server
    await chrome_tab.connect()

    log.info('Sending command and awaiting...')
    result = await chrome_tab.send_command(p, await_on_event_type=page.FrameNavigatedEvent)
    assert result.get('ack') is not None
    assert result.get('event') is not None
    event = result.get('event')
    assert isinstance(event, page.FrameNavigatedEvent)
    assert event.frame.id == f.id
    assert event.frame.url == f.url

    server.close()
    await server.wait_closed() 

def start(self):
        self.logger.info('Starting up asyncio loop')
        # I'm cargo culting these asyncio calls from the websockets
        # documentation
        self.loop.run_until_complete(
            ws.serve(self.handle_connection, self.bind, self.port, loop=self.loop))
        self.loop.run_forever() 

def _get_ws_server(self):
        return ws.serve(self.handle_connection, self.bind, self.port, loop=self.loop) 

def main():
    server = await websockets.serve(
        on_connect,
        '0.0.0.0',
        9000,
        subprotocols=['ocpp1.6']
    )

    await server.wait_closed() 

def main():
    server = await websockets.serve(
        on_connect,
        '0.0.0.0',
        9000,
        subprotocols=['ocpp1.6']
    )

    await server.wait_closed() 

def initialize_web():
    ws = websockets.serve(send_message, global_settings.cfg[C_WEB_SETTINGS][P_WEB_IP], int(global_settings.cfg[C_WEB_SETTINGS][P_WEB_SOCK_PORT]),
                          origins=None)
    asyncio.get_event_loop().run_until_complete(ws)
    global_settings.socket_server = Thread(target=asyncio.get_event_loop().run_forever, daemon=True)
    global_settings.socket_server.start()
    rprint("Initialized Socket Server.", origin=L_WEB_INTERFACE)
    log(INFO, "Initialized Socket Server", origin=L_WEB_INTERFACE)

    global_settings.flask_server = Thread(target=start_flask_server, daemon=True)
    global_settings.flask_server.start()
    rprint("Initialized Flask Server.", origin=L_WEB_INTERFACE)
    log(INFO, "Initialized Flask Server", origin=L_WEB_INTERFACE) 

def run_server(self) -> typing.NoReturn:
        async with websockets.serve(
            self._link, host=self.host, port=self.port, process_request=self.handshake
        ) as server:
            logger.info(f"Websocks Server serving on {self.host}:{self.port}")

            def termina(signo, frame):
                logger.info(f"Websocks Server has closed.")
                raise SystemExit(0)

            signal.signal(signal.SIGINT, termina)
            signal.signal(signal.SIGTERM, termina)

            while True:
                await asyncio.sleep(1) 

def _run_server(port):
    """Handles running the websocket thread"""
    asyncio.set_event_loop(asyncio.new_event_loop())
    asyncio.get_event_loop().run_until_complete(
        websockets.serve(ws_handler, 'localhost', port))
    asyncio.get_event_loop().run_forever() 

def setup_tasks(self):
        super().setup_tasks()
        start_server = websockets.serve(echo_time, '127.0.0.1', 65432)
        asyncio.ensure_future(start_server, loop=self.loop) 

def __init__(self, port):
        self.log = logging.getLogger(self.__class__.__name__)
        self.clients = {}  # {client: ((exchange, symbol), callback)}
        self.trades = {}  # {(exchange, symbol)}
        self.server = websockets.serve(self.handle_ws, "localhost", port)
        self.loop = asyncio.get_event_loop() 

def start(self):
        """Start the server."""
        loop = asyncio.get_event_loop()

        bound_ip = '0.0.0.0'
        if self.config['local']:
            bound_ip = '127.0.0.1'

        ao_server_crt = loop.create_server(lambda: AOProtocol(self), bound_ip,
                                           self.config['port'])
        ao_server = loop.run_until_complete(ao_server_crt)

        if self.config['use_websockets']:
            ao_server_ws = websockets.serve(new_websocket_client(self),
                                            bound_ip,
                                            self.config['websocket_port'])
            asyncio.ensure_future(ao_server_ws)

        if self.config['use_masterserver']:
            self.ms_client = MasterServerClient(self)
            asyncio.ensure_future(self.ms_client.connect(), loop=loop)

        if self.config['zalgo_tolerance']:
            self.zalgo_tolerance = self.config['zalgo_tolerance']

        asyncio.ensure_future(self.schedule_unbans())

        database.log_misc('start')
        print('Server started and is listening on port {}'.format(
            self.config['port']))

        try:
            loop.run_forever()
        except KeyboardInterrupt:
            pass

        database.log_misc('stop')

        ao_server.close()
        loop.run_until_complete(ao_server.wait_closed())
        loop.close() 

def __run_loop(self):
        # Set event loop
        if self.background:
            logging.info("Running in background")
            asyncio.set_event_loop(self.loop)

        # Create the loop server
        self.server = self.loop.run_until_complete(websockets.serve(self.handler, self.address, self.port))

        try:
            logging.info("Starting server")
            self.loop.run_forever()

        except KeyboardInterrupt:
            logging.info("Keyboard Interrupt received.")

        finally:
            # Tell any clients that we're closing
            self.server.close()
            self.loop.run_until_complete(asyncio.sleep(0.1))

            # Gather any remaining tasks so we can cancel them
            asyncio.gather(*asyncio.Task.all_tasks()).cancel()
            self.loop.stop()

            logging.info("Cancelling pending tasks...")
            self.loop.run_forever()

            logging.info("Stopping Server...")
            self.loop.close() 

def _start(self):
        self.ev_loop = asyncio.new_event_loop()
        asyncio.set_event_loop(self.ev_loop)
        asyncio.ensure_future(websockets.serve(self._handler, self.host, self.port))
        self.ev_loop.run_forever() 

def _server(self):
        async with websockets.serve(self._handler_md, "127.0.0.1", self.md_port) as self.server_md:
            async with websockets.serve(self._handler_td, "127.0.0.1", self.td_port) as self.server_td:
                self.semaphore.release()
                await self.stop_signal 

def run (self, host='localhost', port=6789):
        self.loop.add_reader (self.fd, self.handleStdin)
        return websockets.serve(self.client, host, port) 

def start(self):
        start_server = websockets.serve(self.__handle, self.host, self.port)
        self.loop.run_until_complete(start_server) 

def launch(self, port, message_max_size):
        event_loop = asyncio.get_event_loop()
        start_server = websockets.serve(
            self._handler, port=port, max_size=message_max_size)
        self._server = event_loop.run_until_complete(start_server)
        self._start_event.set()
        event_loop.run_forever() 

def start(self):
        """Start the server"""
        # Secure behavior: adds a secure layer applying cryptography and authentication
        if not (self.cert_path is None) and not (self.key_path is None):
            ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
            ssl_context.load_cert_chain(self.cert_path, self.key_path)
            start_server = websockets.serve(
                self._handler,
                self.host,
                self.port,
                ssl=ssl_context,
                max_size=None,
                ping_timeout=None,
                close_timeout=None,
            )
        else:
            # Insecure
            start_server = websockets.serve(
                self._handler,
                self.host,
                self.port,
                max_size=None,
                ping_timeout=None,
                close_timeout=None,
            )

        asyncio.get_event_loop().run_until_complete(start_server)
        print("Serving. Press CTRL-C to stop.")
        try:
            asyncio.get_event_loop().run_forever()
        except KeyboardInterrupt:
            logging.info("Websocket server stopped.") 

def _create_server(self, local_addr, sock):
        async def hello(websocket, path):
            proto = WS(app=self._app, loop=self._loop,
                       local_addr=local_addr,
                       peer_addr=websocket.remote_address,
                       websocket=websocket)
            await proto.websocket_pump

        try:
            return self._servers[local_addr]
        except KeyError:
            server = await websockets.serve(hello, local_addr[0], local_addr[1],
                                            subprotocols=['sip'])
            self._servers[local_addr] = server
            return server 

def serve(self):
        return websockets.serve(self.handle_client, self.host, self.port) 

def run_server(gimbal, **kw):
    server = SocketServer(gimbal, **kw)
    loop = asyncio.get_event_loop()
    loop.run_until_complete(server.serve())
    print("Server running at %s" % server.uri())
    loop.run_forever()