Mark the current coordinator as dead.
965462
def coordinator_dead(self, error):
        """"""
        if self.coordinator_id is not None:
            log.warning("Marking the coordinator dead (node %s) for group %s: %s.",
                        self.coordinator_id, self.group_id, error)
            self.coordinator_id = None
211791
public synchronized void kill() {
        if (oooProcess != null) {
            log.info("OOServer is killing office instance with port {}", port);
            List<Long> pids = processManager.findPid(host, port);
            processManager.kill(oooProcess, pids);
            oooProcess = null;
        }
    }
254197
def coordinator(self):
        
        if self.coordinator_id is None:
            return None
        elif self._client.is_disconnected(self.coordinator_id):
            self.coordinator_dead('Node Disconnected')
            return None
        else:
            return self.coordinator_id
729422
function setCursorDeadAndNotified(cursor, callback) {
  cursor.s.dead = true;
  setCursorNotified(cursor, callback);
}
686254
def stop():
    '''
    '''
    global _active
    if not _active:
        msg = 'lazarus is not active'
        raise RuntimeWarning(msg)
    _observer.stop()
    _observer.join()
    _deactivate()
478239
def on_shutdown(self, broker):
        """"""
        _v and LOG.debug('%r.on_shutdown(%r)', self, broker)
        fire(self, 'shutdown')
        for handle, (persist, fn) in self._handle_map.iteritems():
            _v and LOG.debug('%r.on_shutdown(): killing %r: %r', self, handle, fn)
            fn(Message.dead(self.broker_shutdown_msg))
1242934
public void kill() {
    if (isComplete() || failed) {
      return;
    }
    this.failed = true;
    killed = true;
    this.execFinishTime = JobTracker.getClock().getTime();
    recomputeProgress();
  }
27401
function(self, callback) {
  // Cursor is dead but not marked killed, return null
  if (self.cursorState.dead && !self.cursorState.killed) {
    self.cursorState.killed = true;
    setCursorNotified(self, callback);
    return true;
  }

  return false;
}
84471
function(worker) {
      var data = getWorkerNamespacedData(worker);

      Object.keys(data.pending).forEach(function(seqNum) {
        var item = data.pending[seqNum];
        delete data.pending[seqNum];
        if (item[0].monitored) {
          item[1](new Error("Undeliverable message: worker died before we could get acknowledgement"));
        }
      });
    }
9533
private void updateDagStatusInternal(final boolean failed) {
    if (this.status == Status.KILLING) {
      /*
      It's possible that some nodes have failed when the dag is killed.
      Since killing a dag signals an intent from an operator, it is more important to make
      the dag status reflect the result of that explict intent. e.g. if the killing is a
      result of handing a job failure, users more likely want to know that someone has taken
      an action rather than that a job has failed. Operators can still see the individual job
      status.
      */
      changeStatus(Status.KILLED);
    } else if (failed) {
      changeStatus(Status.FAILURE);
    } else {
      changeStatus(Status.SUCCESS);
    }
  }
1261908
function isCursorDeadAndKilled(cursor, callback) {
  if (cursor.s.dead && cursor.s.killed) {
    handleCallback(callback, new MongoError('cursor is dead'));
    return true;
  }

  return false;
}
1209674
def finalize(self):
        """"""
        if self.total_instances > 1:
            print('{} of {} instances contained dead code.'
                  .format(self.dead_code_instances, self.total_instances))
446691
def __die(self, synchronous=False):
        
        already_killed = self.__killed
        self.__killed = True
        if self.__id and not already_killed:
            address = _CursorAddress(
                self.__address, self.__collection.full_name)
            if synchronous:
                self.__collection.database.client._close_cursor_now(
                    self.__id, address, session=self.__session)
            else:
                # The cursor will be closed later in a different session.
                self.__collection.database.client._close_cursor(
                    self.__id, address)
        self.__end_session(synchronous)
1245895
def finish_and_die(self):
        
        self.logstate('finish_and_die')
        self.stop_working_on_queue()
        if self.jobphase != 'pending_request':
            self.stopFactory()
1085766
def mark_dead(self, connection):
        
        # mark as dead even when sniffing to avoid hitting this host during the sniff process
        self.connection_pool.mark_dead(connection)
        if self.sniff_on_connection_fail:
            self.sniff_hosts()
860089
@Override
    public void die(String reason) {
	log.info("[die] Robot {} died with reason: {}", serialNumber, reason);
	if (alive) { // if not alive it means it was killed at creation
	    alive = false;
	    interrupted = true; // to speed up death
	    world.remove(Robot.this);
	}

    }
137864
def kill(self):
        """"""
        if not self.is_dead():
            self.bundle_engine.warnline("{0} did not shut down cleanly, killing.".format(self.service.name))
            try:
                if hasattr(self.process, 'pid'):
                    for child in psutil.Process(self.process.pid).children(recursive=True):
                        os.kill(child.pid, signal.SIGKILL)
                    self.process.kill()
            except psutil.NoSuchProcess:
                pass