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 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 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 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 _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)
def test_no_timeout(self):
d = defer.succeed(1)
timed.timeoutDeferred(d).addCallback(self.assertEqual, 1)
