How to stop a task started using asyncio.start_server

[krishnak]

I have a task which has a method

async def run(self):
        try:
            return await uasyncio.start_server(self.handle, self.address, self.port)

I create the task from main

async def main():
    myserver = uasyncio.create_task(mytaskclass.run())

asyncio.run(main())

The task is up and running. However I want to shutdown the server based on certain events once it has started.

[dpgeorge]

You can use close and wait_closed methods:

myserver.close()
await myserver.wait_closed()

Or async with, and when the with finishes it'll automatically close the server. That allows you to wait on an event, eg:

async with myserver:
    await event.wait()
# myserver will be closed when you get here

[krishnak]

async def main():
    myserver = await uasyncio.start_server(self.handle, self.address, self.port)
    While True:
         if checksomeconditions():
              myserver.cancel()

This throws AttributeError: 'Server' object has no attribute 'cancel'

[dpgeorge]

See above, you need to use close and wait_closed.

[krishnak]

Thank you it works now, for clarity of anyone else encountering this, the API details are here but it is difficult to comprehend for a new comer

async def main():

myserver = await uasyncio.start_server(self.handle, self.address, self.port)
 While True:
      if checksomeconditions():
           myserver.close()
           await myserver.wait_closed()

Just an additional query, when I am using the above the server stops, the server object is still in memory. If I want to restart the server again is there a way or do I need to call start_server again to create a new object. If I have to recreate by calling start_server - is there a way to check whether the previous instance is running?

[dpgeorge]

You could also write the above like this:

async with myserver:
    while not checksomecondition():
        await asyncio.sleep(0)

If I want to restart the server again is there a way or do I need to call start_server again to create a new object.

You need to call start_server again.

is there a way to check whether the previous instance is running?

When await myserver.wait_closed() returns (or when the async with myserver finishes), the server is no longer running.

Note that all of this is standard Python, so you can refer to the Python docs/tutorials/etc to learn more about how it works.

[krishnak]

I am encountering an issue when using the uasyncio.run(main()) - which is the recommended way, The code that is being called is at the bottom. Only the first print statement gets executed.

However when I use the loop method - the server starts and listens

The same usyncio.run(main()) starts the server if there is another task which is created using a Coro i.e a local async def method as another task. Could you throw some light as in what is it that I am doing incorrectly.

from websocketfile import somemethod as websocket_server

async def main():
    await uasyncio.create_task(websocket_server(add_client))
   
uasyncio.run(main())

"""
loop = uasyncio.get_event_loop()
loop.create_task(websocket_server(add_client))
loop.run_forever()
"""

The following is defined in a separate file websocketfile.py which is being called above

async def somemethod(cb, host="0.0.0.0", port=8080):
    print("Inside 1")
    async def _connect(reader, writer):
        print("Inside  2")
        await connect(reader, writer, cb)

    return await asyncio.start_server(_connect, host, port)

[peterhinch]

asyncio.create_task is a synchronous method. It is therefore incorrect to await it. Further, it returns immediately. Consequently the code

async def main():
    await uasyncio.create_task(websocket_server(add_client))

runs to completion immediately. To give it a chance of working you need something like:

async def main():
    uasyncio.create_task(websocket_server(add_client))
    while True:
        await uasyncio.sleep(1)

Have you looked at the uasyncio tutorial?

[krishnak]

Thank you, I did have a look at the tutorial but the confusion arose because of the start_server method. it was used in an example as I have posted which doesn't involve any sleep, so I misunderstood that start_server is starting the task instead of just creating the task. I have been enlightened to a reasonable extent.

Noo wonder it used to work when I club it along with another task created using task2 = asyncio.create_task(task2method) as I have asyncio.sleep in that main method.. Thank you, all resolved