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/selectreactor.py (6215B)

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

"""
Select reactor
"""

from __future__ import division, absolute_import

from time import sleep
import sys, select, socket
from errno import EINTR, EBADF

from zope.interface import implementer

from twisted.internet.interfaces import IReactorFDSet
from twisted.internet import posixbase
from twisted.python import log
from twisted.python.runtime import platformType

def win32select(r, w, e, timeout=None):
    """Win32 select wrapper."""
    if not (r or w):
        # windows select() exits immediately when no sockets
        if timeout is None:
            timeout = 0.01
        else:
            timeout = min(timeout, 0.001)
        sleep(timeout)
        return [], [], []
    # windows doesn't process 'signals' inside select(), so we set a max
    # time or ctrl-c will never be recognized
    if timeout is None or timeout > 0.5:
        timeout = 0.5
    r, w, e = select.select(r, w, w, timeout)
    return r, w + e, []

if platformType == "win32":
    _select = win32select
else:
    _select = select.select

try:
    from twisted.internet.win32eventreactor import _ThreadedWin32EventsMixin
except ImportError:
    _extraBase = object
else:
    _extraBase = _ThreadedWin32EventsMixin

@implementer(IReactorFDSet)
class SelectReactor(posixbase.PosixReactorBase, _extraBase):
    """
    A select() based reactor - runs on all POSIX platforms and on Win32.

@ivar _reads: A set containing L{FileDescriptor} instances which will be
        checked for read events.

@ivar _writes: A set containing L{FileDescriptor} instances which will be
        checked for writability.
    """

def __init__(self):
        """
        Initialize file descriptor tracking dictionaries and the base class.
        """
        self._reads = set()
        self._writes = set()
        posixbase.PosixReactorBase.__init__(self)

def _preenDescriptors(self):
        log.msg("Malformed file descriptor found.  Preening lists.")
        readers = list(self._reads)
        writers = list(self._writes)
        self._reads.clear()
        self._writes.clear()
        for selSet, selList in ((self._reads, readers),
                                 (self._writes, writers)):
            for selectable in selList:
                try:
                    select.select([selectable], [selectable], [selectable], 0)
                except Exception as e:
                    log.msg("bad descriptor %s" % selectable)
                    self._disconnectSelectable(selectable, e, False)
                else:
                    selSet.add(selectable)

def doSelect(self, timeout):
        """
        Run one iteration of the I/O monitor loop.

This will run all selectables who had input or output readiness
        waiting for them.
        """
        try:
            r, w, ignored = _select(self._reads,
                                    self._writes,
                                    [], timeout)
        except ValueError:
            # Possibly a file descriptor has gone negative?
            self._preenDescriptors()
            return
        except TypeError:
            # Something *totally* invalid (object w/o fileno, non-integral
            # result) was passed
            log.err()
            self._preenDescriptors()
            return
        except (select.error, socket.error, IOError) as se:
            # select(2) encountered an error, perhaps while calling the fileno()
            # method of a socket.  (Python 2.6 socket.error is an IOError
            # subclass, but on Python 2.5 and earlier it is not.)
            if se.args[0] in (0, 2):
                # windows does this if it got an empty list
                if (not self._reads) and (not self._writes):
                    return
                else:
                    raise
            elif se.args[0] == EINTR:
                return
            elif se.args[0] == EBADF:
                self._preenDescriptors()
                return
            else:
                # OK, I really don't know what's going on.  Blow up.
                raise

_drdw = self._doReadOrWrite
        _logrun = log.callWithLogger
        for selectables, method, fdset in ((r, "doRead", self._reads),
                                           (w,"doWrite", self._writes)):
            for selectable in selectables:
                # if this was disconnected in another thread, kill it.
                # ^^^^ --- what the !@#*?  serious!  -exarkun
                if selectable not in fdset:
                    continue
                # This for pausing input when we're not ready for more.
                _logrun(selectable, _drdw, selectable, method)

doIteration = doSelect

def _doReadOrWrite(self, selectable, method):
        try:
            why = getattr(selectable, method)()
        except:
            why = sys.exc_info()[1]
            log.err()
        if why:
            self._disconnectSelectable(selectable, why, method=="doRead")

def addReader(self, reader):
        """
        Add a FileDescriptor for notification of data available to read.
        """
        self._reads.add(reader)

def addWriter(self, writer):
        """
        Add a FileDescriptor for notification of data available to write.
        """
        self._writes.add(writer)

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

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

def removeAll(self):
        return self._removeAll(self._reads, self._writes)

def getReaders(self):
        return list(self._reads)

def getWriters(self):
        return list(self._writes)

def install():
    """Configure the twisted mainloop to be run using the select() reactor.
    """
    reactor = SelectReactor()
    from twisted.internet.main import installReactor
    installReactor(reactor)

__all__ = ['install']

cmd: