// Status returns the status of the model.
180754
func (m *Model) Status() (status.StatusInfo, error) {
	modelStatus, err := getStatus(m.st.db(), m.globalKey(), "model")
	if err != nil {
		return modelStatus, err
	}
	return modelStatus, nil
}
384328
func (p *Init) Status(ctx context.Context) (string, error) {
	p.mu.Lock()
	defer p.mu.Unlock()

	c, err := p.runtime.State(ctx, p.id)
	if err != nil {
		if strings.Contains(err.Error(), "does not exist") {
			return "stopped", nil
		}
		return "", p.runtimeError(err, "OCI runtime state failed")
	}
	return c.Status, nil
}
329024
func (linux *systemDRecord) Status() (string, error) {

	if ok, err := checkPrivileges(); !ok {
		return "", err
	}

	if !linux.isInstalled() {
		return "Status could not defined", ErrNotInstalled
	}

	statusAction, _ := linux.checkRunning()

	return statusAction, nil
}
1368651
func (pattern *Pattern) status() error {
	ret := Status(C.cairo_pattern_status(pattern.Ptr)).toError()
	return ret
}
248463
func (surface *Surface) status() error {
	ret := Status(C.cairo_surface_status(surface.Ptr)).toError()
	return ret
}
1113764
func (r *AnalyticsDeferredResultHandle) Status() (string, error) {
	req := &gocbcore.HttpRequest{
		Service:  gocbcore.CbasService,
		Endpoint: r.handleUri,
		Method:   "GET",
	}

	var resp *analyticsResponseHandle
	err := r.executeHandle(req, &resp)
	if err != nil {
		return "", err
	}

	r.status = resp.Status
	if r.status == "success" {
		r.handleUri = resp.Handle
	}
	return r.status, nil
}
1067241
func (lxd *lxdInstance) Status(ctx context.ProviderCallContext) instance.Status {
	jujuStatus := status.Pending
	instStatus, _, err := lxd.server.GetContainerState(lxd.id)
	if err != nil {
		return instance.Status{
			Status:  status.Empty,
			Message: fmt.Sprintf("could not get status: %v", err),
		}
	}
	switch instStatus.StatusCode {
	case api.Starting, api.Started:
		jujuStatus = status.Allocating
	case api.Running:
		jujuStatus = status.Running
	case api.Freezing, api.Frozen, api.Thawed, api.Stopping, api.Stopped:
		jujuStatus = status.Empty
	default:
		jujuStatus = status.Empty
	}
	return instance.Status{
		Status:  jujuStatus,
		Message: instStatus.Status,
	}
}
255534
func (s *PublicTxPoolAPI) Status() map[string]hexutil.Uint {
	pending, queue := s.b.Stats()
	return map[string]hexutil.Uint{
		"pending": hexutil.Uint(pending),
		"queued":  hexutil.Uint(queue),
	}
}
752085
func (cr *Context) status() error {
	ret := Status(C.cairo_status(cr.Ptr)).toError()
	return ret
}
1269701
func (s *SQL) Status() (interface{}, error) {
	if err := validateSQLConfig(s.Config); err != nil {
		return nil, err
	}

	switch {
	// check for SQLExecer first
	case s.Config.Execer != nil:
		// if the result handler is nil, use the default
		if s.Config.ExecerResultHandler == nil {
			s.Config.ExecerResultHandler = DefaultExecHandler
		}
		// run the execer
		return s.runExecer()
	// check for SQLQueryer next
	case s.Config.Queryer != nil:
		// if the result handler is nil, use the default
		if s.Config.QueryerResultHandler == nil {
			s.Config.QueryerResultHandler = DefaultQueryHandler
		}
		// run the queryer
		return s.runQueryer()
	// finally, must be a pinger
	default:
		ctx := context.Background()
		return nil, s.Config.Pinger.PingContext(ctx)
	}
}
754789
func (w *trezorDriver) Status() (string, error) {
	if w.failure != nil {
		return fmt.Sprintf("Failed: %v", w.failure), w.failure
	}
	if w.device == nil {
		return "Closed", w.failure
	}
	if w.pinwait {
		return fmt.Sprintf("Trezor v%d.%d.%d '%s' waiting for PIN", w.version[0], w.version[1], w.version[2], w.label), w.failure
	}
	return fmt.Sprintf("Trezor v%d.%d.%d '%s' online", w.version[0], w.version[1], w.version[2], w.label), w.failure
}
128034
func (o *ociInstance) Status(ctx envcontext.ProviderCallContext) instance.Status {
	if err := o.refresh(); err != nil {
		common.HandleCredentialError(err, ctx)
		return instance.Status{}
	}
	state, ok := statusMap[o.raw.LifecycleState]
	if !ok {
		state = status.Unknown
	}
	return instance.Status{
		Status:  state,
		Message: strings.ToLower(string(o.raw.LifecycleState)),
	}
}
768388
func (s *Server) Status(ctx context.Context,
	in *StatusRequest) (*StatusResponse, error) {

	return &StatusResponse{
		Active: s.manager.IsActive(),
	}, nil
}
142344
func (c *customCheck) Status() (interface{}, error) {
	// perform some sort of check
	if false {
		return nil, fmt.Errorf("Something major just broke")
	}

	// You can return additional information pertaining to the check as long
	// as it can be JSON marshalled
	return map[string]int{"foo": 123, "bar": 456}, nil
}
929759
func (c *Client) Status(patterns []string) (*params.FullStatus, error) {
	var result params.FullStatus
	p := params.StatusParams{Patterns: patterns}
	if err := c.facade.FacadeCall("FullStatus", p, &result); err != nil {
		return nil, err
	}
	// Older servers don't fill out model type, but
	// we know a missing type is an "iaas" model.
	if result.Model.Type == "" {
		result.Model.Type = model.IAAS.String()
	}
	return &result, nil
}
210679
func (c *criClient) Status() *models.Status {
	if c == nil {
		return &models.Status{State: models.StatusStateDisabled}
	}

	sreq := &criRuntime.StatusRequest{
		Verbose: false,
	}
	sresp, err := c.RuntimeServiceClient.Status(context.Background(), sreq)
	if err != nil {
		return &models.Status{State: models.StatusStateFailure, Msg: err.Error()}
	}
	for _, runtimeCondition := range sresp.Status.Conditions {
		if !runtimeCondition.Status {
			return &models.Status{State: models.StatusStateFailure, Msg: runtimeCondition.Message}
		}

	}
	return &models.Status{State: models.StatusStateOk, Msg: "cri daemon: Ok"}
}
1103566
func (client *Client) Status(handle string) (status *Status, err error) {
	if client.conn == nil {
		return nil, ErrLostConn
	}
	var mutex sync.Mutex
	mutex.Lock()
	client.innerHandler.put("s"+handle, func(resp *Response) {
		defer mutex.Unlock()
		var err error
		status, err = resp._status()
		if err != nil {
			client.err(err)
		}
	})
	req := getRequest()
	req.DataType = dtGetStatus
	req.Data = []byte(handle)
	client.write(req)
	mutex.Lock()
	return
}