Stop tracking a remote task, because we got an ACKACK.
339277
void remove_task_tracking( int task ) {
    RPC.RPCCall rpc = _work.get(task);
    if( rpc == null ) return;   // Already stopped tracking

    // Atomically attempt to remove the 'dt'.  If we win, we are the sole
    // thread running the dt.onAckAck.  Also helps GC: the 'dt' is done (sent
    // to client and we received the ACKACK), but the rpc might need to stick
    // around a long time - and the dt might be big.
    DTask dt = rpc._dt;         // The existing DTask, if any
    if( dt != null && RPC.RPCCall.CAS_DT.compareAndSet(rpc,dt,null) ) {
      assert rpc._computed : "Still not done #"+task+" "+dt.getClass()+" from "+rpc._client;
      AckAckTimeOutThread.PENDING.remove(rpc);
      dt.onAckAck();            // One-time call on stop-tracking
    }

    // Roll-up as many done RPCs as we can, into the _removed_task_ids list
    while( true ) {
      int t = _removed_task_ids.get();   // Last already-removed ID
      RPC.RPCCall rpc2 = _work.get(t+1); // RPC of 1st not-removed ID
      if( rpc2 == null || rpc2._dt != null || !_removed_task_ids.compareAndSet(t,t+1) )
        break;                  // Stop when we hit in-progress tasks
      _work.remove(t+1);        // Else we can remove the tracking now
    }
  }
596046
def stop_capture(self):
        

        self._capturing = False
        self._project.controller.notification.emit("link.updated", self.__json__())
1348988
private void removeTracker(TaskTracker tracker) {
    String trackerName = tracker.getTrackerName();
    // Remove completely after marking the tasks as 'KILLED'
    lostTaskTracker(tracker);
    TaskTrackerStatus status = tracker.getStatus();

    // tracker is lost, and if it is blacklisted, remove
    // it from the count of blacklisted trackers in the cluster
    if (isBlacklisted(trackerName)) {
     faultyTrackers.decrBlackListedTrackers(1);
    }
    updateTaskTrackerStatus(trackerName, null);
    statistics.taskTrackerRemoved(trackerName);
    getInstrumentation().decTrackers(1);
  }
430745
public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }
980290
private void cancelScan() {
        if (cleanTask != null) {
            cleanTask.cancel(true);
            cleanTask = null;
        }
        client.close();
    }
198068
private void cancelScan() {
        if (rescanIncompleteTask != null) {
            rescanIncompleteTask.cancel(true);
            rescanIncompleteTask = null;
        }
        if (rescanUndeployTask != null) {
            rescanUndeployTask.cancel(true);
            rescanUndeployTask = null;
        }
        if (scanTask != null) {
            scanTask.cancel(true);
            scanTask = null;
        }
    }
1065876
def stop(self):
        
        if not self.is_started:
            raise ConnectionError("Client is already stopped")

        if self.takeout_id:
            self.send(functions.account.FinishTakeoutSession())
            log.warning("Takeout session {} finished".format(self.takeout_id))

        Syncer.remove(self)
        self.dispatcher.stop()

        for _ in range(self.DOWNLOAD_WORKERS):
            self.download_queue.put(None)

        for i in self.download_workers_list:
            i.join()

        self.download_workers_list.clear()

        for _ in range(self.UPDATES_WORKERS):
            self.updates_queue.put(None)

        for i in self.updates_workers_list:
            i.join()

        self.updates_workers_list.clear()

        for i in self.media_sessions.values():
            i.stop()

        self.media_sessions.clear()

        self.is_started = False
        self.session.stop()

        return self
841186
def stop(self):
        """"""
        self._end.value = True
        if self.background_process:
            try:
                self.background_process.terminate()
            except Exception:
                pass
        for task_id, values in self.current_tasks.items():
            try:
                values['proc'].terminate()
            except Exception:
                pass
1093950
private void unclaimTask(ClaimedTask claimedTask, boolean releaseTask) {
        _claimedTasks.remove(claimedTask.getTaskId());
        claimedTask.setComplete(true);

        if (releaseTask) {
            try {
                _scanWorkflow.releaseScanRangeTask(claimedTask.getTask());
                _log.info("Released scan range task: {}", claimedTask.getTask());
            } catch (Exception e) {
                _log.error("Failed to release scan range", e);
            }
        }
    }
119604
async def stop(self):
        
        for task in self.__tracks.values():
            if task is not None:
                task.cancel()
        self.__tracks = {}
532872
async def stop(self, _task=None):
        

        self._logger.info("Stopping adapter wrapper")

        if self._task.stopped:
            return

        for task in self._task.subtasks:
            await task.stop()

        self._logger.debug("Stopping underlying adapter %s", self._adapter.__class__.__name__)
        await self._execute(self._adapter.stop_sync)
254507
def stop_tracking(self, end_time):
        """"""
        facts = self.__get_todays_facts()
        if facts and not facts[-1]['end_time']:
            self.__touch_fact(facts[-1], end_time)
            self.facts_changed()
531001
def stop_capture(self):
        """"""
        super(Treal, self).stop_capture()
        if self._machine:
            self._machine.close()
        self._stopped()
1021870
def stop
      Guard::Compat::UI.info "Guard::RemoteSync stopped."
      Guard::Compat::UI.notify("Guard::RemoteSync stopped.",notifier_options)
    end
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);
                }
            }
        }
    }
856654
def stop_consuming(self):
        
        if self._channel:
            _logger.debug('Sending a Basic.Cancel RPC command to RabbitMQ')
            self._channel.basic_cancel(self.on_cancelok, self._consumer_tag)
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
        )