:meth:`.WSimpleTrackerStorage.register_stop` method implementation
194824
def register_stop(self, task, event_details=None):
		
		if self.record_stop() is True:
			record_type = WTrackerEvents.stop
			record = WSimpleTrackerStorage.Record(record_type, task, event_details=event_details)
			self.__store_record(record)
1221789
public void stop() {

        String thisMethodName = CLASS_NAME + ".stop()";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            // SibTr.entry(tc, thisMethodName);
        }

        // Get the MEs on this server
        Enumeration meEnum = _messagingEngines.elements();

        // Stop each ME on this server. Any exceptions are caught and
        // deliberately
        // not
        // rethrown as errors in one ME must not affect any others that might
        // exist.
        while (meEnum.hasMoreElements()) {
            Object o = meEnum.nextElement();
            Object c = ((MessagingEngine) o).getRuntime();
            try {

                ((BaseMessagingEngineImpl) c)
                                .stopConditional(JsConstants.ME_STOP_IMMEDIATE);
            } catch (Exception e) {
                FFDCFilter.processException(e, thisMethodName, "1:854:1.108",
                                            this);
                SibTr.exception(tc, e);
                SibTr.error(tc, "INTERNAL_ERROR_SIAS0003", e);
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName);
        }
    }
1085026
def register_signal_handlers
      trap('TERM') { shutdown! }
      trap('INT')  { shutdown! }

      begin
        trap('QUIT') { shutdown }
      rescue ArgumentError
        warn "Signals TERM and/or QUIT not supported."
      end

      log! "Registered signals"
    end
1142841
def stop(self):
        
        if self.server.eio.async_mode == 'threading':
            func = flask.request.environ.get('werkzeug.server.shutdown')
            if func:
                func()
            else:
                raise RuntimeError('Cannot stop unknown web server')
        elif self.server.eio.async_mode == 'eventlet':
            raise SystemExit
        elif self.server.eio.async_mode == 'gevent':
            self.wsgi_server.stop()
932975
public synchronized void stop() {
        // stopps all watchdogs
        Iterator iter = registeredWachdogs.values().iterator();
        while (iter.hasNext()) {
            Watchdog wd = (Watchdog) iter.next();
            wd.stop();
            if (log.isInfoEnabled()) {
                log.info("WatchdogRegistry.stop() : Watchdog " + wd.getId() + " is stopped");
            }
        }


    }
1205008
def stop(self):
        
        self.stop_flag.value = True
        with self.lock:
            (
                Control().text(C(' ', style='reset_all'))
                .pos_restore().move_column(1).erase_line()
                .write(self.file)
            )
573772
private void registerCleanupTimer(W window) {
		long cleanupTime = cleanupTime(window);
		if (cleanupTime == Long.MAX_VALUE) {
			// don't set a GC timer for "end of time"
			return;
		}

		if (windowAssigner.isEventTime()) {
			triggerContext.registerEventTimeTimer(cleanupTime);
		} else {
			triggerContext.registerProcessingTimeTimer(cleanupTime);
		}
	}
403063
def stop(cls):
        
        main_log, cls.main_log = cls.main_log, StructuredLogger_usingStream(STDOUT)
        main_log.stop()
781126
def stop(self):
        
        if self.stop_event.ready():  # not started
            return

        # Needs to come before any greenlets joining
        self.stop_event.set()

        # Filters must be uninstalled after the alarm task has stopped. Since
        # the events are polled by an alarm task callback, if the filters are
        # uninstalled before the alarm task is fully stopped the callback
        # `poll_blockchain_events` will fail.
        #
        # We need a timeout to prevent an endless loop from trying to
        # contact the disconnected client
        self.transport.stop()
        self.alarm.stop()

        self.transport.join()
        self.alarm.join()

        self.blockchain_events.uninstall_all_event_listeners()

        # Close storage DB to release internal DB lock
        self.wal.storage.conn.close()

        if self.db_lock is not None:
            self.db_lock.release()

        log.debug('Raiden Service stopped', node=pex(self.address))
488717
@Override
    public void stop(){
        if (isStarted) {
            synchronized (this) {
                if (isStarted) {
                    if (getRegistrationService() instanceof Closable) {
                        ((Closable) getRegistrationService()).stop();
                    }
                    isStarted = false;
                }
            }
        }

    }
1098196
def stop(self):
        
        distributed_logger.info('Stopping metrics aggregator')
        self.process.terminate()
        self.process.join()
        distributed_logger.info('Stopped metrics aggregator')
662491
private function stopTimeRegister()
    {
        if ($this->rTimer !== null)
        {
            $this->rTimer->cancel();
            $this->rTimer = null;
            $this->connectionPool->resetNow();
        }
    }
313428
def stop(self, stopSparkContext=True, stopGraceFully=False):
        
        while self._on_stop_cb:
            cb = self._on_stop_cb.pop()
            log.debug('calling on_stop_cb {}'.format(cb))
            cb()

        IOLoop.current().stop()

        StreamingContext._activeContext = None
1150979
def stop(self, check=True):
        
        if (check and self.countiter > 0 and self.opts['termination_callback'] and
                self.opts['termination_callback'] != str(self.opts['termination_callback'])):
            self.callbackstop = self.opts['termination_callback'](self)

        return self._stopdict(self, check)
427667
def stop(self):
        
        # check that everything is running
        if not self._running:
            logging.warning('Realsense not running. Aborting stop.')
            return False

        self._pipe.stop()
        self._running = False
        return True
208661
def start(self):
		
		tracker = self.tracker_storage()
		if tracker is not None and self.track_start() is True:
			details = self.event_details(WTrackerEvents.start)
			tracker.register_start(self, event_details=details)
		WThreadTask.start(self)
880166
def stop(self):
        
        LOGGER.debug("natsd.Driver.stop")
        for requester in self.requester_registry:
            requester.stop()
        self.requester_registry.clear()

        for service in self.services_registry:
            if service.is_started:
                service.stop()
        self.services_registry.clear()

        return self