Fetches the current status of this operation.
347839
public Operation<R, M> reload() throws SpannerException {
    if (isDone) {
      return this;
    }
    com.google.longrunning.Operation proto = rpc.getOperation(name);
    return Operation.<R, M>create(rpc, proto, parser);
  }
254283
def status()
            joinThread()
            lastconnerror = getCString()
            status = getCString()
            uptime = 0
            begin
                uptime_uint = MiniUPnP.new_uintp()
                r = MiniUPnP.UPNP_GetStatusInfo(@urls.controlURL,
                           @data.servicetype, status, uptime_uint,
                           lastconnerror)
                if r != 0 then
                    raise UPnPException.new, "Error while retriving status info. #{code2error(r)}."
                end
                uptime = MiniUPnP.uintp_value(uptime_uint)
            rescue
                raise
            ensure
                MiniUPnP.delete_uintp(uptime_uint)
            end
            return status.rstrip,lastconnerror.rstrip,uptime
        end
531917
public Status getStatus() {
        String status = m_resultFields.get(STATUS);
        if (status == null) {
            return Status.OK;
        } else {
            return Status.valueOf(status.toUpperCase());
        }
    }
1033785
def is_running(self):
        
        self.__update_status()
        return self.status == Status.UP or self.status == Status.DECOMMISSIONED
192338
def get_status(self):
        
        if self._value == 'loaded':
            status = 'loaded'

        elif not _is_server and self._bundle is not None and self._server_status is not None:
            if not _can_requests:
                raise ImportError("requests module required for external jobs")

            if self._value in ['complete']:
                # then we have no need to bother checking again
                status = self._value
            else:
                url = self._server_status
                logger.info("checking job status on server from {}".format(url))
                # "{}/{}/parameters/{}".format(server, bundleid, self.uniqueid)
                r = requests.get(url, timeout=5)
                try:
                    rjson = r.json()
                except ValueError:
                    # TODO: better exception here - perhaps look for the status code from the response?
                    status = self._value
                else:
                    status = rjson['data']['attributes']['value']

        else:

            if self.status_method == 'exists':
                output_exists = os.path.isfile("_{}.out".format(self.uniqueid))
                if output_exists:
                    status = 'complete'
                else:
                    status = 'unknown'
            else:
                raise NotImplementedError

        # here we'll set the value to be the latest CHECKED status for the sake
        # of exporting to JSON and updating the status for clients.  get_value
        # will still call status so that it will return the CURRENT value.
        self._value = status
        return status
469718
public function status()
    {
        $connection = $this->getDI()->get($this->migrationAdapter);

        $lastMig = $connection->fetchOne('SELECT * FROM migration ORDER BY id DESC', \PDO::FETCH_ASSOC);

        print PHP_EOL . Color::info('Current Version : ' . $lastMig['version']) . PHP_EOL;
    }
395195
public int getStatus() {
        if (ptm == null) {
            return TransactionManager.STATUS_NO_TRANSACTION;
        }

        // logger.debug( "Current TX name (According to TransactionSynchronizationManager) : " + TransactionSynchronizationManager.getCurrentTransactionName() );
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionStatus transaction = null;
            boolean commitNewTransaction = false;
            try {
                if (currentTransaction.isEmpty()) {
                    transaction = ptm.getTransaction(td);
                    currentTransaction.push(transaction);
                    commitNewTransaction = true;
                    if (transaction.isNewTransaction()) {
                        return TransactionManager.STATUS_COMMITTED;
                    }
                } else {
                    transaction = currentTransaction.peek();
                }
                logger.debug("Current TX: " + transaction);
                // If SynchronizationManager thinks it has an active transaction but
                // our transaction is a new one
                // then we must be in the middle of committing
                if (transaction.isCompleted()) {
                    if (transaction.isRollbackOnly()) {
                        return TransactionManager.STATUS_ROLLEDBACK;
                    }
                    return TransactionManager.STATUS_COMMITTED;
                } else {
                    if (transaction.isRollbackOnly()) {
                        return 5;
                    }
                    return TransactionManager.STATUS_ACTIVE;
                }
            } finally {
                if (commitNewTransaction) {
                    ptm.commit(transaction);
                }
            }
        }
        return TransactionManager.STATUS_NO_TRANSACTION;
    }
150188
private static Status getStatus(Throwable throwable) {
    Status status = Status.UNKNOWN;

    if (throwable instanceof StatusRuntimeException) {
      status = ((StatusRuntimeException) throwable).getStatus();
    } else if (throwable instanceof StatusException) {
      status = ((StatusException) throwable).getStatus();
    }
    return status;
  }
36071
def status(self, timeout=None):
        

        def run(txn):
            txn.execute("SELECT now()")
            rows = txn.fetchall()
            res = "{0}".format(rows[0][0])
            return res

        return self._pool.runInteraction(run)
677602
public function status()
    {
        if (is_null($this->status)) {
            $this->status = app(Status::class);
        }

        return $this->status;
    }
622296
public function getStatus()
    {
        switch (strtolower($this->request->status)) {
            case 'success':
                return self::STATUS_COMPLETED;

            case 'pending':
                return self::STATUS_PENDING;

            case 'failure':
                return self::STATUS_FAILED;

            default:
                return self::STATUS_FAILED;
        }
    }
634193
public STATUS getStatus() {
		if (featureContent.isLoaded()) {
			return STATUS.LOADED;
		}
		if (deferred == null) {
			return STATUS.EMPTY;
		}
		return STATUS.LOADING;
	}
955275
public com.google.api.ads.adwords.axis.v201809.billing.BudgetOrderRequestStatus getStatus() {
        return status;
    }
94671
public function getStatusDescription()
    {
        static $list = null;
        if ($list === null) {
            $list = static::getStatuses();
        }
        return (isset($list[$this->status])) ? $list[$this->status] : $this->status;
    }
134932
def GetStatusInformation(self):
    
    status = processing_status.TasksStatus()

    with self._lock:
      status.number_of_abandoned_tasks = len(self._tasks_abandoned)
      status.number_of_queued_tasks = len(self._tasks_queued)
      status.number_of_tasks_pending_merge = (
          len(self._tasks_pending_merge) + len(self._tasks_merging))
      status.number_of_tasks_processing = len(self._tasks_processing)
      status.total_number_of_tasks = self._total_number_of_tasks

    return status
992079
public function getStatus()
    {
        try {
            $this->returnSuccess((string) $this->getTaskEntity()->getStatus());
        } catch (\Exception $e) {
            $this->returnFailure($e);
        }
    }
521637
def getStatus(self):
    """"""
    command = '$GS'
    status = self.sendCommand(command)
    return states[int(status[1])]