Beispiel #1
0
        def fail(delay, error_class, *args, **kwargs):

            def raise_error(_param):
                raise error_class(*args, **kwargs)

            d = defer.Deferred()
            d.addCallback(raise_error)
            time.call_later(delay, d.callback, None)
            return d
Beispiel #2
0
def delay_raise(error_factory, delay):

    def raise_error(_param):
        raise error_factory()

    d = defer.Deferred()
    d.addCallback(raise_error)
    time.call_later(delay, d.callback, None)
    return d
Beispiel #3
0
    def finish(self):
        self.debug('Finishing %s', self.log_ident)
        assert not self.finished, "Request already finished"
        self.finished = True

        # If not all the body has been read, we must disconnect
        if self._body_length and not self.received:
            self.persistent = False

        self._write_headers()

        if self.activated:
            time.call_later(0, self._cleanup)
Beispiel #4
0
    def _schedule_retry(self, key):
        if key in self._retries:
            return

        delay = self._next_retry_delay(key)
        callid = time.call_later(delay, self._do_retry, key)
        self._retries[key] = callid
        self._delays[key] = delay
Beispiel #5
0
    def activate(self):
        self.debug('Activating %s', self.log_ident)
        assert not self.activated, "request already active"
        self.activated = True

        self._activate_transport()

        if self.finished:
            # The request was finished before being activated
            time.call_later(0, self._cleanup)
            return

        try:
            self.onActivate()
        except HTTPError, e:
            self.warning("Error during activation: %s",
                         error.get_exception_message(e))
            self._make_error(e.status_code, e.status_message)
Beispiel #6
0
    def __init__(self, timeout, deferred, message="Timeout expired"):
        self._master = deferred
        self._control = Deferred()

        self._call_later = time.call_later(
            timeout, self._control.errback, TimeoutError(message))

        DeferredList.__init__(self,
                              [self._master, self._control],
                              fireOnOneCallback=True,
                              fireOnOneErrback=True,
                              consumeErrors=True)
        self.addCallbacks(self._callback, self._errback)
Beispiel #7
0
 def set_timeout(self, expiration_time, state, callback, *args, **kwargs):
     self.cancel_timeout()
     eta = max([0, time.left(expiration_time)])
     self._timeout_call = time.call_later(
         eta, self._timeout_target, state, callback, args, kwargs)
Beispiel #8
0
 def activate(self):
     response = "%s %s %s\r\n\r\n" % (self.protocol.name, self.status_code,
                                      self.status_message)
     self.channel.transport.write(response)
     time.call_later(0, self._cleanup)
Beispiel #9
0
 def connectionMade(self):
     self._server.connection_made(self)
     self._timeout = time.call_later(self._disconnect_timeout,
                                     self._verify_authorized)
Beispiel #10
0
 def call_later(self, _time, _method, *args, **kwargs):
     id = str(uuid.uuid1())
     call = time.call_later(_time, _method, *args, **kwargs)
     self._delayed_calls[id] = call
     return id
Beispiel #11
0
 def call_next(self, call, *args, **kwargs):
     time.call_later(0, fiber.maybe_fiber, call, *args, **kwargs)
Beispiel #12
0
 def reset_timeout(self, name):
     assert name in self._timeouts, "Unknown timeout " + name
     self.cancel_timeout(name)
     duration = self._timeouts[name][0]
     dc = time.call_later(duration, self._on_timeout, name)
     self._callids[name] = dc