CM SERVICE ABORT Section 9.2.7
353025
def cmServiceAbort():
    """"""
    a = TpPd(pd=0x5)
    b = MessageType(mesType=0x23)  # 00100011
    packet = a / b
    return packet
1353825
def external_aborted(self, params):
        
        self.ended = True
        self.running = False

        # When the server sends an abort signal, we really have to close immediately,
        # since for example the job has been already deleted.
        # without touching the git and client any further
        os._exit(1)
718717
def cli(env, identifier, immediate, comment, reason):
    """"""

    mgr = SoftLayer.HardwareManager(env.client)
    hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware')

    if not (env.skip_confirmations or formatting.no_going_back(hw_id)):
        raise exceptions.CLIAbort('Aborted')

    mgr.cancel_hardware(hw_id, reason, comment, immediate)
1041498
def SignalAbort(self):
    """"""
    self._abort = True
    if self._foreman_status_wait_event:
      self._foreman_status_wait_event.set()
    if self._analysis_mediator:
      self._analysis_mediator.SignalAbort()
1272550
public TaskServiceResponse abortTaskSet(Nexus nexus)
   {
      try
      {
         this.taskSet.abort(nexus);
         return TaskServiceResponse.FUNCTION_COMPLETE;
      }
      catch (InterruptedException e)
      {
         return TaskServiceResponse.SERVICE_DELIVERY_OR_TARGET_FAILURE;
      }
      catch (IllegalArgumentException e)
      {
         throw e;
      }
   }
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)
869958
function abortSuite() {
      var event,
          suite = this,
          resetting = calledBy.resetSuite;

      if (suite.running) {
        event = Event('abort');
        suite.emit(event);
        if (!event.cancelled || resetting) {
          // Avoid infinite recursion.
          calledBy.abortSuite = true;
          suite.reset();
          delete calledBy.abortSuite;

          if (!resetting) {
            suite.aborted = true;
            invoke(suite, 'abort');
          }
        }
      }
      return suite;
    }
329957
def abort
      line = "ABOR" + CRLF
      print "put: ABOR\n" if @debug_mode
      @sock.send(line, Socket::MSG_OOB)
      resp = getmultiline
      unless ["426", "226", "225"].include?(resp[0, 3])
        raise FTPProtoError, resp
      end
      return resp
    end
902710
function apimpull(opts, cb) {
  var options = {
    host: opts.host || '127.0.0.1',
    port: opts.port || 443, // assume SSL
    timeout: opts.timeout * 1000 || 30 * 1000,
    srvca: opts.srvca ? opts.srvca : null,
    clikey: opts.clikey ? opts.clikey : null,
    clipass: opts.clipass,
    clicert: opts.clicert ? opts.clicert : null,
    indir: opts.indir,
    outdir: opts.outdir || 'apim',
    clientid: opts.clientid || '1111-1111' };

  if (opts.indir) {
    try {
      indirFiles = fs.readdirSync(opts.indir);
    } catch (e) {
      logger.info(e);
      // not fatal; continue
    }
  }

  /* First, start w/ catalogs */
  pullcatalog(options, function(err, catalogs, models) {
    if (err) {
      cb(err, response);
    } else if (typeof catalogs !== 'undefined') {
      getDataBasedOnCatalog(options, catalogs, models, cb);
    } else {
      cb(null, response);
    }
  });
}
1188196
function abortSuite() {
    var event,
        me = this,
        resetting = calledBy.resetSuite;

    if (me.running) {
      event = Event('abort');
      me.emit(event);
      if (!event.cancelled || resetting) {
        // avoid infinite recursion
        calledBy.abortSuite = true;
        me.reset();
        delete calledBy.abortSuite;

        if (!resetting) {
          me.aborted = true;
          invoke(me, 'abort');
        }
      }
    }
    return me;
  }
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()
729609
async def abort(self, *, comment: str = None):
        
        params = {
            "system_id": self.system_id
        }
        if comment:
            params["comment"] = comment
        self._data = await self._handler.abort(**params)
        return self
332079
def stop_service(conn, service='ceph'):
    
    if is_systemd(conn):
        # Without the check, an error is raised trying to stop an
        # already stopped service
        if is_systemd_service_active(conn, service):
            remoto.process.run(
                conn,
                [
                    'systemctl',
                    'stop',
                    '{service}'.format(service=service),
                ]
            )
579022
def abort_now ():
    """"""
    if os.name == 'posix':
        # Unix systems can use signals
        import signal
        os.kill(os.getpid(), signal.SIGTERM)
        time.sleep(1)
        os.kill(os.getpid(), signal.SIGKILL)
    elif os.name == 'nt':
        # NT has os.abort()
        os.abort()
    else:
        # All other systems have os._exit() as best shot.
        os._exit(3)
1037532
def abort(self):
        
        if (self.reply and self.reply.isRunning()):
            self.on_abort = True
            self.reply.abort()
1354118
def abort(self):
        
        self._coll.chunks.delete_many(
            {"files_id": self._file['_id']}, session=self._session)
        self._coll.files.delete_one(
            {"_id": self._file['_id']}, session=self._session)
        object.__setattr__(self, "_closed", True)
48880
protected void cancelReplace() {

        m_canceled = true;
        if (m_progressInfo != null) {
            cancelUpdateProgress();
            CmsRpcAction<Boolean> callback = new CmsRpcAction<Boolean>() {

                /**
                 * @see org.opencms.gwt.client.rpc.CmsRpcAction#execute()
                 */
                @Override
                public void execute() {

                    getUploadService().cancelUpload(this);
                }

                /**
                 * @see org.opencms.gwt.client.rpc.CmsRpcAction#onResponse(java.lang.Object)
                 */
                @Override
                protected void onResponse(Boolean result) {

                    hide();
                }
            };
            callback.execute();
        } else {
            hide();
        }
    }