def stopService(self): if not self.running: return logger.debug("service %r already stopped", self) if self._consume_deferred: logger.debug("wait previous consuming request...") timed.timeoutDeferred(self._consume_deferred, self.cancel_consuming_timeout) try: yield self._consume_deferred except Exception: logger.exception("upps") logger.debug("too quick consume-unconsume - sleep for 0.5 sec") yield timed.sleep(0.5) logger.debug("stop service %s", self) p1 = self._protocol_instance p2 = self.parent.amqp_service.getProtocol() if p1 is p2 and self.consumer_tag: logger.debug("protocol didn't change - cancel consuming") d = p1.cancelConsuming(self.consumer_tag) timed.timeoutDeferred(d, self.cancel_consuming_timeout) try: yield d except Exception: logger.exception("Can't cancel consuming") yield self._cancelActiveCallbacks() yield defer.maybeDeferred(service.Service.stopService, self)
def getProtocol(self, timeout=None): if self._protocol and self._protocol_ready: return defer.succeed(self._protocol) else: d = timed.timeoutDeferred(defer.Deferred(), timeout) self._protocol_deferreds.append(d) return d
def checkServicesHealth(root_srv, timeout=20): logger.debug("check services health, root %r", root_srv) ssx = filter(IHealthChecker.providedBy, _flatSubservices(root_srv)) def on_ok(x, s): return True, _serviceFullName(s), str(x or "") def trap_ni(f, s): f.trap(NotImplementedError) logger.debug("service %s not implement health checking", s) def on_fail(f, s): logger.error("health check failure: %s", f.value) return False, _serviceFullName(s), "exc: %s" % f.value logger.debug("check health for %d services", len(ssx)) return defer.gatherResults( timed.timeoutDeferred( defer.maybeDeferred(IHealthChecker(s).checkHealth) .addCallback(on_ok, s) .addErrback(trap_ni, s) .addErrback(on_fail, s), timeout=timeout, ) for s in ssx ).addCallback( lambda x: list(filter(None, x)), )
def stopService(self): yield defer.maybeDeferred(service.Service.stopService, self) if self._delayedCall and self._delayedCall.active(): self._delayedCall.cancel() activeDeferred = self._activeDeferred if activeDeferred and not activeDeferred.called: try: timed.timeoutDeferred(activeDeferred, self.cancelTimeout, self.clock) activeDeferred.cancel() yield activeDeferred except defer.CancelledError: logger.debug("deffered %r cancelled", activeDeferred) except Exception: logger.exception("cancellation error")
def test_timeout_deferred(self): d = timed.sleep(10000).addCallback(lambda _: 1) try: yield timed.timeoutDeferred(d, timeout=0.1) except timed.TimeoutError: pass else: self.fail("Expected TimeoutError")
def _cancelActiveCallbacks(self): cancelled = [0] ds = list(self._active_callbacks.values()) self._active_callbacks.clear() def ignore_cancelled_error(f): f.trap(defer.CancelledError) cancelled[0] += 1 def log_error(f): logger.error("callback %s failed: %s", self.callback, f) for d in ds: timed.timeoutDeferred(d, self.cancel_message_timeout) d.addErrback(ignore_cancelled_error) d.addErrback(log_error) d.cancel() yield defer.gatherResults(ds) if cancelled[0]: logger.debug("cancelled %d msgs for callback %s", self.callback)
def checkServicesHealth(root_srv, timeout=20): logger.debug("check services health, root %r", root_srv) ssx = filter(IHealthChecker.providedBy, _flatSubservices(root_srv)) def on_ok(x, s): return True, _serviceFullName(s), str(x or "") def trap_ni(f, s): f.trap(NotImplementedError) logger.debug("service %s not implement health checking", s) def on_fail(f, s): logger.error("health check failure: %s", f.value) return False, _serviceFullName(s), "exc: %s" % f.value logger.debug("check health for %d services", len(ssx)) return defer.gatherResults( timed.timeoutDeferred( defer.maybeDeferred(IHealthChecker(s).checkHealth).addCallback( on_ok, s).addErrback(trap_ni, s).addErrback(on_fail, s), timeout=timeout, ) for s in ssx).addCallback(lambda x: list(filter(None, x)), )
def test_no_timeout(self): d = defer.succeed(1) timed.timeoutDeferred(d).addCallback(self.assertEqual, 1)