Stops Taskmaster processing by not returning a next candidate.

        Note that we have to clean-up the Taskmaster candidate list
        because the cycle detection depends on the fact all nodes have
        been processed somehow.
328462
def no_next_candidate(self):
        
        while self.candidates:
            candidates = self.candidates
            self.candidates = []
            self.will_not_build(candidates)
        return None
567814
def stop(self):
        """"""
        _LOGGER.info('Stopping gateway')
        self._disconnect()
        if self.connect_task and not self.connect_task.cancelled():
            self.connect_task.cancel()
            self.connect_task = None
        if not self.persistence:
            return
        if self._cancel_save is not None:
            self._cancel_save()
            self._cancel_save = None
        yield from self.loop.run_in_executor(
            None, self.persistence.save_sensors)
418439
public boolean stop() {
        if (scheduledFuture != null && !scheduledFuture.isCancelled()) {
            scheduledFuture.cancel(DO_NOT_INTERRUPT_IF_RUNNING);
            if (LOG.isDebugEnabled()) {
                LOG.debug("{} Cache Manager stopped.", cache.getClass().getSimpleName());
            }
            return true;
        }
        return false;
    }
118235
public void stop() {
        if (mMonitorStarted) {
            mMonitorStarted = false;
            Looper.getMainLooper().setMessageLogging(null);
            mBlockCanaryCore.stackSampler.stop();
            mBlockCanaryCore.cpuSampler.stop();
        }
    }
372689
def cleanup(self):
        
        if self.transport:
            self.transport.close()
            self.transport = None
        if self.task:
            self.task.cancel()
            self.task = None
959845
def stop(self) -> None:
        

        self._shutdown = True

        # Close connection if needed
        self._protocol.close()

        # Cancel any pending tasks
        self.cancel_pending_tasks()
147496
async def stop(self):
        
        if self.__started:
            self.__transport._unregister_rtp_sender(self)
            self.__rtp_task.cancel()
            self.__rtcp_task.cancel()
            await asyncio.gather(
                self.__rtp_exited.wait(),
                self.__rtcp_exited.wait())
1303542
def StopProcessing(obj, eng, callbacks, exc_info):
        """"""
        e = exc_info[1]
        obj.save(status=eng.object_status.COMPLETED,
                 id_workflow=eng.uuid)
        eng.save(WorkflowStatus.COMPLETED)
        obj.log.warning(
            "Workflow '%s' stopped at task %s with message: %s",
            eng.name, eng.current_taskname or "Unknown", e.message
        )
        db.session.commit()

        super(InvenioTransitionAction, InvenioTransitionAction).StopProcessing(
            obj, eng, callbacks, exc_info
        )
599075
async def stop(self, force: bool=False) -> None:
        ''''''

        Log.debug('stopping task %s', self.name)
        self.running = False

        if force:
            self.task.cancel()
260924
public void stopChecking() {
        // synchronize with other attempts to update the running task
        synchronized(runningTaskLock){
            if(runningTask != null) {
                // cancel task (let it complete its current run if running)
                runningTaskFuture.cancel(false);
                // log
                LOGGER.debug("Stop criterion checker for search {} deactivated", search);
                // discard task
                runningTask = null;
                runningTaskFuture = null;
            }
        }
    }
50208
@LifecycleStop
  public void stop()
  {
    giant.lock();

    try {
      tasks.clear();
      taskFutures.clear();
      active = false;
      managerExec.shutdownNow();
      storageSyncExec.shutdownNow();
      managementMayBeNecessary.signalAll();
    }
    finally {
      giant.unlock();
    }
  }
316997
def _StopExtractionProcesses(self, abort=False):
    
    logger.debug('Stopping extraction processes.')
    self._StopMonitoringProcesses()

    # Note that multiprocessing.Queue is very sensitive regarding
    # blocking on either a get or a put. So we try to prevent using
    # any blocking behavior.

    if abort:
      # Signal all the processes to abort.
      self._AbortTerminate()

    logger.debug('Emptying task queue.')
    self._task_queue.Empty()

    # Wake the processes to make sure that they are not blocking
    # waiting for the queue new items.
    for _ in self._processes_per_pid:
      try:
        self._task_queue.PushItem(plaso_queue.QueueAbort(), block=False)
      except errors.QueueFull:
        logger.warning('Task queue full, unable to push abort message.')

    # Try waiting for the processes to exit normally.
    self._AbortJoin(timeout=self._PROCESS_JOIN_TIMEOUT)
    self._task_queue.Close(abort=abort)

    if not abort:
      # Check if the processes are still alive and terminate them if necessary.
      self._AbortTerminate()
      self._AbortJoin(timeout=self._PROCESS_JOIN_TIMEOUT)
      self._task_queue.Close(abort=True)

    # Kill any lingering processes.
    self._AbortKill()
456933
protected void stop() {
        this.authenticating = false;
        // clear batcher
        batcher.clear();
        // set non-continuous
        setLifecycle(Replication.Lifecycle.ONESHOT);
        // cancel if middle of retry
        cancelRetryFuture();
        // cancel all pending future tasks.
        while (!pendingFutures.isEmpty()) {
            Future future = pendingFutures.poll();
            if (future != null && !future.isCancelled() && !future.isDone()) {
                future.cancel(true);
                CancellableRunnable runnable = cancellables.get(future);
                if (runnable != null) {
                    runnable.cancel();
                    cancellables.remove(future);
                }
            }
        }
    }
552291
async def cancel_remaining(self):
        ''''''
        self._closed = True
        task_list = list(self._pending)
        for task in task_list:
            task.cancel()
        for task in task_list:
            with suppress(CancelledError):
                await task
1221589
public void stopAutoCycle(){
        if(mCycleTask!=null){
            mCycleTask.cancel();
        }
        if(mCycleTimer!= null){
            mCycleTimer.cancel();
        }
        if(mResumingTimer!= null){
            mResumingTimer.cancel();
        }
        if(mResumingTask!=null){
            mResumingTask.cancel();
        }
        mAutoCycle = false;
        mCycling = false;
    }
1278926
def stop(self):
        """"""
        if self.running and self.num_workers:
            for worker in self.workers:
                self.queue.put(None)
            for worker in self.workers:
                worker.join()
            # Free up references held by workers
            del self.workers[:]
            self.queue.join()
        self.running = False
262128
public synchronized void pause() {
        // use compareAndSet to make sure it stops only once and when running
        if (running.compareAndSet(true, false)) {
            logger.debug("Stopping the HystrixMetricsPoller");
            scheduledTask.cancel(true);
        } else {
            logger.debug("Attempted to pause a stopped poller");
        }
    }