Mr.X

# 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()
"""


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

from zope.interface import implementer

from twisted.internet import posixbase
from twisted.internet.interfaces import IReactorFDSet

# Twisted imports
from twisted.python import log


@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 BaseException:
            # 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"]

Name	Type	Size	Permission
__pycache__	Folder		0755
iocpreactor	Folder		0755
test	Folder		0755
__init__.py	File	521 B	0644
_baseprocess.py	File	1.96 KB	0644
_dumbwin32proc.py	File	12.48 KB	0644
_glibbase.py	File	12.41 KB	0644
_idna.py	File	1.39 KB	0644
_newtls.py	File	8.94 KB	0644
_pollingfile.py	File	8.58 KB	0644
_posixserialport.py	File	2.03 KB	0644
_posixstdio.py	File	4.88 KB	0644
_producer_helpers.py	File	3.82 KB	0644
_resolver.py	File	8.27 KB	0644
_signals.py	File	2.61 KB	0644
_sslverify.py	File	71.09 KB	0644
_threadedselect.py	File	11.31 KB	0644
_win32serialport.py	File	4.8 KB	0644
_win32stdio.py	File	3.07 KB	0644
abstract.py	File	18.84 KB	0644
address.py	File	5.12 KB	0644
asyncioreactor.py	File	10.87 KB	0644
base.py	File	46.28 KB	0644
cfreactor.py	File	17.09 KB	0644
default.py	File	1.85 KB	0644
defer.py	File	83.65 KB	0644
endpoints.py	File	75.63 KB	0644
epollreactor.py	File	8.73 KB	0644
error.py	File	13.17 KB	0644
fdesc.py	File	3.16 KB	0644
gireactor.py	File	4.51 KB	0644
glib2reactor.py	File	1.09 KB	0644
gtk2reactor.py	File	3.55 KB	0644
gtk3reactor.py	File	1.49 KB	0644
inotify.py	File	14.06 KB	0644
interfaces.py	File	95.75 KB	0644
kqreactor.py	File	10.56 KB	0644
main.py	File	1006 B	0644
pollreactor.py	File	5.83 KB	0644
posixbase.py	File	26.96 KB	0644
process.py	File	37.61 KB	0644
protocol.py	File	26.75 KB	0644
pyuisupport.py	File	843 B	0644
reactor.py	File	1.77 KB	0644
selectreactor.py	File	5.96 KB	0644
serialport.py	File	2.22 KB	0644
ssl.py	File	8.44 KB	0644
stdio.py	File	1000 B	0644
task.py	File	32.82 KB	0644
tcp.py	File	53.69 KB	0644
testing.py	File	28.55 KB	0644
threads.py	File	3.72 KB	0644
tksupport.py	File	1.92 KB	0644
udp.py	File	18.18 KB	0644
unix.py	File	21.98 KB	0644
utils.py	File	8.48 KB	0644
win32eventreactor.py	File	14.91 KB	0644
wxreactor.py	File	5.19 KB	0644
wxsupport.py	File	1.27 KB	0644

Upload:

Command:

Filemanager

Server Info

System Info

User Info