Abort the processing_block.
343482
def abort(self):
        """"""
        LOG.debug('Aborting PB %s', self._id)
        self.set_status('aborted')
        pb_type = DB.get_hash_value(self.key, 'type')
        key = '{}:active'.format(self._type)
        DB.remove_from_list(key, self._id)
        key = '{}:active:{}'.format(self._type, pb_type)
        DB.remove_from_list(key, self._id)
        key = '{}:aborted'.format(self._type)
        DB.append_to_list(key, self._id)
        key = '{}:aborted:{}'.format(self._type, pb_type)
        DB.append_to_list(key, self._id)
        self._mark_updated()
1244075
def abort(self):
        
        err = _pa.Pa_AbortStream(self._stream)
        if err == _pa.paStreamIsStopped:
            return
        self._handle_error(err)
258346
def halt(self):
        
        if self._callback:
            self._thread_continue = False
            self._thread.join()
338276
function abort() {
		if (!headers_sent() && session_status()!=PHP_SESSION_ACTIVE)
			session_start();
		$out='';
		while (ob_get_level())
			$out=ob_get_clean().$out;
		if (!headers_sent()) {
			header('Content-Length: '.strlen($out));
			header('Connection: close');
		}
		session_commit();
		echo $out;
		flush();
		if (function_exists('fastcgi_finish_request'))
			fastcgi_finish_request();
	}
181104
def abort (aggregate):
    """"""
    while True:
        try:
            aggregate.abort()
            aggregate.finish()
            aggregate.end_log_output(interrupt=True)
            break
        except KeyboardInterrupt:
            log.warn(LOG_CHECK, _("user abort; force shutdown"))
            aggregate.end_log_output(interrupt=True)
            abort_now()
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
38462
def abort(self, msg=None):
        '''
        '''
        if not self.abort_run.is_set():
            if msg:
                logging.error('%s%s Aborting run...', msg, ('' if msg[-1] in punctuation else '.'))
            else:
                logging.error('Aborting run...')
        self.abort_run.set()
        self.stop_run.set()
1149412
private void stop() {
        finish(inputThread);

        try {
            err.flush();
        } catch (IOException e) {
            // ignore
        }
        try {
            out.flush();
        } catch (IOException e) {
            // ignore
        }
        finish(outputThread);
        finish(errorThread);
    }
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()
427200
public function abandon()
    {
        foreach ($this->processes as $index => $process) {
            $process->kill();

            unset($process[$index]);
        }

        unset($this->processes);
    }
518738
public void abort() {
    try {
      super.close();
    } catch (IOException ioe) {
      LOG.warn("Unable to abort file " + tmpFile, ioe);
    }
    if (!tmpFile.delete()) {
      LOG.warn("Unable to delete tmp file during abort " + tmpFile);
    }
  }
1008116
def terminate(self):
        """"""
        if self._process.state() == QProcess.Running:
            try:
                self._process.terminate()
            except Exception:
                pass
        self._fired = True
1259969
public synchronized void abort()
    {
        if (done)
            return;

        done = true;
        for (SSTableWriter writer : sstables)
            writer.abort();
        sstables.clear();
    }
77070
def abort(self):
        """"""
        for sbi_id in self.sbi_ids:
            sbi = SchedulingBlockInstance(sbi_id)
            sbi.abort()
        self.set_state('ABORTED')
1301082
void stop() {
    if (!shouldRun(conf)) {
      return;
    }
    nodeHealthScriptScheduler.cancel();
    if (shexec != null) {
      Process p = shexec.getProcess();
      if (p != null) {
        p.destroy();
      }
    }
  }
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
873422
def delete(block_id):
    """"""
    _url = get_root_url()
    try:
        DB.delete_processing_block(block_id)
        response = dict(message='Deleted block',
                        id='{}'.format(block_id),
                        links=dict(list='{}/processing-blocks'.format(_url),
                                   home='{}'.format(_url)))
        return response, HTTPStatus.OK
    except RuntimeError as error:
        response = dict(error='Failed to delete Processing Block: {}'.
                        format(block_id),
                        reason=str(error),
                        links=dict(list='{}/processing-blocks'.format(_url),
                                   home='{}'.format(_url)))
        return response, HTTPStatus.OK