• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• vanilla-master
  • .coveragerc
  • examples
    • ticktock.py
    • tcp-basic.py
    • tcp-echo.py
  • xx
    • react.py
    • pipe.py
    • router.py
    • notes.md
    • pipe2.py
    • stream.py
  • LICENSE
  • TODO.md
  • README.rst
  • setup.py
  • CHANGELOG.rst
  • .travis.yml
  • tests
    • integration
      • test_http.py
    • unit
      • test_poll.py
      • test_thread.py
      • test_process.py
      • test_udp.py
      • test_io.py
      • test_message.py
      • test_http.py
      • test_signal.py
      • test_tcp.py
      • test_core.py
  • requirements.txt
  • bench
    • heap.py
  • .gitignore
  • vanilla
    • signal.py
    • udp.py
    • http.py
    • tcp.py
    • poll.py
    • message.py
    • io.py
    • meta.py
    • __init__.py
    • exception.py
    • core.py
    • process.py
    • thread.py
  • docs
    • Makefile
    • api.rst
    • requirements.txt
    • index.rst
    • conf.py
    • _static
  • MANIFEST.in
  • tox.ini

import operator
import select
import errno


POLLIN = 1
POLLOUT = 2
POLLERR = 3


if hasattr(select, 'kqueue'):
    class Poll(object):
        def __init__(self):
            self.q = select.kqueue()

            self.to_ = {
                select.KQ_FILTER_READ: POLLIN,
                select.KQ_FILTER_WRITE: POLLOUT, }

            self.from_ = dict((v, k) for k, v in self.to_.iteritems())

        def register(self, fd, *masks):
            for mask in masks:
                event = select.kevent(
                    fd,
                    filter=self.from_[mask],
                    flags=select.KQ_EV_ADD | select.KQ_EV_CLEAR)
                self.q.control([event], 0)

        def unregister(self, fd, *masks):
            for mask in masks:
                event = select.kevent(
                    fd, filter=self.from_[mask], flags=select.KQ_EV_DELETE)
                self.q.control([event], 0)

        def poll(self, timeout=None):
            if timeout == -1:
                timeout = None
            while True:
                try:
                    events = self.q.control(None, 4, timeout)
                    break
                except OSError, err:
                    if err.errno == errno.EINTR:
                        continue
                    raise

            ret = []
            for e in events:
                if e.filter == select.KQ_FILTER_READ and e.data:
                    ret.append((e.ident, POLLIN))
                if e.filter == select.KQ_FILTER_WRITE:
                    ret.append((e.ident, POLLOUT))
                if e.flags & (select.KQ_EV_EOF | select.KQ_EV_ERROR):
                    ret.append((e.ident, POLLERR))
            return ret


elif hasattr(select, 'epoll'):
    class Poll(object):
        def __init__(self):
            self.q = select.epoll()

            self.to_ = {
                select.EPOLLIN: POLLIN,
                select.EPOLLOUT: POLLOUT, }

            self.from_ = dict((v, k) for k, v in self.to_.iteritems())

        def register(self, fd, *masks):
            masks = [self.from_[x] for x in masks] + [
                select.EPOLLET, select.EPOLLERR, select.EPOLLHUP]
            self.q.register(fd, reduce(operator.or_, masks, 0))

        def unregister(self, fd, *masks):
            self.q.unregister(fd)

        def poll(self, timeout=-1):
            events = self.q.poll(timeout=timeout)
            ret = []
            for fd, event in events:
                for mask in self.to_:
                    if event & mask:
                        ret.append((fd, self.to_[mask]))
                if event & (select.EPOLLERR | select.EPOLLHUP):
                    ret.append((fd, POLLERR))
            return ret

else:
    raise Exception('only epoll or kqueue supported')