Exit the process with an error message, optionally with a stack trace.
554721
public static void crashLocalVoltDB(String errMsg, boolean stackTrace, Throwable thrown) {
        crashLocalVoltDB(errMsg, stackTrace, thrown, true);
    }
1206580
def handle_errors
      trap('HUP')  { }
      trap('TERM') { close_log; Process.exit! }
      trap('KILL') { close_log; Process.exit! }
      trap('INT')  { close_log; Process.exit! }
    end
220624
def stop(self):
                
        if self.is_alive():
            self._proc.terminate()
            
        if self._proc is not None:
            self.__cleanup()
                   
            if self.raise_error:
                if self._proc.exitcode == 255:
                    raise LoopExceptionError("the loop function return non zero exticode ({})!\n".format(self._proc.exitcode)+
                                             "see log (INFO level) for traceback information")
        self.pipe_handler.close()
        self._proc = None
1174704
async function handleError(error) {
    process.stderr.write('\n' + chalk.red.bold(error + '\n\n'));
    await help(args);
    return 1;
}
897337
def fail_with_error(self, err_msg, err_operation=None):
        ''''''
        if err_operation:
            err_msg = 'ERROR: "{err_msg}", while: {err_operation}'.format(
                err_msg=err_msg, err_operation=err_operation)
        sys.stderr.write(err_msg)
        sys.exit(1)
382477
function abort(options = {}) {
    if (process.platform !== 'win32' && process.platform !== 'linux') {
        throw new Error('Unsupported OS (only Windows and Linux are supported)!');
    }

    let cmdarguments = ['shutdown'];
    
    if (process.platform === 'win32') {
        cmdarguments.push('-a'); // abort
    } else {
        // linux
        cmdarguments.push('-c'); // cancel a pending shutdown
    }
    
    executeCmd(cmdarguments, options.debug, options.quitapp);
}
40256
def _excepthook(self, etype, evalue, trace):
        
        if etype == ArgumentParserError:
            self.exit(code=CRITICAL,
                      message='error: {0}'.format(evalue),
                      extdata=self.parser.format_usage())
        else:
            self.exit(code=UNKNOWN,
                      message='Uncaught exception: {0} - {1}'
                              .format(etype.__name__, evalue),
                      extdata=''.join(traceback.format_tb(trace)))
217378
function exit (status, ...messages) {
  if (messages) {
    messages.forEach(message => console.log(message))
  }

  process.exit(status)
}
4201
def _on_process_error(self, error):
        
        if self is None:
            return
        if error not in PROCESS_ERROR_STRING:
            error = -1
        if not self._prevent_logs:
            _logger().warning(PROCESS_ERROR_STRING[error])
666833
def exit(self, message):
        

        self.output(message, normal=True, color="green")
        sys.exit()
497865
def display_error_message(ex)
      trace "#{name} aborted!"
      trace ex.message
      if options.backtrace
        trace ex.backtrace.join("\n")
      else
        trace Backtrace.collapse(ex.backtrace).join("\n")
      end
      trace "Tasks: #{ex.chain}" if has_chain?(ex)
      trace "(See full trace by running task with --trace)" unless
        options.backtrace
    end
1017288
def stop_main_thread(*args):
    
    try:
        if len(args) and args[0] != _signal.SIGTERM:
            Log.warning("exit with {{value}}", value=_describe_exit_codes.get(args[0], args[0]))
    except Exception as _:
        pass
    finally:
        MAIN_THREAD.stop()
100689
private void abort(Error error) {
    try {
      if (mContext == null || mContext.getError() != null || mContext.isDoneUnsafe()) {
        // Note, we may reach here via events due to network errors bubbling up before
        // mContext is initialized, or stream error after the request is finished.
        return;
      }
      mContext.setError(error);
      cleanupRequest(mContext);
      replyError();
    } catch (Exception e) {
      LOG.warn("Failed to cleanup states with error {}.", e.getMessage());
    }
  }
1367193
def exit_with_error(msg):
    '''
    
    '''
    msg += '\n'
    msg += 'Local job workspaces can be found in: ' + str(environ.get('DX_TEST_JOB_HOMEDIRS'))
    sys.exit(msg)
425699
def _kill_process(self, pid, sig=signal.SIGKILL):
        """"""
        try:
            os.kill(pid, sig)
        except OSError as e:
            if e.errno == errno.ESRCH: # process itself returned and exited before killing
                logging.debug("Failure %s while killing process %s with signal %s: %s",
                              e.errno, pid, sig, e.strerror)
            else:
                logging.warning("Failure %s while killing process %s with signal %s: %s",
                                e.errno, pid, sig, e.strerror)
1090066
def exit(self):
        ''''''
        self.output.write("Happy hacking!")
        self.output.nextLine()
        self.output.loseConnection()
851328
def exit(self, status=0, message=None):
        '''
        
        '''
        self.exited = True
        self.status = status

        if message is not None:
            self.outp.printf(message)
        raise s_exc.ParserExit(mesg=message, status=status)