Go through incomplete batches and abort them.
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)
54614
function (nodes, batchOps, done) {
      self.db.batch(batchOps, function (err) {
        if (err) {
          nodes.forEach(rejectNode)
          return done(err)
        }
        done(null, nodes)
      })
    }
700066
def abort(self, reason):
        """"""
        if _debug: ServerSSM._debug("abort %r", reason)

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

        # return an abort APDU
        return AbortPDU(True, self.invokeID, reason)
607769
def abort_io(self, iocb, err):
        """"""
        if _debug: IOChainMixIn._debug("abort_io %r %r", iocb, err)

        # make sure we're being notified of an abort request from
        # the iocb we are chained from
        if iocb is not self.ioChain:
            raise RuntimeError("broken chain")

        # call my own Abort(), which may forward it to a controller or
        # be overridden by IOGroup
        self.abort(err)
1186456
async def abort(self):
        """"""
        state = await self.state()
        res = await self.call("X_Abort", MasterSessionID=state.MasterSessionID)
        return res
659133
def skip_all(self):
        """"""

        storage, streaming = self.engine.count()

        if self.selector.output:
            self.offset = streaming
        else:
            self.offset = storage

        self._count = 0
1340551
function abort (err, stream, db, cb) {
  debug('aborting with error: ' + err);
  stream.destroy();
  db.close(function () {
    cb(err);
  })
}
1030593
def finalize(self, result):
        """"""
        sys.stderr = self._stderr.pop()
        sys.stdout = self._stdout.pop()
        pdb.set_trace = self._set_trace.pop()
        pdb.Pdb.cmdloop = self._cmdloop.pop()
1135121
def abort():
    """"""
    a = TpPd(pd=0x5)
    b = MessageType(mesType=0x29)  # 00101001
    c = RejectCause()
    packet = a / b / c
    return packet
391479
def reject(self):
        """"""
        self.stochastic.revert()

        # Increment rejected count
        self.rejected[self.current_kernel] += 1

        if self.verbose > 1:
            print_(
                self._id,
                "rejected, reverting to value =",
                self.stochastic.value)
63878
private void abortTransactions(Set<String> transactionalIds) {
		for (String transactionalId : transactionalIds) {
			try (FlinkKafkaInternalProducer<byte[], byte[]> kafkaProducer =
				initTransactionalProducer(transactionalId, false)) {
				// it suffice to call initTransactions - this will abort any lingering transactions
				kafkaProducer.initTransactions();
			}
		}
	}
140553
def _AbortTerminate(self):
    """"""
    for pid, process in iter(self._processes_per_pid.items()):
      if not process.is_alive():
        continue

      logger.warning('Terminating process: {0:s} (PID: {1:d}).'.format(
          process.name, pid))
      process.terminate()
1326700
def stop(args):
  """"""
  if args.local:
    raise ValueError("Stopping commands locally is not supported (please kill them yourself)")
  jm = setup(args)
  jm.stop_jobs(get_ids(args.job_ids))
295481
def _filter_deleted_records(self, batches):
        
        for batch in batches:
            for record in batch:
                if not self.must_delete_record(record):
                    yield record
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
52373
private void abortMultiPartUpload() {
    AmazonClientException lastException;
    do {
      try {
        mClient.abortMultipartUpload(new AbortMultipartUploadRequest(mBucketName,
            mKey, mUploadId));
        LOG.warn("Aborted multipart upload for key {} and id '{}' to bucket {}",
            mKey, mUploadId, mBucketName);
        return;
      } catch (AmazonClientException e) {
        lastException = e;
      }
    } while (mRetryPolicy.attempt());
    // This point is only reached if the operation failed more
    // than the allowed retry count
    LOG.warn("Unable to abort multipart upload for key '{}' and id '{}' to bucket {}. "
        + "You may need to enable the periodical cleanup by setting property {}"
        + "to be true.", mKey, mUploadId, mBucketName,
        PropertyKey.UNDERFS_CLEANUP_ENABLED.getName(),
        lastException);
  }
1244225
def deallocate(self, batch):
        """"""
        self._incomplete.remove(batch)
        self._free.deallocate(batch.buffer())