def stopService(self): try: file_cache_idxs = MetricCache.getAllFileCaches() writeCachedDataPointsWhenStop(file_cache_idxs) except Exception as e: log.err('write error when stopping service: %s' % e) Service.stopService(self)
def stopService(self): """ Stop service by stopping the timerservice and disconnecting cass client """ Service.stopService(self) d = self._service.stopService() return d.addCallback(lambda _: self._client.disconnect())
def stopService(self): """ Stop ThreadWrapper :return: """ self.q.put((None, None, None, None)) Service.stopService(self)
def main(self): """Parse arguments and run the script's main function via ``react``.""" # If e.g. --version is called this may throw a SystemExit, so we # always do this first before any side-effecty code is run: options = self._parse_options(self.sys_module.argv[1:]) if self.logging: log_writer = eliot_logging_service(options.eliot_destination, self._reactor, True) else: log_writer = Service() log_writer.startService() # XXX: We shouldn't be using this private _reactor API. See # https://twistedmatrix.com/trac/ticket/6200 and # https://twistedmatrix.com/trac/ticket/7527 def run_and_log(reactor): d = maybeDeferred(self.script.main, reactor, options) def got_error(failure): if failure.check(UsageError): err(failure.value.args) raise SystemExit(1) elif not failure.check(SystemExit): err(failure) return failure d.addErrback(got_error) return d try: self._react(run_and_log, [], _reactor=self._reactor) finally: log_writer.stopService()
def stopService(self): Service.stopService(self) try: self.app.close() except Exception: logger.error('Error while closing application', exc_info=True) self._close_database()
def stopService(self): """ Stop the service by calling stored function """ Service.stopService(self) if self._stop: return self._stop()
def stopService(self): if self.running: Service.stopService(self) log.info("Stopping master heartbeat service...") return self._hb.stop() else: return defer.succeed(None)
def stopService(self): # We don't need to call port.stopListening(), because the reactor # shutdown sequence will do that for us. Service.stopService(self) logging.info("%s stopped with config %s" % (self.service_name.capitalize(), self.config.get_config_filename()))
def stopService(self): print 'Stop PullRequest service: %s ...' % self.context.name Service.stopService(self) if self.watchLoop: self.watchLoop.stop() if self.schedulerLoop: self.schedulerLoop.stop()
def s2(code, self=self): try: if code != 1: # Cancel stop return if not (self._state == 'stopping' and (self._process + self._workers) == 0): err(RuntimeError('{0} stop error: state-{1} p{2} w{3}'.format( self.name, self._state, self._process, self._workers, ))) self._stopCall = None self._stopDeferred = None # Inside Service.stopService(self) self._state = 'stopped' # Show info msg(self.name, 'stopped', system='-') except: err()
def stopService(self): ntasks = len(self._tasks) for task in self.iterTasks(): task.close() self._tasks = set() Service.stopService(self) logger.debug("stopped scheduler (%i tasks killed)" % ntasks)
def main(self): """Parse arguments and run the script's main function via ``react``.""" # If e.g. --version is called this may throw a SystemExit, so we # always do this first before any side-effecty code is run: options = self._parse_options(self.sys_module.argv[1:]) if self.logging: log_writer = eliot_logging_service( options.eliot_destination, self._reactor, True ) else: log_writer = Service() log_writer.startService() # XXX: We shouldn't be using this private _reactor API. See # https://twistedmatrix.com/trac/ticket/6200 and # https://twistedmatrix.com/trac/ticket/7527 def run_and_log(reactor): d = maybeDeferred(self.script.main, reactor, options) def got_error(failure): if not failure.check(SystemExit): err(failure) return failure d.addErrback(got_error) return d try: self._react(run_and_log, [], _reactor=self._reactor) finally: log_writer.stopService()
def stopService(self): """ Stops the loop that fetches mail. """ if self._loop and self._loop.running is True: self._loop.stop() self._loop = None Service.stopService(self)
def stopService(self): Service.stopService(self) if self.__ws_port_obj is None: raise Exception('Not started, cannot stop') # TODO: Does Twisted already have something to bundle up a bunch of ports for shutdown? return defer.DeferredList([ self.__http_port_obj.stopListening(), self.__ws_port_obj.stopListening()])
def stopService(self): Service.stopService(self) self.ready = False self._registered = False for d in list(self._waiting): d.cancel() self._waiting = [] return self._timer_service.stopService()
def stopService(self, stopReactor=False): Service.stopService(self) if self.pipeline is not None: self.forceEos() else: self.shutdown(EXIT_OK, stopReactor) return self.shutdownDeferred
def stopService(self): "Stop reading from the stream." ret = None if self._streamDone is not None: self._streamDone.cancel() ret = self._streamDone self._streamDone = None Service.stopService(self) return ret
def stopService(self): Event('instance-started').unsubscribe(self.write) Event('signal').unsubscribe(self.write) Event('journal-error').unsubscribe(self._journal_failure) if self._task.running: self._task.stop() if not self.writing.called: self.writing.addBoth(lambda x: Service.stopService(self) and x or x) return self.writing #the main service will deal with it Service.stopService(self)
def stopService(self): if self.running: Service.stopService(self) log.info("Stopping slave heartbeats...") if self._call.running: self._call.stop() return self._hb.stop() else: return defer.succeed(None)
def stopService(self): """ Stop reading on the inherited port. """ Service.stopService(self) # XXX stopping should really be destructive, because otherwise we will # always leak a file descriptor; i.e. this shouldn't be restartable. # XXX this needs to return a Deferred. self.reportingFactory.inheritedPort.stopReading()
def stopService(self): # annoince to matchmaker that server is shut down # try: # res = requests.delete(HUB+"/api/v1.0/register", json={"port": self.port, "id": self.node_id}, timeout=2) # except requests.exceptions.RequestException as e: # log.error("Could not notify hub due to request error: {}".format(e)) # else: # log.info("Service stop, notified hub with code {}".format(res.status_code)) Service.stopService(self)
def stopService(self): """Stop All Janitizer Service""" try: if self.GARBAGE_CHECK.running: self.GARBAGE_CHECK.stop() if self.ELDERLY_CHECK.running: self.ELDERLY_CHECK.stop() except: pass Service.stopService(self)
def stopService(self): """ Shutdown HiiTrack. """ self.log() self.logloop.stop() Service.stopService(self) cassandra.CLIENT.stopService() if self.listener: self.listener.stopListening()
def stopService(self): """ Stop the writer thread, wait for it to finish. """ Service.stopService(self) removeDestination(self) self._reactor.callFromThread(self._reactor.stop) return deferToThreadPool( self._mainReactor, self._mainReactor.getThreadPool(), self._thread.join )
def stopService(self): """ Stop the writer thread, wait for it to finish. """ Service.stopService(self) removeDestination(self) self._reactor.callFromThread(self._reactor.stop) return deferToThreadPool(self._mainReactor, self._mainReactor.getThreadPool(), self._thread.join)
def stopService(self): Service.stopService(self) self.ready = False self._registered = False for d in list(self._waiting): d.cancel() self._waiting = [] deferred = self._client.stop() deferred.addCallback(lambda _: self._timer_service.stopService()) return deferred
def stopService(self): info("Stopping client...") Service.stopService(self) # If CTRL-C is pressed twice in a row, the second SIGINT actually # kills us before subprocesses die, and that makes them hang around. signal.signal(signal.SIGINT, signal.SIG_IGN) done = self.watchdog.request_exit() done.addBoth(lambda r: self._remove_pid()) return done
def stopService(self): self.statusIcon.hide() # HACK: the timer should always be running and there's no need for this # check; however, during development the service might be # uncleanly with the timer not running, and then we'd rather # avoid 'trying to stop a timer which isn't running' exception if self.timer.running: self.timer.stop() self.connectionRegistry.updateConfiguration() self.configuration.save() Service.stopService(self)
def stopService(self): if self.running: Service.stopService(self) log.info("Stopping RPC service...") d1 = defer.maybeDeferred(self._remotePort.stopListening) d2 = defer.maybeDeferred(self._localPort.stopListening) d2.addBoth(self.cleanSocket) return defer.DeferredList([d1, d2]) else: return defer.succeed(None)
def stopService(self): if self.running: Service.stopService(self) log.info("Stopping RPC service...") d1=defer.maybeDeferred(self._remotePort.stopListening) d2=defer.maybeDeferred(self._localPort.stopListening) d2.addBoth(self.cleanSocket) return defer.DeferredList([d1, d2]) else: return defer.succeed(None)
def stopService(self): Service.stopService(self) if self._stream_protocol is not None: self._stream_protocol.transport.stopProducing() if self._reconnect_delayedcall is not None: self._reconnect_delayedcall.cancel() self._reconnect_delayedcall = None if self._connect_d is not None: self._connect_d.addErrback(lambda f: f.trap(CancelledError)) self._connect_d.cancel() self._connect_d = None self.reconnect_delay = 0
def stopService(self): if self.running: Service.stopService(self) try: self._process.signalProcess('TERM') except: pass try: reactor.stop() except: pass
def stopService(self): Service.stopService(self) if self._socket is not None: d = defer.maybeDeferred(self._socket.stopListening) else: d = defer.succeed(None) def loseConnection(_ignored): if self.factory.protocol and self.factory.protocol.transport is not None: self.factory.protocol.transport.loseConnection() d.addCallback(loseConnection) return d
def stopService(self): Service.stopService(self) if self.filename != '-': signal.signal(signal.SIGUSR1, self.__previous_signal_handler) del self.__previous_signal_handler self.observer.stop() self.observer = None self.logfile.close() self.logfile = None else: self.observer.stop() self.observer = None # Don't close stdout. self.logfile = None
def stopService(self): """ Stop reading on the inherited port. @return: a Deferred which fires after the last outstanding request is complete. """ Service.stopService(self) # XXX stopping should really be destructive, because otherwise we will # always leak a file descriptor; i.e. this shouldn't be restartable. self.reportingFactory.inheritedPort.stopReading() # Let any outstanding requests finish return self.reportingFactory.allConnectionsClosed()
def stopService(self): """Stop All AppManager Services""" for x in ['allapps', 'applist']: if x in drone.builtins: del drone.builtins[x] Event('instance-started').unsubscribe(self.reset_tracking) for manager in AppManager.objects: if manager.running: mesg = 'Stopping Application Manager' logWithContext(type=manager.name, route=SERVICENAME)(mesg) manager.stop() #plugins are stateless by design pluginFactory.delete_plugin(manager.model) if self._task.running: self._task.stop() Service.stopService(self)
def stopService(self): """Stop All AppManager Services""" for x in ['allapps', 'applist']: if x in drone.builtins: del drone.builtins[x] Event('instance-started').unsubscribe(self.reset_tracking) for manager in AppManager.objects: if manager.running: mesg = 'Stopping Application Manager' logWithContext(type=manager.name,route=SERVICENAME)(mesg) manager.stop() #plugins are stateless by design pluginFactory.delete_plugin(manager.model) if self._task.running: self._task.stop() Service.stopService(self)
def stopService(self): """ Called when the plugin is stopped. If a plugin needs to perform any shutdown task, they should override this method (be sure to chain up to the parent method) and perform them here. """ return Service.stopService(self)
def stopService(self): if self._delayedCall: self._delayedCall.cancel() self._delayedCall = None return self._looper.stop() self._loopFinished.addCallback(lambda _: Service.stopService(self)) return self._loopFinished
def stopService(self): Service.stopService(self) self.ready = False for d in list(self._waiting): d.cancel() self._waiting = [] def stop_timer(ignored): if not self._timer_service: return return self._timer_service.stopService() def cleanup(ignored): self._timer_service = None return (self._client.stop().addBoth(tap(stop_timer)).addBoth( tap(cleanup)))
def stopService(self): if self.capture_logs: globalLogPublisher.removeObserver(self.twisted_observer) self.stdlib_cleanup() if self.task is not None: self.task.finish() for dest in self.destinations: remove_destination(dest) return Service.stopService(self)
def stopService(self): def exit(result): log.info("Stopping daemon...") if not reactor._stopped: reactor.stop() if self.running: Service.stopService(self) # Stop receiving cluster messages self._messagePort.stopListening() self.s_rpc.stopService().addErrback(log.err) # Cleanly leave cluster d = self.leaveCluster() d.addErrback(log.err) d.addBoth(exit) # Even if there are errors return d else: return defer.succeed(None)