Bug: Program hangs on Ctrl+C (KeyboardInterrupt) with subprocess error

[rifkymcz]

When using rsloop, the program does not exit cleanly when pressing Ctrl+C (KeyboardInterrupt). Instead, it sometimes hangs and shows a subprocess-related error.

Error:

^Csubprocess pipe_data_received failed
Traceback (most recent call last):
File "/usr/lib/python3.13/asyncio/subprocess.py", line 64, in pipe_data_received
def pipe_data_received(self, fd, data):

KeyboardInterrupt

Steps to reproduce:

1. Install and use rsloop
2. Run an async application (e.g. aiogram bot or any aiohttp-based app)
3. Press Ctrl+C to stop the program

Expected:
Program should stop immediately and exit cleanly

Actual:
Program hangs during shutdown and prints subprocess-related error

Environment:
• Python: 3.12 / 3.13
• rsloop: 0.1.13

Notes:
• This issue was present before the FD leak issue and still occurs in v0.1.13
• Does not happen when using default asyncio loop or uvloops
• Likely related to subprocess handling or event loop shutdown not being fully implemented

[egorsmkv]

can you give reproducible code, plz?

[rifkymcz]

Here is the code I’m using:

"""
This is a echo bot.
It echoes any incoming text messages.
"""

import logging
import rsloop
import asyncio
from aiogram import Bot, Dispatcher, executor, types
from playwright.async_api import async_playwright

API_TOKEN = 'BOT_TOKEN'

loop = rsloop.new_event_loop()
asyncio.set_event_loop(loop)

# Configure logging
logging.basicConfig(level=logging.INFO)

# Initialize bot and dispatcher
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)

class BrowserManager:
    def __init__(self):
        self.playwright = None
        self.browser = None
        self.lock = asyncio.Lock()

    async def start(self):
        async with self.lock:
            if not self.browser:
                self.playwright = await async_playwright().start()

                self.browser = await self.playwright.chromium.launch(
                    headless=True,
                    args=[
                        "--no-sandbox",
                        "--disable-dev-shm-usage",
                        "--disable-gpu",
                    ],
                )

    async def new_context(self, **kwargs):
        return await self.browser.new_context(**kwargs)

    async def close(self):
        if self.browser:
            try:
                await self.browser.close()
            except Exception:
                pass

        if self.playwright:
            try:
                await self.playwright.stop()
            except Exception:
                pass

browser_manager = BrowserManager()

@dp.message_handler(commands=['start', 'help'])
async def send_welcome(message: types.Message):
    """
    This handler will be called when user sends `/start` or `/help` command
    """
    await message.reply("Hi!\nI'm EchoBot!\nPowered by aiogram.")

@dp.message_handler()
async def echo(message: types.Message):
    await message.answer(message.text)

async def on_startup(dp):
    loop = asyncio.get_running_loop()
    logging.info(
        f"Event loop policy: {loop.__class__.__module__}.{loop.__class__.__name__}"
    )
    
    await browser_manager.start()
    logging.info("Startup completed")


async def on_shutdown(dp):
    await browser_manager.close()
    session = await bot.get_session()
    await session.close()
    logging.info("Shutdown completed")


if __name__ == "__main__":
    executor.start_polling(
        dp, loop=loop, on_startup=on_startup, on_shutdown=on_shutdown, skip_updates=True
    )

Environment:

• aiogram 2.25.2
• Python 3.13

The issue occurs when pressing Ctrl+C. The program does not exit cleanly and sometimes hangs with a subprocess-related error.

[egorsmkv]

i think this bug is not in rsloop code because in your traceback there is rsloop's lines (maybe you can add them?).

try this code please:

import asyncio
import logging
import signal

import rsloop
from aiogram import Bot, Dispatcher, types
from playwright.async_api import async_playwright

API_TOKEN = "BOT_TOKEN"

logging.basicConfig(level=logging.INFO)

bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)


class BrowserManager:
    def __init__(self):
        self.playwright = None
        self.browser = None
        self.lock = asyncio.Lock()

    async def start(self):
        async with self.lock:
            if self.browser is None:
                self.playwright = await async_playwright().start()
                self.browser = await self.playwright.chromium.launch(
                    headless=True,
                    args=[
                        "--no-sandbox",
                        "--disable-dev-shm-usage",
                        "--disable-gpu",
                    ],
                )

    async def new_context(self, **kwargs):
        if self.browser is None:
            raise RuntimeError("Browser is not started")
        return await self.browser.new_context(**kwargs)

    async def close(self):
        async with self.lock:
            if self.browser is not None:
                try:
                    await self.browser.close()
                finally:
                    self.browser = None

            if self.playwright is not None:
                try:
                    await self.playwright.stop()
                finally:
                    self.playwright = None


browser_manager = BrowserManager()
shutdown_event = asyncio.Event()


@dp.message_handler(commands=["start", "help"])
async def send_welcome(message: types.Message):
    await message.reply("Hi!\nI'm EchoBot!\nPowered by aiogram.")


@dp.message_handler()
async def echo(message: types.Message):
    await message.answer(message.text)


def request_shutdown() -> None:
    if not shutdown_event.is_set():
        logging.info("Shutdown requested")
        shutdown_event.set()


async def main():
    loop = asyncio.get_running_loop()
    logging.info(
        "Event loop policy: %s.%s",
        loop.__class__.__module__,
        loop.__class__.__name__,
    )

    loop.add_signal_handler(signal.SIGINT, request_shutdown)
    loop.add_signal_handler(signal.SIGTERM, request_shutdown)

    await browser_manager.start()
    logging.info("Startup completed")

    polling_task = asyncio.create_task(dp.start_polling())

    try:
        await shutdown_event.wait()
    finally:
        dp.stop_polling()
        await polling_task
        await browser_manager.close()
        session = await bot.get_session()
        await session.close()
        logging.info("Shutdown completed")


if __name__ == "__main__":
    rsloop.run(main())

[rifkymcz]

Closing this for now.

After further testing, it seems the issue was related to my implementation rather than rsloop itself. The behavior is no longer reproducible after adjusting my code.

It also looks like rsloop may require some adjustments in usage compared to the default asyncio loop or uvloop, especially under certain workloads.

Thanks for the help!