示例#1
0
    def test_wb_connect_after_timeout(self):
        """
        Test an odd error scenario. If the zookeeper client succeeds in
        connecting after a timeout, the connection should be closed, as
        the connect deferred has already fired.
        """
        mock_client = self.mocker.patch(self.client)
        mock_client.close()

        def close_state():
            # Ensure the client state variable is correct after the close call.
            self.client.connected = False

        self.mocker.call(close_state)
        self.mocker.replay()

        task = DelayedCall(1, lambda: 1, None, None, None, None)
        task.called = True

        d = Deferred()
        d.errback(ConnectionTimeoutException())

        self.client._cb_connected(
            task, d, None, zookeeper.CONNECTED_STATE, "/")

        self.failUnlessFailure(d, ConnectionTimeoutException)
        return d
示例#2
0
    def _cb_timeout(response: Response, request: Request, timeout: float,
                    timeout_cl: DelayedCall) -> Response:
        if timeout_cl.active():
            timeout_cl.cancel()
            return response

        url = urldefrag(request.url)[0]
        raise TimeoutError(
            f"Getting {url} took longer than {timeout} seconds.")
示例#3
0
 def test_repr(self):
     """
     The string representation of a L{DelayedCall} instance, as returned by
     {repr}, is identical to that returned by L{str}.
     """
     dc = DelayedCall(13, nothing, (6, ), {"A": 9}, None, None, lambda: 1.6)
     self.assertEqual(str(dc), repr(dc))
示例#4
0
    def _getDelayedCallAt(self, time):
        """
        Get a L{DelayedCall} instance at a given C{time}.

        @param time: The absolute time at which the returned L{DelayedCall}
            will be scheduled.
        """
        def noop(call):
            pass
        return DelayedCall(time, lambda: None, (), {}, noop, noop, None)
示例#5
0
    def test_wb_reconnect_after_timeout_and_close(self):
        """
        Another odd error scenario, if a client instance has has
        connect and closed methods invoked in succession multiple
        times, and a previous callback connect timeouts, the callback
        of a previous connect can be invoked by a subsequent connect,
        with a CONNECTING_STATE. Verify this does not attempt to
        invoke the connect deferred again.
        """
        d = Deferred()
        d.callback(True)

        task = DelayedCall(1, lambda: 1, None, None, None, None)
        task.called = True

        self.assertEqual(
            self.client._cb_connected(
                task, d, None, zookeeper.CONNECTING_STATE, ""),
            None)
示例#6
0
 def test_str(self):
     """
     The string representation of a L{DelayedCall} instance, as returned by
     L{str}, includes the unsigned id of the instance, as well as its state,
     the function to be called, and the function arguments.
     """
     dc = DelayedCall(12, nothing, (3, ), {"A": 5}, None, None, lambda: 1.5)
     expected = ("<DelayedCall 0x{:x} [10.5s] called=0 cancelled=0 "
                 "nothing(3, A=5)>".format(id(dc)))
     self.assertEqual(str(dc), expected)
示例#7
0
 def test_str(self):
     """
     The string representation of a L{DelayedCall} instance, as returned by
     L{str}, includes the unsigned id of the instance, as well as its state,
     the function to be called, and the function arguments.
     """
     dc = DelayedCall(12, nothing, (3, ), {"A": 5}, None, None, lambda: 1.5)
     expectedRegexp = (
         "<DelayedCall 0x{:x} \\[10.5s\\] called=0 cancelled=0 "
         "nothing\\(3, A=5\\)\n\n"
         "traceback at creation:".format(id(dc)))
     self.assertRegex(str(dc), expectedRegexp)
示例#8
0
 def test_cleanPendingCancelsCalls(self):
     """
     During pending-call cleanup, the janitor cancels pending timed calls.
     """
     def func():
         return "Lulz"
     cancelled = []
     delayedCall = DelayedCall(300, func, (), {},
                               cancelled.append, lambda x: None)
     reactor = StubReactor([delayedCall])
     jan = _Janitor(None, None, reactor=reactor)
     jan._cleanPending()
     self.assertEquals(cancelled, [delayedCall])
示例#9
0
    def _on_timeout_error(self, failure, request, timeout: float = None,
                          timer: DelayedCall = None):
        failure.trap(defer.CancelledError)
        msg = {}
        if timer is not None:
            msg['remaining'] = timer.time - timer.seconds()

        if timer is not None and timer.cancelled:
            ex = CancelledError(msg)
            return self._write_error(request, 520, ex)

        msg['timeout'] = timeout
        ex = GlobalTimeoutError(msg)
        return self._write_error(request, 504, ex)
示例#10
0
 def test_cleanPendingReturnsDelayedCallStrings(self):
     """
     The Janitor produces string representations of delayed calls from the
     delayed call cleanup method. It gets the string representations
     *before* cancelling the calls; this is important because cancelling the
     call removes critical debugging information from the string
     representation.
     """
     delayedCall = DelayedCall(
         300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0
     )
     delayedCallString = str(delayedCall)
     reactor = StubReactor([delayedCall])
     jan = _Janitor(None, None, reactor=reactor)
     strings = jan._cleanPending()
     self.assertEqual(strings, [delayedCallString])
示例#11
0
 def test_postClassCleanupWithPendingCallErrors(self):
     """
     The post-class cleanup method call C{addError} on the result with a
     L{DirtyReactorAggregateError} Failure if there are pending calls.
     """
     delayedCall = DelayedCall(
         300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0
     )
     delayedCallString = str(delayedCall)
     reactor = StubReactor([delayedCall], [])
     test = object()
     reporter = StubErrorReporter()
     jan = _Janitor(test, reporter, reactor=reactor)
     jan.postClassCleanup()
     self.assertEqual(len(reporter.errors), 1)
     self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString])
示例#12
0
    def callLater(self, seconds, f, *args, **kwargs):
        def run():
            dc.called = True
            self._delayedCalls.remove(dc)
            f(*args, **kwargs)
        handle = self._asyncioEventloop.call_later(seconds, run)
        dchandle = _DCHandle(handle)
        def cancel(dc):
            self._delayedCalls.remove(dc)
            dchandle.cancel()
        def reset(dc):
            dchandle.handle = self._asyncioEventloop.call_at(dc.time, run)

        dc = DelayedCall(self.seconds() + seconds, run, (), {},
                         cancel, reset, seconds=self.seconds)
        self._delayedCalls.add(dc)
        return dc
示例#13
0
文件: task.py 项目: giadram/twisted
 def callLater(self, delay: float, callable: Callable[..., object],
               *args: object, **kw: object) -> IDelayedCall:
     """
     See L{twisted.internet.interfaces.IReactorTime.callLater}.
     """
     dc = DelayedCall(
         self.seconds() + delay,
         callable,
         args,
         kw,
         self.calls.remove,
         lambda c: None,
         self.seconds,
     )
     self.calls.append(dc)
     self._sortCalls()
     return dc
示例#14
0
 def test_str(self):
     """
     The string representation of a L{DelayedCall} instance, as returned by
     C{str}, includes the unsigned id of the instance, as well as its state,
     the function to be called, and the function arguments.
     """
     def nothing():
         pass
     dc = DelayedCall(12, nothing, (3, ), {"A": 5}, None, None, lambda: 1.5)
     ids = {dc: 200}
     def fakeID(obj):
         try:
             return ids[obj]
         except (TypeError, KeyError):
             return id(obj)
     self.addCleanup(setIDFunction, setIDFunction(fakeID))
     self.assertEqual(
         str(dc),
         "<DelayedCall 0xc8 [10.5s] called=0 cancelled=0 nothing(3, A=5)>")
示例#15
0
    def callLater(self, seconds, f, *args, **kwargs):
        def run(*a, **k):
            dc.called = True
            self._delayedCalls.remove(dc)
            result = f(*a, **k)
            return result

        handle = self.spawn_later(seconds, run, *args, **kwargs)
        dchandle = _DCHandle(handle)

        def cancel(dc):
            self._delayedCalls.remove(dc)
            dchandle.cancel()

        def reset(dc):
            dchandle.handle = self.spawn_later(dc.time - self.seconds(), run)

        dc = DelayedCall(self.seconds() + seconds,
                         run, (), {},
                         cancel,
                         reset,
                         seconds=self.seconds)
        self._delayedCalls.add(dc)
        return dc
示例#16
0
文件: twistedr.py 项目: esh/invaders
 def cancel(self):
     if self.cancelled or self.called:
         self.cancelled = True
         return
     return TwistedDelayedCall.cancel(self)
示例#17
0
 def cancel(self):
     if self.cancelled or self.called:
         self.cancelled = True
         return
     return TwistedDelayedCall.cancel(self)