Example #1
0
class TestEngineInstallPoller(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_custom_poller(self):
        poller = MagicMock()
        self.engine._poller = None
        self.engine._channels = {}
        self.engine._install_poller(poller)
        self.assertTrue(self.engine._poller is poller)

    @unittest.skip("Not yet implemented.")
    def test_custom_poller_with_existing_channels(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    def test_custom_poller_with_existing_channels_and_poller(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    @unittest.skipUnless(hasattr(select, "epoll"), "epoll-specific functionality.")
    def test_defaulting_to_epoll(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    @unittest.skipIf(hasattr(select, "epoll"), "kqueue-specific functionality.")
    @unittest.skipUnless(hasattr(select, "kqueue"), "kqueue-specific functionality.")
    def test_defaulting_to_kqueue(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    @unittest.skipIf(hasattr(select, "epoll"), "select-specific functionality.")
    @unittest.skipIf(hasattr(select, "kqueue"), "select-specific functionality.")
    def test_defaulting_to_select(self):
        self.fail("Not yet implemented.")
Example #2
0
        def doer(*a, **kw):
            if Engine.instance()._running:
                raise RuntimeError(
                    "synchronous calls cannot be made while Pants is already running."
                )

            data = []

            def callback(*a, **kw):
                if kw:
                    if a:
                        a = a + (kw, )
                    else:
                        a = kw

                if isinstance(a, tuple) and len(a) == 1:
                    a = a[0]

                data.append(a)
                Engine.instance().stop()

            kw['callback'] = callback
            func(*a, **kw)
            Engine.instance().start()
            return data[0]
Example #3
0
File: qt.py Project: ixokai/pants
def install(app=None, timeout=0.02):
    """
    Creates a :class:`~PySide.QtCore.QTimer` instance that will be triggered
    continuously to call :func:`Engine.poll() <pants.engine.Engine.poll>`,
    ensuring that Pants remains responsive.

    =========  ========  ============
    Argument   Default   Description
    =========  ========  ============
    app        None      *Optional.* The :class:`~PySide.QtCore.QCoreApplication` to attach to. If no application is provided, it will attempt to find an existing application in memory, or, failing that, create a new application instance.
    timeout    ``0.02``  *Optional.* The maximum time to wait, in seconds, before running :func:`Engine.poll() <pants.engine.Engine.poll>`.
    =========  ========  ============
    """
    global timer
    global _timeout

    Engine.instance()._install_poller(_Qt())

    if app is None:
        app = QCoreApplication.instance()
    if app is None:
        app = QCoreApplication([])

    _timeout = timeout * 1000

    timer = QTimer(app)
    timer.timeout.connect(do_poll)
    timer.start(_timeout)
Example #4
0
 def test_channel_is_modified_on_poller(self):
     engine = Engine()
     channel = MagicMock()
     channel.fileno = "foo"
     channel._events = "bar"
     engine._poller.modify = MagicMock()
     engine.modify_channel(channel)
     engine._poller.modify.assert_called_once_with(channel.fileno, channel._events)
Example #5
0
 def setUp(self):
     self.engine = Engine()
     self.poller = MagicMock()
     self.poller.add = MagicMock()
     self.engine._poller = self.poller
     self.channel = MagicMock()
     self.channel.fileno = "foo"
     self.channel._events = "bar"
Example #6
0
 def test_channel_is_modified_on_poller(self):
     engine = Engine()
     channel = MagicMock()
     channel.fileno = "foo"
     channel._events = "bar"
     engine._poller.modify = MagicMock()
     engine.modify_channel(channel)
     engine._poller.modify.assert_called_once_with(channel.fileno,
                                                   channel._events)
Example #7
0
 def process(self):
     """
     Block until the queued requests finish.
     """
     if not self._requests:
         return
     
     self._processing = True
     from pants.engine import Engine
     Engine.instance().start()
Example #8
0
    def close(self):
        """
        Close the channel.
        """
        if self._socket is None:
            return

        Engine.instance().remove_channel(self)
        self._socket_close()
        self._safely_call(self.on_close)
Example #9
0
File: dns.py Project: Sureiya/pants
            def callback(*a,**kw):
                if kw:
                    if a:
                        a = a + (kw, )
                    else:
                        a = kw

                if isinstance(a, tuple) and len(a) == 1:
                    a = a[0]

                data.append(a)
                Engine.instance().stop()
Example #10
0
            def callback(*a, **kw):
                if kw:
                    if a:
                        a = a + (kw, )
                    else:
                        a = kw

                if isinstance(a, tuple) and len(a) == 1:
                    a = a[0]

                data.append(a)
                Engine.instance().stop()
Example #11
0
class TestEngineRemoveChannel(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()
        self.poller = MagicMock()
        self.poller.remove = MagicMock()
        self.engine._poller = self.poller
        self.channel = MagicMock()
        self.channel.fileno = "foo"
        self.channel._events = "bar"
        self.engine._channels[self.channel.fileno] = self.channel

    def test_channel_is_removed_from_engine(self):
        self.engine.remove_channel(self.channel)
        self.assertFalse(self.channel.fileno in self.engine._channels)

    def test_channel_is_removed_from_poller(self):
        self.engine.remove_channel(self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno, self.channel._events)

    def test_removing_channel_from_poller_raises_IOError(self):
        self.poller.remove = MagicMock(side_effect=IOError())
        self.engine.remove_channel(self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno, self.channel._events)

    def test_removing_channel_from_poller_raises_OSError(self):
        self.poller.remove = MagicMock(side_effect=OSError())
        self.engine.remove_channel(self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno, self.channel._events)

    def test_removing_channel_from_poller_raises_unknown(self):
        self.poller.remove = MagicMock(side_effect=Exception())
        self.assertRaises(Exception, self.engine.remove_channel, self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno, self.channel._events)
Example #12
0
    def _handle_events(self, events):
        """
        Handle events raised on the channel.

        =========  ============
        Argument   Description
        =========  ============
        events     The events in the form of an integer.
        =========  ============
        """
        if self._socket is None:
            log.warning("Received events for closed %s #%d." %
                    (self.__class__.__name__, self.fileno))
            return

        if events & Engine.READ:
            self._wait_for_read_event = False
            self._handle_read_event()
            if self._socket is None:
                return

        if events & Engine.WRITE:
            self._wait_for_write_event = False
            self._handle_write_event()
            if self._socket is None:
                return

        if events & Engine.ERROR:
            err, errstr = self._get_socket_error()
            if err != 0:
                log.error("Error on %s #%d: %s (%d)" %
                        (self.__class__.__name__, self.fileno, errstr, err))
            self.close()
            return

        if events & Engine.HANGUP:
            log.debug("Hang up on %s #%d." %
                    (self.__class__.__name__, self.fileno))
            self.close()
            return

        events = Engine.ERROR | Engine.HANGUP
        if self._wait_for_read_event:
            events |= Engine.READ
        if self._wait_for_write_event:
            events |= Engine.WRITE
        if events != self._events:
            self._events = events
            Engine.instance().modify_channel(self)
Example #13
0
class TestEngineStop(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_when_running(self):
        self.engine._shutdown = False
        self.engine._running = True
        self.engine.stop()
        self.assertTrue(self.engine._shutdown)

    def test_when_not_running(self):
        self.engine._shutdown = False
        self.engine._running = False
        self.engine.stop()
        self.assertFalse(self.engine._shutdown)
Example #14
0
class TestEngineStop(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_when_running(self):
        self.engine._shutdown = False
        self.engine._running = True
        self.engine.stop()
        self.assertTrue(self.engine._shutdown)

    def test_when_not_running(self):
        self.engine._shutdown = False
        self.engine._running = False
        self.engine.stop()
        self.assertFalse(self.engine._shutdown)
Example #15
0
 def _handle_events(self, events):
     """
     Args:
         events: The events raised on the channel.
     """
     if not self.active():
         log.warning("Received events for closed channel %d." % self.fileno)
         return
     
     # Read event.
     if events & Engine.READ:
         if self._listening:
             self._handle_accept_event()
         elif not self._connected:
             self._handle_connect_event()
         else:
             self._handle_read_event()
         if not self.active():
             return
     
     # Write event.
     if events & Engine.WRITE:
         if not self._connected:
             self._handle_connect_event()
         else:
             self._handle_write_event()
         if not self.active():
             return
     
     # Error event.
     if events & Engine.ERROR:
         self.close_immediately()
         return
     
     # Update events.
     events = Engine.ERROR
     if self.readable():
         events |= Engine.READ
     if self.writable():
         events |= Engine.WRITE
     elif self._closing:
         # Done writing, so close.
         self.close_immediately()
         return
     
     if events != self._events:
         self._events = events
         Engine.instance().modify_channel(self)
Example #16
0
def install(app=None, timeout=0.02, engine=None):
    """
    Creates a :class:`~PySide.QtCore.QTimer` instance that will be triggered
    continuously to call :func:`Engine.poll() <pants.engine.Engine.poll>`,
    ensuring that Pants remains responsive.

    =========  ========  ============
    Argument   Default   Description
    =========  ========  ============
    app        None      *Optional.* The :class:`~PySide.QtCore.QCoreApplication` to attach to. If no application is provided, it will attempt to find an existing application in memory, or, failing that, create a new application instance.
    timeout    ``0.02``  *Optional.* The maximum time to wait, in seconds, before running :func:`Engine.poll() <pants.engine.Engine.poll>`.
    engine               *Optional.* The :class:`pants.engine.Engine` instance to use.
    =========  ========  ============
    """
    global timer
    global _timeout
    global _engine

    _engine = engine or Engine.instance()
    _engine._install_poller(_Qt())

    if app is None:
        app = QCoreApplication.instance()
    if app is None:
        app = QCoreApplication([])

    _timeout = timeout * 1000

    timer = QTimer(app)
    timer.timeout.connect(do_poll)
    timer.start(_timeout)
Example #17
0
def start_event(owner, delay, event_func, data=None, arg='', *args, **kwargs):
    """
    Schedule a new event to trigger after ``delay`` seconds. Owners may be any
    Python object, but should be an instance of one of:
    :class:`account.Account`, :class:`char.Char`, :class:`exit.Exit`,
    :class:`mudsock.Mudsock`, :class:`obj.Obj`, or :class:`room.Room`.

    If the owner *is* one of those classes, any currently pending events are
    de-scheduled automatically when the owner is destroyed.

    Event functions should take a minimum of three arguments: the event owner,
    ``data``, and ``arg``. This is for compatibility with NakedMud. You may
    provide additional positional and keyword arguments if you wish.

    Returns a callable that de-schedules the event when called.

    ===========  ============
    Argument     Description
    ===========  ============
    owner        The object that owns the event.
    delay        How long, in seconds, to wait before the event function should be called.
    event_func   The function to be called.
    data         *Optional.* Any Python object to be provided to the event function.
    arg          *Optional.* A string to be provided to the event function.
    ===========  ============
    """
    if not owner in __queued__:
        __queued__[owner] = []

    event = Engine.instance().defer(delay, event_func, owner, data, arg, *args, **kwargs)
    __queued__[owner].append(event)
    return event
Example #18
0
    def setUp(self):
        self.app = Application()
        self.init_app(self.app)

        engine = Engine.instance()
        self.server = HTTPServer(self.app, engine=engine)
        self.server.listen(('127.0.0.1', 4040))
        PantsTestCase.setUp(self, engine)
Example #19
0
 def setUp(self):
     self.engine = Engine.instance()
     self.client = HTTPClient(self.on_response,
                              self.on_headers,
                              self.on_progress,
                              self.on_ssl_error,
                              self.on_error,
                              engine=self.engine)
Example #20
0
 def setUp(self):
     self.engine = Engine()
     self.poller = MagicMock()
     self.poller.add = MagicMock()
     self.engine._poller = self.poller
     self.channel = MagicMock()
     self.channel.fileno = "foo"
     self.channel._events = "bar"
Example #21
0
 def close_immediately(self):
     """
     Close the socket immediately.
     
     Any pending data will not be sent.
     """
     if not self.active():
         return
     
     if self._write_file:
         self._write_file.close()
         self._write_file = None
         self._write_file_left = None
     
     Engine.instance().remove_channel(self)
     self._socket_close()
     self._update_addr()
     self._safely_call(self.handle_close)
Example #22
0
class TestEngineAddChannel(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()
        self.poller = MagicMock()
        self.poller.add = MagicMock()
        self.engine._poller = self.poller
        self.channel = MagicMock()
        self.channel.fileno = "foo"
        self.channel._events = "bar"

    def test_channel_is_added_to_engine(self):
        self.engine.add_channel(self.channel)
        self.assertTrue(self.channel.fileno in self.engine._channels)
        self.assertEqual(self.engine._channels[self.channel.fileno], self.channel)

    def test_channel_is_added_to_poller(self):
        self.engine.add_channel(self.channel)
        self.poller.add.assert_called_once_with(self.channel.fileno, self.channel._events)
Example #23
0
class TestEngineStart(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_when_shutdown_is_true(self):
        self.engine._shutdown = True
        self.engine.start()
        self.assertFalse(self.engine._shutdown)

    def test_when_shutdown_is_false_and_running_is_true(self):
        self.engine._shutdown = False
        self.engine._running = True
        self.engine.start()
        self.assertFalse(self.engine._shutdown)
        self.assertTrue(self.engine._running)

    def test_when_engine_is_stopped_normally(self):
        def poll(engine):
            self.engine.stop()

        self.engine.poll = poll
        self.engine.start()
        self.assertFalse(self.engine._shutdown)
        self.assertFalse(self.engine._running)

    def test_when_poll_raises_systemexit(self):
        def poll(engine):
            raise SystemExit

        self.engine.poll = poll
        self.assertRaises(SystemExit, self.engine.start)
        self.assertFalse(self.engine._shutdown)
        self.assertFalse(self.engine._running)

    def test_when_poll_raises_exception(self):
        def poll(engine):
            raise Exception

        self.engine.poll = poll
        self.engine.start()
        self.assertFalse(self.engine._shutdown)
        self.assertFalse(self.engine._running)
Example #24
0
class TestEngineStart(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_when_shutdown_is_true(self):
        self.engine._shutdown = True
        self.engine.start()
        self.assertFalse(self.engine._shutdown)

    def test_when_shutdown_is_false_and_running_is_true(self):
        self.engine._shutdown = False
        self.engine._running = True
        self.engine.start()
        self.assertFalse(self.engine._shutdown)
        self.assertTrue(self.engine._running)

    def test_when_engine_is_stopped_normally(self):
        def poll(engine):
            self.engine.stop()

        self.engine.poll = poll
        self.engine.start()
        self.assertFalse(self.engine._shutdown)
        self.assertFalse(self.engine._running)

    def test_when_poll_raises_systemexit(self):
        def poll(engine):
            raise SystemExit

        self.engine.poll = poll
        self.assertRaises(SystemExit, self.engine.start)
        self.assertFalse(self.engine._shutdown)
        self.assertFalse(self.engine._running)

    def test_when_poll_raises_exception(self):
        def poll(engine):
            raise Exception

        self.engine.poll = poll
        self.engine.start()
        self.assertFalse(self.engine._shutdown)
        self.assertFalse(self.engine._running)
Example #25
0
File: dns.py Project: Sureiya/pants
    def __init__(self, servers=None, engine=None):
        self.servers = servers or list_dns_servers()
        self.engine = engine or Engine.instance()

        # Internal State
        self._messages = {}
        self._cache = {}
        self._queries = {}
        self._tcp = {}
        self._udp = None
        self._last_id = -1
Example #26
0
    def __init__(self, servers=None, engine=None):
        self.servers = servers or list_dns_servers()
        self.engine = engine or Engine.instance()

        # Internal State
        self._messages = {}
        self._cache = {}
        self._queries = {}
        self._tcp = {}
        self._udp = None
        self._last_id = -1
Example #27
0
class TestEngineAddChannel(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()
        self.poller = MagicMock()
        self.poller.add = MagicMock()
        self.engine._poller = self.poller
        self.channel = MagicMock()
        self.channel.fileno = "foo"
        self.channel._events = "bar"

    def test_channel_is_added_to_engine(self):
        self.engine.add_channel(self.channel)
        self.assertTrue(self.channel.fileno in self.engine._channels)
        self.assertEqual(self.engine._channels[self.channel.fileno],
                         self.channel)

    def test_channel_is_added_to_poller(self):
        self.engine.add_channel(self.channel)
        self.poller.add.assert_called_once_with(self.channel.fileno,
                                                self.channel._events)
Example #28
0
class TestEngineInstallPoller(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_custom_poller(self):
        poller = MagicMock()
        self.engine._poller = None
        self.engine._channels = {}
        self.engine._install_poller(poller)
        self.assertTrue(self.engine._poller is poller)

    @unittest.skip("Not yet implemented.")
    def test_custom_poller_with_existing_channels(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    def test_custom_poller_with_existing_channels_and_poller(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    @unittest.skipUnless(hasattr(select, "epoll"),
                         "epoll-specific functionality.")
    def test_defaulting_to_epoll(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    @unittest.skipIf(hasattr(select, "epoll"),
                     "kqueue-specific functionality.")
    @unittest.skipUnless(hasattr(select, "kqueue"),
                         "kqueue-specific functionality.")
    def test_defaulting_to_kqueue(self):
        self.fail("Not yet implemented.")

    @unittest.skip("Not yet implemented.")
    @unittest.skipIf(hasattr(select, "epoll"),
                     "select-specific functionality.")
    @unittest.skipIf(hasattr(select, "kqueue"),
                     "select-specific functionality.")
    def test_defaulting_to_select(self):
        self.fail("Not yet implemented.")
Example #29
0
 def __init__(self, socket=None):
     """
     Initialises the channel object.
     
     Args:
         socket: A pre-existing socket that this channel should wrap.
             Optional.
     """
     # Socket
     self._socket = socket or self._socket_create()
     self._socket.setblocking(False)
     self.fileno = self._socket.fileno()
     self.remote_addr = (None, None)
     self.local_addr = (None, None)
     
     # Internal state
     self._connected = False
     self._connecting = False
     self._listening = False
     self._closing = False
     
     # Input
     self.read_delimiter = None # String, integer or None.
     self._read_amount = 4096
     self._read_buffer = ""
     
     # Output
     self._write_buffer = ""
     self._secondary_write_buffer = ""
     self._write_file = None
     self._write_file_left = None
     self._write_file_chunk = 65536
     
     # Initialisation
     self._events = Engine.ERROR
     if self.readable():
         self._events |= Engine.READ
     if self.writable():
         self._events |= Engine.WRITE
     Engine.instance().add_channel(self)
Example #30
0
    def __init__(self, **kwargs):
        # Keyword arguments
        sock_family = kwargs.get("family", socket.AF_INET)
        sock_type = kwargs.get("type", socket.SOCK_STREAM)
        sock = kwargs.get("socket", None)
        if sock is None:
            sock = socket.socket(sock_family, sock_type)

        # Socket
        self.fileno = None
        self._socket = None
        self._socket_set(sock)

        # Socket state
        self._wait_for_read_event = True
        self._wait_for_write_event = True

        # I/O attributes
        self._recv_amount = 4096

        # Events
        self._events = Engine.ALL_EVENTS
        Engine.instance().add_channel(self)
Example #31
0
File: qt.py Project: ixokai/pants
def do_poll():
    """
    Here, we run the Pants event loop. Then, we set the timer interval, either
    to the provided timeout, or for how long it would take to reach the
    earliest deferred event.
    """
    engine = Engine.instance()

    engine.poll(0)

    if engine._deferreds:
        timer.setInterval(min(1000 * (engine._deferreds[0].end - engine.time), _timeout))
    else:
        timer.setInterval(_timeout * 1000)
Example #32
0
File: dns.py Project: Sureiya/pants
        def doer(*a, **kw):
            if Engine.instance()._running:
                raise RuntimeError("synchronous calls cannot be made while Pants is already running.")

            data = []

            def callback(*a,**kw):
                if kw:
                    if a:
                        a = a + (kw, )
                    else:
                        a = kw

                if isinstance(a, tuple) and len(a) == 1:
                    a = a[0]

                data.append(a)
                Engine.instance().stop()

            kw['callback'] = callback
            func(*a, **kw)
            Engine.instance().start()
            return data[0]
Example #33
0
def install(app=None, timeout=0.02):
    """
    Sets up the timer. This isn't necessary if you're going to be calling
    poll yourself. (And, if you ARE going to be calling poll yourself: why?)

    Args:
        app: The QApplication to attach to. If None, it will attempt to find
            the app or, failing that, it will create a new QCoreApplication
            instance.
        timeout: The length of time, in seconds, to wait between each call to
            the engine's poll function.
    """
    global timer
    
    Engine.instance()._install_poller(_Qt())
    
    if app is None:
        app = QCoreApplication.instance()
    if app is None:
        app = QCoreApplication([])

    timer = QTimer(app)
    timer.timeout.connect(functools.partial(Engine.instance().poll, 0))
    timer.start(timeout * 1000)
Example #34
0
    def __init__(self, **kwargs):
        self.engine = kwargs.get("engine", Engine.instance())

        # Socket
        self._socket = None
        self._closed = False
        sock = kwargs.get("socket", None)
        if sock:
            self._socket_set(sock)

        # I/O attributes
        self._recv_amount = 4096

        # Internal state
        self._events = Engine.ALL_EVENTS
        if self._socket:
            self.engine.add_channel(self)
Example #35
0
    def __init__(self, **kwargs):
        self.engine = kwargs.get("engine", Engine.instance())

        # Socket
        self._socket = None
        self._closed = False
        sock = kwargs.get("socket", None)
        if sock:
            self._socket_set(sock)

        # I/O attributes
        self._recv_amount = 4096

        # Internal state
        self._events = Engine.ALL_EVENTS
        if self._socket:
            self.engine.add_channel(self)
Example #36
0
class TestEngineRemoveChannel(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()
        self.poller = MagicMock()
        self.poller.remove = MagicMock()
        self.engine._poller = self.poller
        self.channel = MagicMock()
        self.channel.fileno = "foo"
        self.channel._events = "bar"
        self.engine._channels[self.channel.fileno] = self.channel

    def test_channel_is_removed_from_engine(self):
        self.engine.remove_channel(self.channel)
        self.assertFalse(self.channel.fileno in self.engine._channels)

    def test_channel_is_removed_from_poller(self):
        self.engine.remove_channel(self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno,
                                                   self.channel._events)

    def test_removing_channel_from_poller_raises_IOError(self):
        self.poller.remove = MagicMock(side_effect=IOError())
        self.engine.remove_channel(self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno,
                                                   self.channel._events)

    def test_removing_channel_from_poller_raises_OSError(self):
        self.poller.remove = MagicMock(side_effect=OSError())
        self.engine.remove_channel(self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno,
                                                   self.channel._events)

    def test_removing_channel_from_poller_raises_unknown(self):
        self.poller.remove = MagicMock(side_effect=Exception())
        self.assertRaises(Exception, self.engine.remove_channel, self.channel)
        self.poller.remove.assert_called_once_with(self.channel.fileno,
                                                   self.channel._events)
Example #37
0
    def run(self, address=None, ssl_options=None, engine=None):
        """
        This function exists for convenience, and when called creates a
        :class:`~pants.http.HTTPServer` instance with its request
        handler set to this application instance, calls
        :func:`~pants.http.HTTPServer.listen` on that HTTPServer, and
        finally, starts the Pants engine to process requests.

        ============  ============
        Argument      Description
        ============  ============
        address       *Optional.* The address to listen on. If this isn't specified, it will default to ``(INADDR_ANY, 80)``.
        ssl_options   *Optional.* A dict of SSL options for the server. See :class:`pants.contrib.ssl.SSLServer` for more information.
        engine        *Optional.* The :class:`pants.engine.Engine` instance to use.
        ============  ============
        """
        if not engine:
            from pants.engine import Engine
            engine = Engine.instance()

        HTTPServer(self, ssl_options=ssl_options).listen(address)
        engine.start()
Example #38
0
 def test_channel_constructor_no_args(self):
     channel = _Channel()
     self.assertTrue(channel.engine is Engine.instance())
     self.assertTrue(channel._socket is None)
Example #39
0
 def test_channel_constructor_engine_arg(self):
     engine = Engine()
     channel = _Channel(engine=engine)
     self.assertTrue(channel.engine is engine)
Example #40
0
 def test_channel_gets_added_to_engine(self):
     engine = Engine()
     engine.add_channel = MagicMock()
     channel = _Channel(socket=socket.socket(), engine=engine)
     engine.add_channel.assert_called_once_with(channel)
     channel.close()
Example #41
0
 def test_channel_gets_removed_from_engine(self):
     engine = Engine()
     engine.remove_channel = MagicMock()
     channel = _Channel(socket=socket.socket(), engine=engine)
     channel.close()
     engine.remove_channel.assert_called_once_with(channel)
Example #42
0
    "__version__",  # Metadata
    "HAS_IPV6",
    "HAS_UNIX",  # Constants
    "engine",  # Core
    "Stream",
    "Server",  # TCP Networking
    "struct_delimiter",  # Utility Stuff
]


###############################################################################
# Objects
###############################################################################

#: Alias for pants.engine.Engine.instance
engine = Engine.instance()


###############################################################################
# Logging
###############################################################################


class NullHandler(logging.Handler):
    """
    A dummy handler to prevent logging errors if the user does not
    initialise logging.
    """

    def emit(self, record):
        pass
Example #43
0
class TestEnginePoll(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_poll_updates_time(self):
        current_time = self.engine.latest_poll_time
        time.sleep(0.02)
        self.engine.poll(0.02)
        self.assertTrue(self.engine.latest_poll_time > current_time)

    def test_poll_executes_callbacks(self):
        callback = MagicMock()
        callback.function = MagicMock()
        callback.requeue = False
        self.engine._callbacks.append(callback)
        self.engine.poll(0.02)
        callback.function.assert_called_once_with()
        self.assertTrue(len(self.engine._callbacks) == 0)

    def test_callback_exception_doesnt_break_poll(self):
        callback = MagicMock()
        callback.function = MagicMock(side_effect=Exception)
        callback.requeue = False
        self.engine._callbacks.append(callback)
        try:
            self.engine.poll(0.02)
        except Exception:
            self.fail("Exception in callback function was not caught.")

    def test_keyboardinterrupt_during_callback_processing_is_raised(self):
        callback = MagicMock()
        callback.function = MagicMock(side_effect=KeyboardInterrupt)
        callback.requeue = False
        self.engine._callbacks.append(callback)
        self.assertRaises(KeyboardInterrupt, self.engine.poll, 0.02)

    def test_systemexit_during_callback_processing_is_raised(self):
        callback = MagicMock()
        callback.function = MagicMock(side_effect=SystemExit)
        callback.requeue = False
        self.engine._callbacks.append(callback)
        self.assertRaises(SystemExit, self.engine.poll, 0.02)

    def test_poll_requeues_loops(self):
        loop = MagicMock()
        loop.function = MagicMock()
        loop.requeue = True
        self.engine._callbacks.append(loop)
        self.engine.poll(0.02)
        self.assertTrue(loop in self.engine._callbacks)

    def test_poll_executes_deferreds(self):
        defer = MagicMock()
        defer.function = MagicMock()
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        self.engine.poll(0.02)
        defer.function.assert_called_once_with()

    def test_deferred_exception_doesnt_break_poll(self):
        defer = MagicMock()
        defer.function = MagicMock()
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        try:
            self.engine.poll(0.02)
        except Exception:
            self.fail("Exception in deferred was not caught.")

    def test_keyboardinterrupt_during_deferred_processing_is_raised(self):
        defer = MagicMock()
        defer.function = MagicMock(side_effect=KeyboardInterrupt)
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        self.assertRaises(KeyboardInterrupt, self.engine.poll, 0.02)

    def test_systemexit_during_deferred_processing_is_raised(self):
        defer = MagicMock()
        defer.function = MagicMock(side_effect=SystemExit)
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        self.assertRaises(SystemExit, self.engine.poll, 0.02)

    def test_poll_requeues_deferreds(self):
        cycle = MagicMock()
        cycle.function = MagicMock()
        cycle.requeue = True
        cycle.end = self.engine.latest_poll_time - 1
        cycle.delay = 10
        self.engine._deferreds.append(cycle)
        self.engine.poll(0.02)
        self.assertTrue(cycle in self.engine._deferreds)

    def test_poll_returns_if_timer_shuts_down_engine(self):
        # Pretty ugly way of testing this, to be honest.
        self.engine._poller.poll = MagicMock()
        self.engine._channels = {1: None}
        self.engine.callback(self.engine.stop)
        self.engine.poll(0.02)
        self.assertRaises(AssertionError, self.engine._poller.poll.assert_called_once_with)

    def test_poll_sleeps_for_poll_timeout(self):
        before = time.time()
        self.engine.poll(0.225)
        after = time.time()
        # It's never exactly the timeout length, but it gets very close.
        self.assertTrue((after - before) > 0.22)

    def test_poll_sleeps_until_next_deferred(self):
        defer = MagicMock()
        defer.function = MagicMock()
        defer.requeue = False
        self.engine._deferreds.append(defer)
        before = time.time()
        defer.end = before + 0.225
        self.engine.poll(1)
        after = time.time()
        # Again, never going to be exact.
        self.assertTrue((after - before) < 0.25)

    def test_poller_successful(self):
        self.engine._channels = {1: None}
        self.engine._poller.poll = MagicMock()
        self.engine.poll(0.02)
        self.engine._poller.poll.assert_called_once_with(0.02)

    def test_poller_raises_EINTR(self):
        self.engine._channels = {1: None}
        self.engine._poller.poll = MagicMock(side_effect=Exception(errno.EINTR))
        try:
            self.engine.poll(0.02)
        except Exception as err:
            if err.args[0] == errno.EINTR:
                self.fail("EINTR during polling was not caught.")

    def test_poller_raises_unknown(self):
        self.engine._channels = {1: None}
        self.engine._poller.poll = MagicMock(side_effect=Exception)
        self.assertRaises(Exception, self.engine.poll, 0.02)

    def test_poll_processes_events(self):
        channel = MagicMock()
        channel._handle_events = MagicMock()
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(return_value={1:Engine.ALL_EVENTS})
        self.engine.poll(0.02)
        channel._handle_events.assert_called_once_with(Engine.ALL_EVENTS)

    def test_event_processing_error_doesnt_break_poll(self):
        channel = MagicMock()
        channel._handle_events = MagicMock(side_effect=Exception)
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(return_value={1:Engine.ALL_EVENTS})
        try:
            self.engine.poll(0.02)
        except Exception:
            self.fail("Exception raised during event processing was not caught.")

    def test_keyboardinterrupt_during_event_processing_is_raised(self):
        channel = MagicMock()
        channel._handle_events = MagicMock(side_effect=KeyboardInterrupt)
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(return_value={1:Engine.ALL_EVENTS})
        self.assertRaises(KeyboardInterrupt, self.engine.poll, 0.02)

    def test_systemexit_during_event_processing_is_raised(self):
        channel = MagicMock()
        channel._handle_events = MagicMock(side_effect=SystemExit)
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(return_value={1:Engine.ALL_EVENTS})
        self.assertRaises(SystemExit, self.engine.poll, 0.02)
Example #44
0
 def test_cancelling_timer_calls_engine_remove_timer(self):
     engine = Engine()
     engine._remove_timer = MagicMock()
     timer = _Timer(engine, None, None)
     timer.cancel()
     engine._remove_timer.assert_called_once_with(timer)
Example #45
0
class TestTimers(unittest.TestCase):
    def setUp(self):
        self.times_called = []
        self.engine = Engine()

    def timer(self):
        self.times_called.append(self.engine.latest_poll_time)

    def test_callback(self):
        timer = MagicMock()
        self.engine.callback(timer)
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        timer.assert_called_once_with()

    def test_callback_cancel(self):
        timer = MagicMock()
        cancel_callback = self.engine.callback(timer)
        cancel_callback()
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        self.assertRaises(AssertionError, timer.assert_called_with)

    def test_loop(self):
        timer = MagicMock()
        self.engine.loop(timer)
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        timer.assert_has_calls([call() for _ in range(3)])

    def test_loop_cancel(self):
        timer = MagicMock()
        cancel_loop = self.engine.loop(timer)
        self.engine.poll(0.01)
        self.engine.poll(0.01)
        timer.assert_has_calls([call() for _ in range(2)])
        cancel_loop()
        self.engine.poll(0.01)
        timer.assert_has_calls([call() for _ in range(2)])

    def test_defer(self):
        self.engine.poll(0.01)
        timer = MagicMock(side_effect=self.timer)
        expected_time = self.engine.latest_poll_time + 0.01
        self.engine.defer(0.01, timer)
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        timer.assert_called_once_with()
        self.assertLess(abs(expected_time - self.times_called[0]), 0.01)

    def test_defer_cancel(self):
        timer = MagicMock()
        cancel_defer = self.engine.defer(0.01, timer)
        cancel_defer()
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        self.assertRaises(AssertionError, timer.assert_called_with)

    def test_cycle(self):
        self.engine.poll(0.01)
        timer = MagicMock(side_effect=self.timer)
        expected_times = [
            self.engine.latest_poll_time + 0.01,
            self.engine.latest_poll_time + 0.02,
            self.engine.latest_poll_time + 0.03
            ]
        self.engine.cycle(0.01, timer)
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        if sys.platform == "win32": self.engine.poll(0.02)  # See issue #40
        timer.assert_has_calls([call() for _ in range(3)])
        for i in range(3):
            self.assertLess(abs(expected_times[i] - self.times_called[i]), 0.01)

    def test_cycle_cancel(self):
        self.engine.poll(0.01)
        timer = MagicMock(side_effect=self.timer)
        expected_times = [
            self.engine.latest_poll_time + 0.01,
            self.engine.latest_poll_time + 0.02
            ]
        cancel_cycle = self.engine.cycle(0.01, timer)
        self.engine.poll(0.2)
        self.engine.poll(0.2)
        if sys.platform == "win32": self.engine.poll(0.02)  # See issue #40
        timer.assert_has_calls([call() for _ in range(2)])
        cancel_cycle()
        self.engine.poll(0.2)
        timer.assert_has_calls([call() for _ in range(2)])
        for i in range(2):
            self.assertLess(abs(expected_times[i] - self.times_called[i]), 0.01)
Example #46
0
    def test_engine_global_instance(self):
        engine1 = Engine.instance()
        engine2 = Engine.instance()

        self.assertTrue(engine1 is engine2)
Example #47
0
class TestEngineTimers(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_callback_added(self):
        timer = self.engine.callback(MagicMock())
        self.assertTrue(timer in self.engine._callbacks)

    def test_loop_added(self):
        timer = self.engine.loop(MagicMock())
        self.assertTrue(timer in self.engine._callbacks)

    def test_deferred_added(self):
        timer = self.engine.defer(10, MagicMock())
        self.assertTrue(timer in self.engine._deferreds)

    def test_deferred_with_zero_delay(self):
        self.assertRaises(ValueError, self.engine.defer, 0, MagicMock())

    def test_deferred_with_negative_delay(self):
        self.assertRaises(ValueError, self.engine.defer, -1, MagicMock())

    def test_cycle_added(self):
        timer = self.engine.cycle(10, MagicMock())
        self.assertTrue(timer in self.engine._deferreds)

    def test_cycle_with_zero_delay(self):
        self.assertRaises(ValueError, self.engine.cycle, 0, MagicMock())

    def test_cycle_with_negative_delay(self):
        self.assertRaises(ValueError, self.engine.cycle, -1, MagicMock())

    def test_remove_timer_with_no_end(self):
        timer = self.engine.callback(MagicMock())
        self.engine._remove_timer(timer)

    def test_remove_nonexistent_timer_with_no_end(self):
        timer = MagicMock()
        timer.end = None
        self.engine._remove_timer(timer)

    def test_remove_timer_with_end(self):
        timer = self.engine.defer(10, MagicMock())
        self.engine._remove_timer(timer)

    def test_remove_nonexistent_timer_with_end(self):
        timer = MagicMock()
        timer.end = 1
        self.engine._remove_timer(timer)
Example #48
0
 def setUp(self):
     engine = Engine.instance()
     self.server = HTTPServer(self.request_handler, engine=engine)
     self.server.listen(('127.0.0.1', 4040))
     PantsTestCase.setUp(self, engine)
Example #49
0
class TestEnginePoll(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_poll_updates_time(self):
        current_time = self.engine.latest_poll_time
        time.sleep(0.02)
        self.engine.poll(0.02)
        self.assertTrue(self.engine.latest_poll_time > current_time)

    def test_poll_executes_callbacks(self):
        callback = MagicMock()
        callback.function = MagicMock()
        callback.requeue = False
        self.engine._callbacks.append(callback)
        self.engine.poll(0.02)
        callback.function.assert_called_once_with()
        self.assertTrue(len(self.engine._callbacks) == 0)

    def test_callback_exception_doesnt_break_poll(self):
        callback = MagicMock()
        callback.function = MagicMock(side_effect=Exception)
        callback.requeue = False
        self.engine._callbacks.append(callback)
        try:
            self.engine.poll(0.02)
        except Exception:
            self.fail("Exception in callback function was not caught.")

    def test_keyboardinterrupt_during_callback_processing_is_raised(self):
        callback = MagicMock()
        callback.function = MagicMock(side_effect=KeyboardInterrupt)
        callback.requeue = False
        self.engine._callbacks.append(callback)
        self.assertRaises(KeyboardInterrupt, self.engine.poll, 0.02)

    def test_systemexit_during_callback_processing_is_raised(self):
        callback = MagicMock()
        callback.function = MagicMock(side_effect=SystemExit)
        callback.requeue = False
        self.engine._callbacks.append(callback)
        self.assertRaises(SystemExit, self.engine.poll, 0.02)

    def test_poll_requeues_loops(self):
        loop = MagicMock()
        loop.function = MagicMock()
        loop.requeue = True
        self.engine._callbacks.append(loop)
        self.engine.poll(0.02)
        self.assertTrue(loop in self.engine._callbacks)

    def test_poll_executes_deferreds(self):
        defer = MagicMock()
        defer.function = MagicMock()
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        self.engine.poll(0.02)
        defer.function.assert_called_once_with()

    def test_deferred_exception_doesnt_break_poll(self):
        defer = MagicMock()
        defer.function = MagicMock()
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        try:
            self.engine.poll(0.02)
        except Exception:
            self.fail("Exception in deferred was not caught.")

    def test_keyboardinterrupt_during_deferred_processing_is_raised(self):
        defer = MagicMock()
        defer.function = MagicMock(side_effect=KeyboardInterrupt)
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        self.assertRaises(KeyboardInterrupt, self.engine.poll, 0.02)

    def test_systemexit_during_deferred_processing_is_raised(self):
        defer = MagicMock()
        defer.function = MagicMock(side_effect=SystemExit)
        defer.requeue = False
        defer.end = self.engine.latest_poll_time - 1
        self.engine._deferreds.append(defer)
        self.assertRaises(SystemExit, self.engine.poll, 0.02)

    def test_poll_requeues_deferreds(self):
        cycle = MagicMock()
        cycle.function = MagicMock()
        cycle.requeue = True
        cycle.end = self.engine.latest_poll_time - 1
        cycle.delay = 10
        self.engine._deferreds.append(cycle)
        self.engine.poll(0.02)
        self.assertTrue(cycle in self.engine._deferreds)

    def test_poll_returns_if_timer_shuts_down_engine(self):
        # Pretty ugly way of testing this, to be honest.
        self.engine._poller.poll = MagicMock()
        self.engine._channels = {1: None}
        self.engine.callback(self.engine.stop)
        self.engine.poll(0.02)
        self.assertRaises(AssertionError,
                          self.engine._poller.poll.assert_called_once_with)

    def test_poll_sleeps_for_poll_timeout(self):
        before = time.time()
        self.engine.poll(0.225)
        after = time.time()
        # It's never exactly the timeout length, but it gets very close.
        self.assertTrue((after - before) > 0.22)

    def test_poll_sleeps_until_next_deferred(self):
        defer = MagicMock()
        defer.function = MagicMock()
        defer.requeue = False
        self.engine._deferreds.append(defer)
        before = time.time()
        defer.end = before + 0.225
        self.engine.poll(1)
        after = time.time()
        # Again, never going to be exact.
        self.assertTrue((after - before) < 0.25)

    def test_poller_successful(self):
        self.engine._channels = {1: None}
        self.engine._poller.poll = MagicMock()
        self.engine.poll(0.02)
        self.engine._poller.poll.assert_called_once_with(0.02)

    def test_poller_raises_EINTR(self):
        self.engine._channels = {1: None}
        self.engine._poller.poll = MagicMock(
            side_effect=Exception(errno.EINTR))
        try:
            self.engine.poll(0.02)
        except Exception as err:
            if err.args[0] == errno.EINTR:
                self.fail("EINTR during polling was not caught.")

    def test_poller_raises_unknown(self):
        self.engine._channels = {1: None}
        self.engine._poller.poll = MagicMock(side_effect=Exception)
        self.assertRaises(Exception, self.engine.poll, 0.02)

    def test_poll_processes_events(self):
        channel = MagicMock()
        channel._handle_events = MagicMock()
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(
            return_value={1: Engine.ALL_EVENTS})
        self.engine.poll(0.02)
        channel._handle_events.assert_called_once_with(Engine.ALL_EVENTS)

    def test_event_processing_error_doesnt_break_poll(self):
        channel = MagicMock()
        channel._handle_events = MagicMock(side_effect=Exception)
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(
            return_value={1: Engine.ALL_EVENTS})
        try:
            self.engine.poll(0.02)
        except Exception:
            self.fail(
                "Exception raised during event processing was not caught.")

    def test_keyboardinterrupt_during_event_processing_is_raised(self):
        channel = MagicMock()
        channel._handle_events = MagicMock(side_effect=KeyboardInterrupt)
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(
            return_value={1: Engine.ALL_EVENTS})
        self.assertRaises(KeyboardInterrupt, self.engine.poll, 0.02)

    def test_systemexit_during_event_processing_is_raised(self):
        channel = MagicMock()
        channel._handle_events = MagicMock(side_effect=SystemExit)
        self.engine._channels = {1: channel}
        self.engine._poller.poll = MagicMock(
            return_value={1: Engine.ALL_EVENTS})
        self.assertRaises(SystemExit, self.engine.poll, 0.02)
Example #50
0
    def test_engine_local_instances(self):
        engine1 = Engine()
        engine2 = Engine()

        self.assertFalse(engine1 is engine2)
Example #51
0
class TestEngineTimers(unittest.TestCase):
    def setUp(self):
        self.engine = Engine()

    def test_callback_added(self):
        timer = self.engine.callback(MagicMock())
        self.assertTrue(timer in self.engine._callbacks)

    def test_loop_added(self):
        timer = self.engine.loop(MagicMock())
        self.assertTrue(timer in self.engine._callbacks)

    def test_deferred_added(self):
        timer = self.engine.defer(10, MagicMock())
        self.assertTrue(timer in self.engine._deferreds)

    def test_deferred_with_zero_delay(self):
        self.assertRaises(ValueError, self.engine.defer, 0, MagicMock())

    def test_deferred_with_negative_delay(self):
        self.assertRaises(ValueError, self.engine.defer, -1, MagicMock())

    def test_cycle_added(self):
        timer = self.engine.cycle(10, MagicMock())
        self.assertTrue(timer in self.engine._deferreds)

    def test_cycle_with_zero_delay(self):
        self.assertRaises(ValueError, self.engine.cycle, 0, MagicMock())

    def test_cycle_with_negative_delay(self):
        self.assertRaises(ValueError, self.engine.cycle, -1, MagicMock())

    def test_remove_timer_with_no_end(self):
        timer = self.engine.callback(MagicMock())
        self.engine._remove_timer(timer)

    def test_remove_nonexistent_timer_with_no_end(self):
        timer = MagicMock()
        timer.end = None
        self.engine._remove_timer(timer)

    def test_remove_timer_with_end(self):
        timer = self.engine.defer(10, MagicMock())
        self.engine._remove_timer(timer)

    def test_remove_nonexistent_timer_with_end(self):
        timer = MagicMock()
        timer.end = 1
        self.engine._remove_timer(timer)
Example #52
0
 def test_cancelling_timer_calls_engine_remove_timer(self):
     engine = Engine()
     engine._remove_timer = MagicMock()
     timer = _Timer(engine, None, None)
     timer.cancel()
     engine._remove_timer.assert_called_once_with(timer)
Example #53
0
    def test_engine_global_instance(self):
        engine1 = Engine.instance()
        engine2 = Engine.instance()

        self.assertTrue(engine1 is engine2)
Example #54
0
 def setUp(self):
     self.engine = Engine()
Example #55
0
 def setUp(self):
     self.engine = Engine()
Example #56
0
 def setUp(self):
     self.times_called = []
     self.engine = Engine()
Example #57
0
 def setUp(self, engine=None):
     if not engine:
         engine = Engine.instance()
     self._engine = engine
     self._engine_thread = threading.Thread(target=self._engine.start)
     self._engine_thread.start()