Abort everything, everywhere.
332280
def abort(err):
    """"""
    if _debug: abort._debug("abort %r", err)
    global local_controllers

    # tell all the local controllers to abort
    for controller in local_controllers.values():
        controller.abort(err)
666599
function destroyAll(callback) {
        targetClass.all(this._scope, function (err, data) {
            if (err) {
                callback(err);
            } else {
                (function loopOfDestruction(data) {
                    if (data.length > 0) {
                        data.shift().destroy(function (err) {
                            if (err && callback)
                                callback(err);
                            loopOfDestruction(data);
                        });
                    } else {
                        if (callback)
                            callback();
                    }
                }(data));
            }
        });
    }
1064652
protected final void abortIfNeeded() {
        if (shouldAbort()) {
            try {
                abort();    // execute subclass specific abortion logic
            } catch (IOException e) {
                LogFactory.getLog(getClass()).debug("FYI", e);
            }
            throw new AbortedException();
        }
    }
643571
def scram(self):
        '''

        '''
        self.stop_all_children()
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
        sys.exit(2)
35211
def handle_abort(e)
      if log.level == ::Logger::DEBUG
        raise e
      elsif e.class != SystemExit
        @log.error e.message.red
        @log.info 'cleaning up...'

        task_manager.invoke_task_oneshot(:cleanup_local)
      end
      
      Kernel.exit(true)
    end
995557
function closeAll() {
        DeprecationWarning.deprecationWarning("Use CommandManager.execute(Commands.FILE_CLOSE_ALL,{PaneId: MainViewManager.ALL_PANES}) instead of DocumentManager.closeAll()", true);
        CommandManager.execute(Commands.FILE_CLOSE_ALL, {PaneId: MainViewManager.ALL_PANES});
    }
471898
public function abort()
    {
        if ($this->aborted) {
            return;
        }

        $this->aborted = true;
        $this->onWakeup();
        $this->onAbort();

        if ((ignore_user_abort() === 1)
            && (($this->state === Generic::STATE_RUNNING) || ($this->state === Generic::STATE_WAITING))
            && !Daemon::$compatMode
        ) {
            $this->upstream->endRequest($this);
        } else {
            $this->finish(-1);
        }

        $this->onSleep();
    }
721917
public void killAll() {
        for (int i = 0; i < size(); i++) {
            if (i == 0) {
                players[i].bye();
                players[i].stopRunning();
            } else if (i >= 1) {
                try {
                    players[i].bye();
                    players[i].stopRunning();
                } catch (Exception ex) {
                    players[i].handleError(ex.getMessage());
                }
            }
            pause(500);
        }
        if (hasCoach) {
            try {
                coach.bye();
                coach.stopRunning();
            } catch (Exception ex) {
                coach.handleError(ex.getMessage());
            }
            pause(500);
        }
    }
269093
def abort(self, reason):
        """"""
        if _debug: ClientSSM._debug("abort %r", reason)

        # change the state to aborted
        self.set_state(ABORTED)

        # build an abort PDU to return
        abort_pdu = AbortPDU(False, self.invokeID, reason)

        # return it
        return abort_pdu
192757
def abort_request(self, request):
        """"""
        self.timedout = True
        try:
            request.cancel()
        except error.AlreadyCancelled:
            return
878933
def kill_all(self, kill_signal, kill_shell=False):
        """"""
        for key in self.processes.keys():
            self.kill_process(key, kill_signal, kill_shell)
926554
public function removeAll()
    {
        $command = sprintf(
            'rm -rf %s%s*',
            rtrim($this->targetDirectory, DIRECTORY_SEPARATOR),
            DIRECTORY_SEPARATOR
        );

        exec($command);
    }
281794
function(options) {
        var self = this;
        return self.find(options).then(function(objects) {
          return AV.Object.destroyAll(objects, options);
        });
      }
1043765
public void abort() {
        cancel();
        if (mDragState == STATE_SETTLING) {
            final int oldX = mScroller.getCurrX();
            final int oldY = mScroller.getCurrY();
            mScroller.abortAnimation();
            final int newX = mScroller.getCurrX();
            final int newY = mScroller.getCurrY();
            mCallback.onViewPositionChanged(mCapturedView, newX, newY, newX - oldX, newY - oldY);
        }
        setDragState(STATE_IDLE);
    }
375075
def pop_all(self):
        """"""
        new_stack = type(self)()
        new_stack._exit_callbacks = self._exit_callbacks
        self._exit_callbacks = deque()
        return new_stack
1037532
def abort(self):
        
        if (self.reply and self.reply.isRunning()):
            self.on_abort = True
            self.reply.abort()
1314259
def abort(self, err):
        """"""
        if _debug: IOQueue._debug("abort %r", err)

        # send aborts to all of the members
        try:
            for iocb in self.queue:
                iocb.ioQueue = None
                iocb.abort(err)

            # flush the queue
            self.queue = []

            # the queue is now empty, clear the event
            self.notempty.clear()
        except ValueError:
            pass