type statusError interface {
	Status() metav1.Status
}

// ErrorToAPIStatus converts an error to an metav1.Status object.
func ErrorToAPIStatus(err error) *metav1.Status {
	switch t := err.(type) {
	case statusError:
		status := t.Status()
		if len(status.Status) == 0 {
			status.Status = metav1.StatusFailure
		}
		switch status.Status {
		case metav1.StatusSuccess:

  void SetStatus(TF_Code code, const std::string& msg);

  // Status is movable, but not copyable.
  Status(Status&&) = default;
  Status& operator=(Status&&) = default;

 private:
  friend class RuntimeBuilder;
  friend class Runtime;
  friend class SavedModelAPI;
  friend class TensorHandle;

  // Wraps a TF_Status*, and takes ownership of it.
  explicit Status(TF_Status* status) : status_(status) {}

# Statuscodes

Sie können das Modul `status` von `fastapi` importieren:

```python
from fastapi import status
```

`status` wird direkt von Starlette bereitgestellt.

Es enthält eine Gruppe benannter Konstanten (Variablen) mit ganzzahligen Statuscodes.

Zum Beispiel:

* 200: `status.HTTP_200_OK`
* 403: `status.HTTP_403_FORBIDDEN`
* usw.

	logger := klog.FromContext(ctx)
	node := nodeInfo.Node()

	state, err := getStateData(cs)
	if err != nil {
		return framework.AsStatus(err)
	}

	podVolumes, reasons, err := pl.Binder.FindPodVolumes(logger, pod, state.podVolumeClaims, node)

	if err != nil {
		return framework.AsStatus(err)
	}

	if len(reasons) > 0 {

		status := istatus.(GenerationProvider)
		m.Status = status.Unwrap()
		_, err := store.UpdateStatus(*m)
		if err != nil {
			// TODO: need better error handling
			scope.Errorf("Encountered unexpected error updating status for %v, will try again later: %s", m, err)
			return
		}
	}
	retrieveFunc := func(resource Resource) *config.Config {

{
  "kind": "Status",
  "apiVersion": "resource.k8s.io/v1alpha2",
  "metadata": {
    "selfLink": "selfLinkValue",
    "resourceVersion": "resourceVersionValue",
    "continue": "continueValue",
    "remainingItemCount": 4
  },
  "status": "statusValue",
  "message": "messageValue",
  "reason": "reasonValue",
  "details": {
    "name": "nameValue",
    "group": "groupValue",
    "kind": "kindValue",
    "uid": "uidValue",

			return nil, framework.AsStatus(err)
		}
	}
	for i := range s.podInfo.RequiredAntiAffinityTerms {
		if err := pl.mergeAffinityTermNamespacesIfNotEmpty(&s.podInfo.RequiredAntiAffinityTerms[i]); err != nil {
			return nil, framework.AsStatus(err)
		}
	}
	logger := klog.FromContext(ctx)

	EvProcStart   // start of P [timestamp, P ID, P seq]
	EvProcStop    // stop of P [timestamp]
	EvProcSteal   // P was stolen [timestamp, P ID, P seq, M ID]
	EvProcStatus  // P status at the start of a generation [timestamp, P ID, status]

	// Goroutines.
	EvGoCreate            // goroutine creation [timestamp, new goroutine ID, new stack ID, stack ID]

	if programmed {
		conditions = append(conditions, metav1.Condition{
			Type:   string(gateway.GatewayConditionProgrammed),
			Status: kstatus.StatusTrue,
		})
	} else {
		conditions = append(conditions, metav1.Condition{
			Type:   string(gateway.GatewayConditionProgrammed),
			Status: kstatus.StatusFalse,
		})
	}
	className := "other"
	if isWaypoint {
		className = constants.WaypointGatewayClassName
	}

	nodeInfo, err := pl.sharedLister.NodeInfos().Get(nodeName)
	if err != nil {
		return 0, framework.AsStatus(fmt.Errorf("getting node %q from Snapshot: %w", nodeName, err))
	}

	node := nodeInfo.Node()
	s, err := getPreScoreState(cycleState)
	if err != nil {
		return 0, framework.AsStatus(err)
	}

	// Return if the node is not qualified.