REDROOM

Navigation

Breadcrumbs

/ / lib / python3 / dist-packages / twisted / internet

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 10.87 KB

//lib/python3/dist-packages/twisted/internet/asyncioreactor.py

Text Base64

# -*- test-case-name: twisted.test.test_internet -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
asyncio-based reactor implementation.
"""

import errno
import sys
from asyncio import AbstractEventLoop, get_event_loop
from typing import Dict, Optional, Type

from zope.interface import implementer

from twisted.internet.abstract import FileDescriptor
from twisted.internet.interfaces import IReactorFDSet
from twisted.internet.posixbase import (
    _NO_FILEDESC,
    PosixReactorBase,
    _ContinuousPolling,
)
from twisted.logger import Logger
from twisted.python.log import callWithLogger

@implementer(IReactorFDSet)
class AsyncioSelectorReactor(PosixReactorBase):
    """
    Reactor running on top of L{asyncio.SelectorEventLoop}.

On POSIX platforms, the default event loop is
    L{asyncio.SelectorEventLoop}.
    On Windows, the default event loop on Python 3.7 and older
    is C{asyncio.WindowsSelectorEventLoop}, but on Python 3.8 and newer
    the default event loop is C{asyncio.WindowsProactorEventLoop} which
    is incompatible with L{AsyncioSelectorReactor}.
    Applications that use L{AsyncioSelectorReactor} on Windows
    with Python 3.8+ must call
    C{asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())}
    before instantiating and running L{AsyncioSelectorReactor}.
    """

_asyncClosed = False
    _log = Logger()

def __init__(self, eventloop: Optional[AbstractEventLoop] = None):
        if eventloop is None:
            _eventloop: AbstractEventLoop = get_event_loop()
        else:
            _eventloop = eventloop

# On Python 3.8+, asyncio.get_event_loop() on
        # Windows was changed to return a ProactorEventLoop
        # unless the loop policy has been changed.
        if sys.platform == "win32":
            from asyncio import ProactorEventLoop

if isinstance(_eventloop, ProactorEventLoop):
                raise TypeError(
                    f"ProactorEventLoop is not supported, got: {_eventloop}"
                )

self._asyncioEventloop: AbstractEventLoop = _eventloop
        self._writers: Dict[Type[FileDescriptor], int] = {}
        self._readers: Dict[Type[FileDescriptor], int] = {}
        self._continuousPolling = _ContinuousPolling(self)

self._scheduledAt = None
        self._timerHandle = None

super().__init__()

def _unregisterFDInAsyncio(self, fd):
        """
        Compensate for a bug in asyncio where it will not unregister a FD that
        it cannot handle in the epoll loop. It touches internal asyncio code.

A description of the bug by markrwilliams:

The C{add_writer} method of asyncio event loops isn't atomic because
        all the Selector classes in the selector module internally record a
        file object before passing it to the platform's selector
        implementation. If the platform's selector decides the file object
        isn't acceptable, the resulting exception doesn't cause the Selector to
        un-track the file object.

The failing/hanging stdio test goes through the following sequence of
        events (roughly):

* The first C{connection.write(intToByte(value))} call hits the asyncio
        reactor's C{addWriter} method.

* C{addWriter} calls the asyncio loop's C{add_writer} method, which
        happens to live on C{_BaseSelectorEventLoop}.

* The asyncio loop's C{add_writer} method checks if the file object has
        been registered before via the selector's C{get_key} method.

* It hasn't, so the KeyError block runs and calls the selector's
        register method

* Code examples that follow use EpollSelector, but the code flow holds
        true for any other selector implementation. The selector's register
        method first calls through to the next register method in the MRO

* That next method is always C{_BaseSelectorImpl.register} which
        creates a C{SelectorKey} instance for the file object, stores it under
        the file object's file descriptor, and then returns it.

* Control returns to the concrete selector implementation, which asks
        the operating system to track the file descriptor using the right API.

* The operating system refuses! An exception is raised that, in this
        case, the asyncio reactor handles by creating a C{_ContinuousPolling}
        object to watch the file descriptor.

* The second C{connection.write(intToByte(value))} call hits the
        asyncio reactor's C{addWriter} method, which hits the C{add_writer}
        method. But the loop's selector's get_key method now returns a
        C{SelectorKey}! Now the asyncio reactor's C{addWriter} method thinks
        the asyncio loop will watch the file descriptor, even though it won't.
        """
        try:
            self._asyncioEventloop._selector.unregister(fd)
        except BaseException:
            pass

def _readOrWrite(self, selectable, read):
        method = selectable.doRead if read else selectable.doWrite

if selectable.fileno() == -1:
            self._disconnectSelectable(selectable, _NO_FILEDESC, read)
            return

try:
            why = method()
        except Exception as e:
            why = e
            self._log.failure(None)
        if why:
            self._disconnectSelectable(selectable, why, read)

def addReader(self, reader):
        if reader in self._readers.keys() or reader in self._continuousPolling._readers:
            return

fd = reader.fileno()
        try:
            self._asyncioEventloop.add_reader(
                fd, callWithLogger, reader, self._readOrWrite, reader, True
            )
            self._readers[reader] = fd
        except OSError as e:
            self._unregisterFDInAsyncio(fd)
            if e.errno == errno.EPERM:
                # epoll(7) doesn't support certain file descriptors,
                # e.g. filesystem files, so for those we just poll
                # continuously:
                self._continuousPolling.addReader(reader)
            else:
                raise

def addWriter(self, writer):
        if writer in self._writers.keys() or writer in self._continuousPolling._writers:
            return

fd = writer.fileno()
        try:
            self._asyncioEventloop.add_writer(
                fd, callWithLogger, writer, self._readOrWrite, writer, False
            )
            self._writers[writer] = fd
        except PermissionError:
            self._unregisterFDInAsyncio(fd)
            # epoll(7) doesn't support certain file descriptors,
            # e.g. filesystem files, so for those we just poll
            # continuously:
            self._continuousPolling.addWriter(writer)
        except BrokenPipeError:
            # The kqueuereactor will raise this if there is a broken pipe
            self._unregisterFDInAsyncio(fd)
        except BaseException:
            self._unregisterFDInAsyncio(fd)
            raise

def removeReader(self, reader):
        # First, see if they're trying to remove a reader that we don't have.
        if not (
            reader in self._readers.keys() or self._continuousPolling.isReading(reader)
        ):
            # We don't have it, so just return OK.
            return

# If it was a cont. polling reader, check there first.
        if self._continuousPolling.isReading(reader):
            self._continuousPolling.removeReader(reader)
            return

fd = reader.fileno()
        if fd == -1:
            # If the FD is -1, we want to know what its original FD was, to
            # remove it.
            fd = self._readers.pop(reader)
        else:
            self._readers.pop(reader)

self._asyncioEventloop.remove_reader(fd)

def removeWriter(self, writer):
        # First, see if they're trying to remove a writer that we don't have.
        if not (
            writer in self._writers.keys() or self._continuousPolling.isWriting(writer)
        ):
            # We don't have it, so just return OK.
            return

# If it was a cont. polling writer, check there first.
        if self._continuousPolling.isWriting(writer):
            self._continuousPolling.removeWriter(writer)
            return

fd = writer.fileno()

if fd == -1:
            # If the FD is -1, we want to know what its original FD was, to
            # remove it.
            fd = self._writers.pop(writer)
        else:
            self._writers.pop(writer)

self._asyncioEventloop.remove_writer(fd)

def removeAll(self):
        return (
            self._removeAll(self._readers.keys(), self._writers.keys())
            + self._continuousPolling.removeAll()
        )

def getReaders(self):
        return list(self._readers.keys()) + self._continuousPolling.getReaders()

def getWriters(self):
        return list(self._writers.keys()) + self._continuousPolling.getWriters()

def iterate(self, timeout):
        self._asyncioEventloop.call_later(timeout + 0.01, self._asyncioEventloop.stop)
        self._asyncioEventloop.run_forever()

def run(self, installSignalHandlers=True):
        self.startRunning(installSignalHandlers=installSignalHandlers)
        self._asyncioEventloop.run_forever()
        if self._justStopped:
            self._justStopped = False

def stop(self):
        super().stop()
        # This will cause runUntilCurrent which in its turn
        # will call fireSystemEvent("shutdown")
        self.callLater(0, lambda: None)

def crash(self):
        super().crash()
        self._asyncioEventloop.stop()

def _onTimer(self):
        self._scheduledAt = None
        self.runUntilCurrent()
        self._reschedule()

def _reschedule(self):
        timeout = self.timeout()
        if timeout is not None:
            abs_time = self._asyncioEventloop.time() + timeout
            self._scheduledAt = abs_time
            if self._timerHandle is not None:
                self._timerHandle.cancel()
            self._timerHandle = self._asyncioEventloop.call_at(abs_time, self._onTimer)

def _moveCallLaterSooner(self, tple):
        PosixReactorBase._moveCallLaterSooner(self, tple)
        self._reschedule()

def callLater(self, seconds, f, *args, **kwargs):
        dc = PosixReactorBase.callLater(self, seconds, f, *args, **kwargs)
        abs_time = self._asyncioEventloop.time() + self.timeout()
        if self._scheduledAt is None or abs_time < self._scheduledAt:
            self._reschedule()
        return dc

def callFromThread(self, f, *args, **kwargs):
        g = lambda: self.callLater(0, f, *args, **kwargs)
        self._asyncioEventloop.call_soon_threadsafe(g)

def install(eventloop=None):
    """
    Install an asyncio-based reactor.

@param eventloop: The asyncio eventloop to wrap. If default, the global one
        is selected.
    """
    reactor = AsyncioSelectorReactor(eventloop)
    from twisted.internet.main import installReactor

installReactor(reactor)

Exit & Reset Text mode: syntax highlighting auto-detects file type.

Directory Contents

Dirs: 3 × Files: 57

Sort:

Enable drag-to-move

Name	Size	Perms	Modified	Actions
iocpreactor DIR	-	drwxr-xr-x	2026-01-08 12:56:22	Edit Download recursive recursive
test DIR	-	drwxr-xr-x	2026-01-08 12:56:22	Edit Download recursive recursive
__pycache__ DIR	-	drwxr-xr-x	2026-01-08 12:56:23	Edit Download recursive recursive
abstract.py	18.84 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
address.py	5.14 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
asyncioreactor.py	10.87 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
base.py	46.82 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
cfreactor.py	22.75 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
default.py	1.85 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
defer.py	95.88 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
endpoints.py	76.59 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
epollreactor.py	8.73 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
error.py	13.14 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
fdesc.py	3.16 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
gireactor.py	3.42 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
glib2reactor.py	1.24 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
gtk2reactor.py	3.55 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
gtk3reactor.py	512 B	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
inotify.py	14.06 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
interfaces.py	95.89 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
kqreactor.py	10.56 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
main.py	1006 B	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
pollreactor.py	5.83 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
posixbase.py	20.88 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
process.py	43.14 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
protocol.py	26.93 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
pyuisupport.py	853 B	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
reactor.py	1.77 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
selectreactor.py	5.96 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
serialport.py	2.20 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
ssl.py	8.47 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
stdio.py	1006 B	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
task.py	32.90 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
tcp.py	53.97 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
testing.py	29.12 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
threads.py	4.13 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
tksupport.py	1.92 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
udp.py	18.18 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
unix.py	21.98 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
utils.py	8.48 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
win32eventreactor.py	14.84 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
wxreactor.py	5.15 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
wxsupport.py	1.27 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_baseprocess.py	1.96 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_deprecate.py	743 B	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_dumbwin32proc.py	12.29 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_glibbase.py	12.61 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_idna.py	1.39 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_newtls.py	8.97 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_pollingfile.py	8.49 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_posixserialport.py	1.99 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_posixstdio.py	4.88 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_producer_helpers.py	3.82 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_resolver.py	9.46 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_signals.py	14.06 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_sslverify.py	70.68 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_threadedselect.py	11.31 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_win32serialport.py	4.69 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
_win32stdio.py	3.04 KB	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive
__init__.py	521 B	lrw-r--r--	2024-08-27 10:30:39	Edit Download recursive recursive