[FIXED] Client get message from server using asyncio in python

Issue

We are trying to use asyncio to run a straightforward client/server. The server is an echo server with two possible commands sent by the client, "quit" and "timer". The timer command starts a timer that will print a message in the console every second (at the server and client), and the quit command closes the connection.

The actual problem is the following:

When we run the server and the client, and we start the timer, the result of the timer is not sent to the client. It blocks the server and the client. I believe that the problem is on the client's side. However, I was not able to detect it.

Server

import asyncio
import time

HOST = "127.0.0.1"
PORT = 9999

class Timer(object):
    '''Simple timer class that can be started and stopped.'''
    def __init__(self, writer: asyncio.StreamWriter, name = None, interval = 1) -> None:
        self.name = name
        self.interval = interval
        self.writer = writer

    async def _tick(self) -> None:
        while True:
            await asyncio.sleep(self.interval)
            delta = time.time() - self._init_time
            self.writer.write(f"Timer {delta} ticked\n".encode())
            self.writer.drain()
            print("Delta time: ", delta)

    async def start(self) -> None:
        self._init_time = time.time()
        self.task = asyncio.create_task(self._tick())

    async def stop(self) -> None:
        self.task.cancel()
        print("Delta time: ", time.time() - self._init_time)

async def msg_handler(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
    '''Handle the echo protocol.'''
    # timer task that the client can start:
    timer_task = False

    try:
        while True:

            data = await reader.read(1024) # Read 256 bytes from the reader. Size of the message
            msg = data.decode() # Decode the message

            addr, port = writer.get_extra_info("peername") # Get the address of the client
            print(f"Received {msg!r} from {addr}:{port!r}")

            send_message = "Message received: " + msg
            writer.write(send_message.encode()) # Echo the data back to the client
            await writer.drain()  # This will wait until everything is clear to move to the next thing.

            if data == b"quit" and timer_task is True:
                # cancel the timer_task (if any)
                if timer_task:
                    timer_task.cancel()
                    await timer_task
                writer.close()  # Close the connection
                await writer.wait_closed()  # Wait for the connection to close


            elif data == b"quit" and timer_task is False:
                writer.close() # Close the connection
                await writer.wait_closed() # Wait for the connection to close

            elif data == b"start" and timer_task is False:
                print("Starting timer")
                t = Timer(writer)
                timer_task = True
                await t.start()

            elif data == b"stop" and timer_task is True:
                print("Stopping timer")
                await t.stop()
                timer_task = False

    except ConnectionResetError:
        print("Client disconnected")


async def run_server() -> None:
    # Our awaitable callable.
    # This callable is ran when the server recieves some data
    server = await asyncio.start_server(msg_handler, HOST, PORT)

    async with server:
        await server.serve_forever()


if __name__ == "__main__":
    loop = asyncio.new_event_loop() # new_event_loop() is for python 3.10. For older versions, use get_event_loop()
    loop.run_until_complete(run_server())

Client

import asyncio

HOST = '127.0.0.1'
PORT = 9999


async def run_client() -> None:
    # It's a coroutine. It will wait until the connection is established
    reader, writer = await asyncio.open_connection(HOST, PORT)

    while True:

        message = input('Enter a message: ')
        writer.write(message.encode())
        await writer.drain()

        data = await reader.read(1024)
        if not data:
            raise Exception('Socket not communicating with the client')
        print(f"Received {data.decode()!r}")

        if (message == 'quit'):
            writer.write(b"quit")
            writer.close()
            await writer.wait_closed()
            exit(2)
            # break # Don't know if this is necessary


if __name__ == '__main__':
    loop = asyncio.new_event_loop()
    loop.run_until_complete(run_client())

Solution

Finally, I found a possible solution, by separating the thread.

import asyncio
import websockets
import warnings
warnings.filterwarnings("ignore")

async def send_msg(websocket):
    while True:
        imp = await asyncio.get_event_loop().run_in_executor(None, lambda: input("Enter something: "))
        print("MESSAGE: ", imp)
        await websocket.send(imp)
        #return imp

async def recv_msg(websocket):
    while True:
        msg = await websocket.recv()
        print(f":> {msg}")


async def echo_loop():
    uri = f"ws://localhost:8765"
    async with websockets.connect(uri, ssl=None) as websocket:
        while True:
           await asyncio.gather(recv_msg(websocket),send_msg(websocket))


if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(echo_loop())
    asyncio.get_event_loop().run_forever()

Answered By - nunodsousa