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

    # start with the server
    if IOServer._highlander:
        IOServer._highlander.abort(err)

    # now do everything local
    for controller in _local_controllers.values():
        controller.abort(err)
118602
void abort(Throwable t) throws IOException {
    LOG.info("Aborting because of " + StringUtils.stringifyException(t));
    try {
      downlink.abort();
      downlink.flush();
    } catch (IOException e) {
      // IGNORE cleanup problems
    }
    try {
      handler.waitForFinish();
    } catch (Throwable ignored) {
      process.destroy();
    }
    IOException wrapper = new IOException("pipe child exception");
    wrapper.initCause(t);
    throw wrapper;      
  }
858830
function() {
				this.abort();

				if (_fr) {
					_fr.getRuntime().exec.call(this, 'FileReader', 'destroy');
					_fr.disconnectRuntime();
				}

				self = _fr = null;
			}
375075
def pop_all(self):
        """"""
        new_stack = type(self)()
        new_stack._exit_callbacks = self._exit_callbacks
        self._exit_callbacks = deque()
        return new_stack
659377
def _killall(self, force=False):
        """"""
        for_termination = []

        for n, p in iteritems(self._processes):
            if 'returncode' not in p:
                for_termination.append(n)

        for n in for_termination:
            p = self._processes[n]
            signame = 'SIGKILL' if force else 'SIGTERM'
            self._system_print("sending %s to %s (pid %s)\n" %
                               (signame, n, p['pid']))
            if force:
                self._env.kill(p['pid'])
            else:
                self._env.terminate(p['pid'])
281794
function(options) {
        var self = this;
        return self.find(options).then(function(objects) {
          return AV.Object.destroyAll(objects, options);
        });
      }
621764
public void onAbort() {
        for (Future<?> future : getFutures()) {
            future.cancel(true);
        }
        if (uploadId != null) {
            try {
                s3.abortMultipartUpload(new AbortMultipartUploadRequest(
                    req.getBucketName(), req.getKey(), uploadId));
            } catch (Exception e) {
                LogFactory.getLog(getClass())
                          .debug("Failed to abort multi-part upload: " + uploadId, e);
            }
        }
    }
994579
public void processAbort() {
        LOG.entering(CLASS_NAME, "abort");
        if (reader != null) {
            reader.stop();
            reader = null;
        }
    }
303437
def _abortJobs( self, js ):
        """"""
        self.open()
        self._client.abort(jobs = js)
        self.close()
342757
public function destroyAll()
    {
        if ($this->newImage)
        {
            $this->destroy($this->newImage);
        }

        if ($this->sourceImage)
        {
            $this->destroy($this->sourceImage);
        }
    }
990741
def run_hooks(hooks, halt_on_abort: true)
      hooks.each do |hook|
        run_hook(hook)
        break if aborted? && halt_on_abort
      end
    end
1259969
public synchronized void abort()
    {
        if (done)
            return;

        done = true;
        for (SSTableWriter writer : sstables)
            writer.abort();
        sstables.clear();
    }
554163
def abort(message, *args):
	''''''
	if args:
		raise _AbortException(message.format(*args))

	raise _AbortException(message)
212669
function _abortAllRequests() {
        var req;
        while (this._requests.length > 0) {
            req = this._requests.pop();
            req.abort = true;
            req.xhr.abort();
            // jslint complains, but this is fine. setting to empty func
            // is necessary for IE6
            req.xhr.onreadystatechange = function () {}; // jshint ignore:line
        }
    }
1043344
def killall(self):
        
        for pid in set(self):
            try:
                os.kill(pid, signal.SIGTERM)
            except OSError, e: # pragma: nocover
                if e.errno == errno.ESRCH:
                    "Process previously died on its own"
            self.remove(pid)
921883
def abort(self, err):
        """"""
        if _debug: IOCB._debug("abort(%d) %r", self.ioID, err)

        if self.ioController:
            # pass to controller
            self.ioController.abort_io(self, err)
        elif self.ioState < COMPLETED:
            # just fill in the data
            self.ioState = ABORTED
            self.ioError = err
            self.trigger()
506513
def _abort_batches(self):
        """"""
        error = Errors.IllegalStateError("Producer is closed forcefully.")
        for batch in self._incomplete.all():
            tp = batch.topic_partition
            # Close the batch before aborting
            with self._tp_locks[tp]:
                batch.records.close()
            batch.done(exception=error)
            self.deallocate(batch)