FM / internet

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

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

Name	Size	Mode	Actions
iocpreactor/	-	0755	rm
test/	-	0755	rm
__pycache__/	-	0755	rm
abstract.py	19274	0644	edit dl rm
address.py	5246	0644	edit dl rm
asyncioreactor.py	10553	0644	edit dl rm
base.py	44260	0644	edit dl rm
cfreactor.py	17501	0644	edit dl rm
default.py	1942	0644	edit dl rm
defer.py	71193	0644	edit dl rm
endpoints.py	77207	0644	edit dl rm
epollreactor.py	8493	0644	edit dl rm
error.py	12645	0644	edit dl rm
fdesc.py	3223	0644	edit dl rm
gireactor.py	6123	0644	edit dl rm
glib2reactor.py	1115	0644	edit dl rm
gtk2reactor.py	3614	0644	edit dl rm
gtk3reactor.py	2252	0644	edit dl rm
inotify.py	14691	0644	edit dl rm
interfaces.py	96515	0644	edit dl rm
kqreactor.py	10292	0644	edit dl rm
main.py	1054	0644	edit dl rm
pollreactor.py	6026	0644	edit dl rm
posixbase.py	26357	0644	edit dl rm
process.py	38896	0644	edit dl rm
protocol.py	27134	0644	edit dl rm
pyuisupport.py	817	0644	edit dl rm
reactor.py	1863	0644	edit dl rm
selectreactor.py	6215	0644	edit dl rm
serialport.py	2317	0644	edit dl rm
ssl.py	8444	0644	edit dl rm
stdio.py	1045	0644	edit dl rm
task.py	31119	0644	edit dl rm
tcp.py	54908	0644	edit dl rm
threads.py	3953	0644	edit dl rm
tksupport.py	2045	0644	edit dl rm
udp.py	18569	0644	edit dl rm
unix.py	21965	0644	edit dl rm
utils.py	7876	0644	edit dl rm
win32eventreactor.py	15193	0644	edit dl rm
wxreactor.py	5263	0644	edit dl rm
wxsupport.py	1363	0644	edit dl rm
_baseprocess.py	1913	0644	edit dl rm
_dumbwin32proc.py	13107	0644	edit dl rm
_glibbase.py	12813	0644	edit dl rm
_idna.py	1397	0644	edit dl rm
_newtls.py	9332	0644	edit dl rm
_pollingfile.py	8982	0644	edit dl rm
_posixserialport.py	1995	0644	edit dl rm
_posixstdio.py	4687	0644	edit dl rm
_producer_helpers.py	3788	0644	edit dl rm
_resolver.py	8530	0644	edit dl rm
_signals.py	2718	0644	edit dl rm
_sslverify.py	71770	0644	edit dl rm
_threadedselect.py	11764	0644	edit dl rm
_win32serialport.py	4744	0644	edit dl rm
_win32stdio.py	3204	0644	edit dl rm
__init__.py	521	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/internet/pollreactor.py (6026B)

# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
A poll() based implementation of the twisted main loop.

To install the event loop (and you should do this before any connections,
listeners or connectors are added)::

from twisted.internet import pollreactor
    pollreactor.install()
"""

from __future__ import division, absolute_import

# System imports
import errno
from select import error as SelectError, poll
from select import POLLIN, POLLOUT, POLLHUP, POLLERR, POLLNVAL

from zope.interface import implementer

# Twisted imports
from twisted.python import log
from twisted.internet import posixbase
from twisted.internet.interfaces import IReactorFDSet

@implementer(IReactorFDSet)
class PollReactor(posixbase.PosixReactorBase, posixbase._PollLikeMixin):
    """
    A reactor that uses poll(2).

@ivar _poller: A L{select.poll} which will be used to check for I/O
        readiness.

@ivar _selectables: A dictionary mapping integer file descriptors to
        instances of L{FileDescriptor} which have been registered with the
        reactor.  All L{FileDescriptor}s which are currently receiving read or
        write readiness notifications will be present as values in this
        dictionary.

@ivar _reads: A dictionary mapping integer file descriptors to arbitrary
        values (this is essentially a set).  Keys in this dictionary will be
        registered with C{_poller} for read readiness notifications which will
        be dispatched to the corresponding L{FileDescriptor} instances in
        C{_selectables}.

@ivar _writes: A dictionary mapping integer file descriptors to arbitrary
        values (this is essentially a set).  Keys in this dictionary will be
        registered with C{_poller} for write readiness notifications which will
        be dispatched to the corresponding L{FileDescriptor} instances in
        C{_selectables}.
    """

_POLL_DISCONNECTED = (POLLHUP | POLLERR | POLLNVAL)
    _POLL_IN = POLLIN
    _POLL_OUT = POLLOUT

def __init__(self):
        """
        Initialize polling object, file descriptor tracking dictionaries, and
        the base class.
        """
        self._poller = poll()
        self._selectables = {}
        self._reads = {}
        self._writes = {}
        posixbase.PosixReactorBase.__init__(self)

def _updateRegistration(self, fd):
        """Register/unregister an fd with the poller."""
        try:
            self._poller.unregister(fd)
        except KeyError:
            pass

mask = 0
        if fd in self._reads:
            mask = mask | POLLIN
        if fd in self._writes:
            mask = mask | POLLOUT
        if mask != 0:
            self._poller.register(fd, mask)
        else:
            if fd in self._selectables:
                del self._selectables[fd]

def _dictRemove(self, selectable, mdict):
        try:
            # the easy way
            fd = selectable.fileno()
            # make sure the fd is actually real.  In some situations we can get
            # -1 here.
            mdict[fd]
        except:
            # the hard way: necessary because fileno() may disappear at any
            # moment, thanks to python's underlying sockets impl
            for fd, fdes in self._selectables.items():
                if selectable is fdes:
                    break
            else:
                # Hmm, maybe not the right course of action?  This method can't
                # fail, because it happens inside error detection...
                return
        if fd in mdict:
            del mdict[fd]
            self._updateRegistration(fd)

def addReader(self, reader):
        """Add a FileDescriptor for notification of data available to read.
        """
        fd = reader.fileno()
        if fd not in self._reads:
            self._selectables[fd] = reader
            self._reads[fd] =  1
            self._updateRegistration(fd)

def addWriter(self, writer):
        """Add a FileDescriptor for notification of data available to write.
        """
        fd = writer.fileno()
        if fd not in self._writes:
            self._selectables[fd] = writer
            self._writes[fd] =  1
            self._updateRegistration(fd)

def removeReader(self, reader):
        """Remove a Selectable for notification of data available to read.
        """
        return self._dictRemove(reader, self._reads)

def removeWriter(self, writer):
        """Remove a Selectable for notification of data available to write.
        """
        return self._dictRemove(writer, self._writes)

def removeAll(self):
        """
        Remove all selectables, and return a list of them.
        """
        return self._removeAll(
            [self._selectables[fd] for fd in self._reads],
            [self._selectables[fd] for fd in self._writes])

def doPoll(self, timeout):
        """Poll the poller for new events."""
        if timeout is not None:
            timeout = int(timeout * 1000) # convert seconds to milliseconds

try:
            l = self._poller.poll(timeout)
        except SelectError as e:
            if e.args[0] == errno.EINTR:
                return
            else:
                raise
        _drdw = self._doReadOrWrite
        for fd, event in l:
            try:
                selectable = self._selectables[fd]
            except KeyError:
                # Handles the infrequent case where one selectable's
                # handler disconnects another.
                continue
            log.callWithLogger(selectable, _drdw, selectable, fd, event)

doIteration = doPoll

def getReaders(self):
        return [self._selectables[fd] for fd in self._reads]

def getWriters(self):
        return [self._selectables[fd] for fd in self._writes]

def install():
    """Install the poll() reactor."""
    p = PollReactor()
    from twisted.internet.main import installReactor
    installReactor(p)

__all__ = ["PollReactor", "install"]

cmd: