uasyncio.start_server: OSError: [Errno 12] ENOMEM when closing server and running it again

[SirBlackmore]

Hello, I'm trying to create a program that runs an asynchronous web server while also checking the state of two buttons. When I create the server with asyncio.start_server, it works correctly. The issue is that I would like the activation or deactivation of the web server (and the WiFi access point) to depend on the state of a third button (sw_wifi). That is, when the value of sw_wifi is True, it should activate both the access point and the server, and when it is False, it should deactivate both.

The problem is that when I activate and then deactivate it, it works fine. But when I activate it for the second time, it always gives me an error:

Task exception wasn't retrieved
future: <Task> coro= <generator object 'start_server' at 3fff0740>
Traceback (most recent call last):
  File "uasyncio/core.py", line 1, in run_until_complete
  File "uasyncio/stream.py", line 1, in start_server
OSError: [Errno 12] ENOMEM

It seems that the issue is that it's creating another server without closing the first one, which is why it runs out of memory, even though I'm using:

server.close()
server_task.cancel()

Is it possible to close it and free memory so that I can create the server again when I press the sw_wifi button again?

If I add await server.wait_closed() after server.close(), it doesn't work; it's as if it skips that function, and it never sets the variable ap_active to False.

If anyone can help me, I would greatly appreciate it.

Here's my code (I've omitted parts that are unrelated to my problem):

import network
import uasyncio as asyncio
from utime import sleep_ms
from machine import Pin
from web import webpage
import json

sw_wifi = Pin(2, Pin.IN, Pin.PULL_UP)

# AP
ap = None
ap_1stTime = False
ssid = 'Rpi-AP'
password = 'XXXXXXXX'
wifi_active = False
server = None
server_task = None

def init_wifi(ssid, password):
    global ap, ap_1stTime

    ap = network.WLAN(network.AP_IF)
    ap.active(True)
    if ap_1stTime == True:
        ap.config(essid=ssid, password=password)
        ap_1stTime = False

    connection_timeout = 10
    while connection_timeout > 0:
        print('Setting AP. Status: ' + str(ap.status()))
        if ap.active() == True:
            break
        connection_timeout -= 1
        sleep_ms(1000)

    print('Connection successful. Status: ' + str(ap.status()))
    print(ap.ifconfig())
    
    return True

async def handle_client(reader, writer):
    global server, server_task
    
    try:
        print("Client connected")
        
        request_line = await reader.readline()
        print('Request:', request_line)
        
        while await reader.readline() != b"\r\n":
            pass
        
        request = str(request_line, 'utf-8').split()[1]
        print('Request:', request)
        
        # Code to process the request and update variable
        # ----------------
        # ----------------
        # ----------------

        response = webpage()

        writer.write('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
        writer.write(response)
        
        await reader.wait_closed()
        await writer.drain()
        await writer.wait_closed()

    except Exception as e:
        print("Error: " + str(e))
    
def activate_wifi_server():   
    global wifi_active, server, server_task
    
    if not init_wifi(ssid, password):
        return

    server = asyncio.start_server(handle_client, "0.0.0.0", 80)
    server_task = asyncio.create_task(server)
    
    wifi_active = True
    
def deactivate_wifi_server():
    global wifi_active, server, server_task, ap
    wifi_active = False
    
    if server is not None:
        server.close()
        #await server.wait_closed()
        server = None

    if server_task is not None:
        server_task.cancel()
        server_task = None
    
    ap.active(False)
    
    
def check_wifi_pin():
    global wifi_active

    if not sw_wifi.value() == True:
        if wifi_active == False:
            print("AP active")
            activate_wifi_server()
    else:
        if wifi_active == True:
            print("AP inactive")
            deactivate_wifi_server()

async def main():
    while True:

        # -------------------------------------------
        # Functions to check the state of two buttons
        #calcTiempoBoton(0)
        #calcTiempoBoton(1)
        #accionBotones()        
        #tiempoBoton[0] = 0
        #tiempoBoton[1] = 0
        # -------------------------------------------
        
        check_wifi_pin()
        
        await asyncio.sleep_ms(50)

loop = asyncio.get_event_loop()
loop.create_task(main())

try:
    loop.run_forever()
except Exception as e:
    print('Error occured: ', e)
except KeyboardInterrupt:
    print('Program Interrupted by the user')

[bixb922]

What do you need to achieve?

I'd rather not close/release the started server. asyncio.start_server() allocates about 1300 bytes, that is not much unless you are very constrained on RAM. I think it's better to leave the server running instead of trying to free that memory and allocating it again. The possible fragmentation might be worse than the gain.