Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/internet/epollreactor.py

Index: third_party/twisted_8_1/twisted/internet/epollreactor.py
diff --git a/third_party/twisted_8_1/twisted/internet/epollreactor.py b/third_party/twisted_8_1/twisted/internet/epollreactor.py
deleted file mode 100644
index 051bf7190da40e74ca9793069a6c38a39d3aa522..0000000000000000000000000000000000000000
--- a/third_party/twisted_8_1/twisted/internet/epollreactor.py
+++ /dev/null
@@ -1,256 +0,0 @@
-# Copyright (c) 2001-2007 Twisted Matrix Laboratories.
-# See LICENSE for details.
-
-"""
-An epoll() 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 epollreactor
-    epollreactor.install()
-
-Maintainer: U{Jp Calderone <mailto:exarkun@twistedmatrix.com>}
-"""
-
-import sys, errno
-
-from zope.interface import implements
-
-from twisted.internet.interfaces import IReactorFDSet
-
-from twisted.python import _epoll
-from twisted.python import log
-from twisted.internet import posixbase, error
-from twisted.internet.main import CONNECTION_LOST
-
-
-_POLL_DISCONNECTED = (_epoll.HUP | _epoll.ERR)
-
-class EPollReactor(posixbase.PosixReactorBase):
-    """
-    A reactor that uses epoll(4).
-
-    @ivar _poller: A L{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{FileDescriptors} 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}.
-    """
-    implements(IReactorFDSet)
-
-    def __init__(self):
-        """
-        Initialize epoll object, file descriptor tracking dictionaries, and the
-        base class.
-        """
-        # Create the poller we're going to use.  The 1024 here is just a hint
-        # to the kernel, it is not a hard maximum.
-        self._poller = _epoll.epoll(1024)
-        self._reads = {}
-        self._writes = {}
-        self._selectables = {}
-        posixbase.PosixReactorBase.__init__(self)
-
-
-    def _add(self, xer, primary, other, selectables, event, antievent):
-        """
-        Private method for adding a descriptor from the event loop.
-
-        It takes care of adding it if  new or modifying it if already added
-        for another state (read -> read/write for example).
-        """
-        fd = xer.fileno()
-        if fd not in primary:
-            cmd = _epoll.CTL_ADD
-            flags = event
-            if fd in other:
-                flags |= antievent
-                cmd = _epoll.CTL_MOD
-            primary[fd] = 1
-            selectables[fd] = xer
-            # epoll_ctl can raise all kinds of IOErrors, and every one
-            # indicates a bug either in the reactor or application-code.
-            # Let them all through so someone sees a traceback and fixes
-            # something.  We'll do the same thing for every other call to
-            # this method in this file.
-            self._poller._control(cmd, fd, flags)
-
-
-    def addReader(self, reader):
-        """
-        Add a FileDescriptor for notification of data available to read.
-        """
-        self._add(reader, self._reads, self._writes, self._selectables, _epoll.IN, _epoll.OUT)
-
-
-    def addWriter(self, writer):
-        """
-        Add a FileDescriptor for notification of data available to write.
-        """
-        self._add(writer, self._writes, self._reads, self._selectables, _epoll.OUT, _epoll.IN)
-
-
-    def _remove(self, xer, primary, other, selectables, event, antievent):
-        """
-        Private method for removing a descriptor from the event loop.
-
-        It does the inverse job of _add, and also add a check in case of the fd
-        has gone away.
-        """
-        fd = xer.fileno()
-        if fd == -1:
-            for fd, fdes in selectables.items():
-                if xer is fdes:
-                    break
-            else:
-                return
-        if fd in primary:
-            cmd = _epoll.CTL_DEL
-            flags = event
-            if fd in other:
-                flags = antievent
-                cmd = _epoll.CTL_MOD
-            else:
-                del selectables[fd]
-            del primary[fd]
-            # See comment above _control call in _add.
-            self._poller._control(cmd, fd, flags)
-
-
-    def removeReader(self, reader):
-        """
-        Remove a Selectable for notification of data available to read.
-        """
-        self._remove(reader, self._reads, self._writes, self._selectables, _epoll.IN, _epoll.OUT)
-
-
-    def removeWriter(self, writer):
-        """
-        Remove a Selectable for notification of data available to write.
-        """
-        self._remove(writer, self._writes, self._reads, self._selectables, _epoll.OUT, _epoll.IN)
-
-    def removeAll(self):
-        """
-        Remove all selectables, and return a list of them.
-        """
-        if self.waker is not None:
-            fd = self.waker.fileno()
-            if fd in self._reads:
-                del self._reads[fd]
-                del self._selectables[fd]
-        result = self._selectables.values()
-        fds = self._selectables.keys()
-        self._reads.clear()
-        self._writes.clear()
-        self._selectables.clear()
-        for fd in fds:
-            try:
-                # Actually, we'll ignore all errors from this, since it's
-                # just last-chance cleanup.
-                self._poller._control(_epoll.CTL_DEL, fd, 0)
-            except IOError:
-                pass
-        if self.waker is not None:
-            fd = self.waker.fileno()
-            self._reads[fd] = 1
-            self._selectables[fd] = self.waker
-        return result
-
-
-    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 doPoll(self, timeout):
-        """
-        Poll the poller for new events.
-        """
-        if timeout is None:
-            timeout = 1
-        timeout = int(timeout * 1000) # convert seconds to milliseconds
-
-        try:
-            # Limit the number of events to the number of io objects we're
-            # currently tracking (because that's maybe a good heuristic) and
-            # the amount of time we block to the value specified by our
-            # caller.
-            l = self._poller.wait(len(self._selectables), timeout)
-        except IOError, err:
-            if err.errno == errno.EINTR:
-                return
-            # See epoll_wait(2) for documentation on the other conditions
-            # under which this can fail.  They can only be due to a serious
-            # programming error on our part, so let's just announce them
-            # loudly.
-            raise
-
-        _drdw = self._doReadOrWrite
-        for fd, event in l:
-            try:
-                selectable = self._selectables[fd]
-            except KeyError:
-                pass
-            else:
-                log.callWithLogger(selectable, _drdw, selectable, fd, event)
-
-    doIteration = doPoll
-
-    def _doReadOrWrite(self, selectable, fd, event):
-        """
-        fd is available for read or write, make the work and raise errors
-        if necessary.
-        """
-        why = None
-        inRead = False
-        if event & _POLL_DISCONNECTED and not (event & _epoll.IN):
-            why = CONNECTION_LOST
-        else:
-            try:
-                if event & _epoll.IN:
-                    why = selectable.doRead()
-                    inRead = True
-                if not why and event & _epoll.OUT:
-                    why = selectable.doWrite()
-                    inRead = False
-                if selectable.fileno() != fd:
-                    why = error.ConnectionFdescWentAway(
-                          'Filedescriptor went away')
-                    inRead = False
-            except:
-                log.err()
-                why = sys.exc_info()[1]
-        if why:
-            self._disconnectSelectable(selectable, why, inRead)
-
-def install():
-    """
-    Install the epoll() reactor.
-    """
-    p = EPollReactor()
-    from twisted.internet.main import installReactor
-    installReactor(p)
-
-
-__all__ = ["EPollReactor", "install"]
-