---
updatedAt: 2026-08-21T16:12:58.000Z
agentTools:
  projectIndex: https://docs.rackspace.com/llms.txt
---

# Read the status of a Dataset

Returns the current `status` subresource of the Dataset.
The status is managed exclusively by the controller and cannot be updated by clients.


# OpenAPI definition

```json
{
  "openapi": "3.0.3",
  "info": {
    "title": "RackAI API",
    "description": "REST API for RackAI Custom Resources managed by the `rackai.rackspace.com` operator.\n\nMost requests are routed through the Kubernetes API server and authenticated\nwith a bearer token (service-account token or kubeconfig credential).\n\nOrganization management is the exception: tenants have no RBAC to edit the\n`Organization` custom resource directly, so those operations are served by the\norganizer service behind the Front Proxy and authenticated with an Auth0 OIDC\ntoken. See the **Organization** tag.\n\n**Base path:** `/apis/rackai.rackspace.com/v1alpha1`\n",
    "version": "v1alpha1",
    "contact": {
      "name": "Rackspace Spot Platform Engineering"
    }
  },
  "servers": [
    {
      "url": "https://{fqdn}/apis/rackai.rackspace.com/v1alpha1",
      "description": "API Server",
      "variables": {
        "fqdn": {
          "default": "localhost:6443",
          "description": "Fully-qualified domain name (and optional port) of the Front Proxy in front of the Kubernetes API server"
        }
      }
    }
  ],
  "security": [
    {
      "BearerToken": []
    }
  ],
  "tags": [
    {
      "name": "Dataset",
      "description": "Dataset represents a training or validation dataset within a namespace.\nIt supports \"text\" and \"messages\" formats and can optionally verify file\nintegrity via MD5 checksums. The storage path is inferred from the object's\nnamespace and name in SeaweedFS — no URI needs to be specified by the user.\nThe controller confirms file presence, lists files, and runs integrity checks."
    }
  ],
  "paths": {
    "/namespaces/{namespace}/datasets/{name}/status": {
      "parameters": [
        {
          "$ref": "#/components/parameters/namespace"
        },
        {
          "$ref": "#/components/parameters/name"
        }
      ],
      "get": {
        "tags": [
          "Dataset"
        ],
        "summary": "Read the status of a Dataset",
        "description": "Returns the current `status` subresource of the Dataset.\nThe status is managed exclusively by the controller and cannot be updated by clients.\n",
        "operationId": "readNamespacedDatasetStatus",
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Dataset"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        }
      }
    }
  },
  "components": {
    "securitySchemes": {
      "BearerToken": {
        "type": "http",
        "scheme": "bearer",
        "description": "Bearer token for the Kubernetes-extension API surface\n(`/apis/rackai.rackspace.com/v1alpha1/...`). Pass as\n`Authorization: Bearer <token>`.\n\nNote: for paths reached through the Front Proxy, the credential\npresented is an Auth0-issued OIDC bearer that the proxy validates\nand forwards to the upstream apiserver (which validates the same\ntoken via OIDC). A Kubernetes service-account token or kubeconfig\ncredential is what's typically used when hitting the apiserver\ndirectly (e.g. from inside the cluster).\n"
      }
    },
    "parameters": {
      "namespace": {
        "name": "namespace",
        "in": "path",
        "required": true,
        "description": "Kubernetes namespace of the resource.",
        "schema": {
          "type": "string"
        }
      },
      "name": {
        "name": "name",
        "in": "path",
        "required": true,
        "description": "Name of the resource.",
        "schema": {
          "type": "string"
        }
      }
    },
    "responses": {
      "Unauthorized": {
        "description": "Unauthorized — no or invalid bearer token provided."
      },
      "Forbidden": {
        "description": "Forbidden — the authenticated principal lacks permission."
      },
      "NotFound": {
        "description": "Not Found — the resource does not exist."
      }
    },
    "schemas": {
      "Dataset": {
        "description": "Dataset represents a training or validation dataset within a namespace.\nIt supports \"text\" and \"messages\" formats and can optionally verify file\nintegrity via MD5 checksums. The storage path is inferred from the object's\nnamespace and name in SeaweedFS — no URI needs to be specified by the user.\nThe controller confirms file presence, lists files, and runs integrity checks.",
        "properties": {
          "apiVersion": {
            "description": "APIVersion defines the versioned schema of this representation of an object.\nServers should convert recognized schemas to the latest internal value, and\nmay reject unrecognized values.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
            "type": "string",
            "example": "rackai.rackspace.com/v1alpha1"
          },
          "kind": {
            "description": "Kind is a string value representing the REST resource this object represents.\nServers may infer this from the endpoint the client submits requests to.\nCannot be updated.\nIn CamelCase.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
            "type": "string",
            "example": "Dataset"
          },
          "metadata": {
            "type": "object",
            "description": "metadata is a standard object metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
            "example": {
              "name": "alpaca-train",
              "namespace": "org-idxxxxxxxxxx"
            }
          },
          "spec": {
            "description": "spec defines the desired state of Dataset",
            "properties": {
              "description": {
                "description": "Description is a human-readable description of this resource.",
                "example": "Alpaca instruction-tuning dataset, training split.",
                "maxLength": 1024,
                "type": "string"
              },
              "displayName": {
                "description": "DisplayName is a short human-readable label for this resource. Distinct\nfrom metadata.name (which is the DNS-compatible identifier).",
                "example": "Alpaca Training Split",
                "maxLength": 128,
                "type": "string"
              },
              "format": {
                "description": "Format is the dataset format provided by the user.\nSupported values are \"text\" and \"messages\".",
                "enum": [
                  "text",
                  "messages"
                ],
                "example": "messages",
                "type": "string"
              },
              "integrity": {
                "description": "Integrity contains user-provided MD5 hashes for file integrity verification.\nIf specified, the controller checks each file's MD5 against the storage backend.",
                "properties": {
                  "md5": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "MD5 contains the expected hex-encoded MD5 hashes of files to be verified.\nKeys MUST be the full storage path as it appears in SeaweedFS, e.g.\n\"/datasets/<ns>/<name>/<rel>\". Basenames or relative paths are not\naccepted — the controller looks each key up verbatim in the observed\nstorage layout. The controller sets Ready=false with reason\nIntegrityCheckFailed on any mismatch.",
                    "type": "object"
                  }
                },
                "type": "object",
                "x-kubernetes-validations": [
                  {
                    "message": "Spec.Integrity.MD5 keys must be absolute storage paths starting with '/'",
                    "rule": "!has(self.md5) || self.md5.all(k, k.startsWith('/'))"
                  }
                ]
              }
            },
            "required": [
              "format"
            ],
            "type": "object"
          },
          "status": {
            "description": "status defines the observed state of Dataset",
            "properties": {
              "conditions": {
                "description": "conditions represent the current state of the Dataset resource.\nEach condition has a unique type and reflects the status of a specific aspect of the resource.\n\nThe status of each condition is one of True, False, or Unknown.",
                "items": {
                  "description": "Condition contains details for one aspect of the current state of this API Resource.",
                  "properties": {
                    "lastTransitionTime": {
                      "description": "lastTransitionTime is the last time the condition transitioned from one status to another.\nThis should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.",
                      "format": "date-time",
                      "type": "string"
                    },
                    "message": {
                      "description": "message is a human readable message indicating details about the transition.\nThis may be an empty string.",
                      "maxLength": 32768,
                      "type": "string"
                    },
                    "observedGeneration": {
                      "description": "observedGeneration represents the .metadata.generation that the condition was set based upon.\nFor instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date\nwith respect to the current state of the instance.",
                      "format": "int64",
                      "minimum": 0,
                      "type": "integer"
                    },
                    "reason": {
                      "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition.\nProducers of specific condition types may define expected values and meanings for this field,\nand whether the values are considered a guaranteed API.\nThe value should be a CamelCase string.\nThis field may not be empty.",
                      "maxLength": 1024,
                      "minLength": 1,
                      "pattern": "^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$",
                      "type": "string"
                    },
                    "status": {
                      "description": "status of the condition, one of True, False, Unknown.",
                      "enum": [
                        "True",
                        "False",
                        "Unknown"
                      ],
                      "type": "string"
                    },
                    "type": {
                      "description": "type of condition in CamelCase or in foo.example.com/CamelCase.",
                      "maxLength": 316,
                      "pattern": "^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$",
                      "type": "string"
                    }
                  },
                  "required": [
                    "lastTransitionTime",
                    "message",
                    "reason",
                    "status",
                    "type"
                  ],
                  "type": "object"
                },
                "type": "array",
                "x-kubernetes-list-map-keys": [
                  "type"
                ],
                "x-kubernetes-list-type": "map"
              },
              "file": {
                "description": "File is the path of the primary dataset file within the storage directory,\nwhen the dataset is a single file. Empty when the dataset is a directory tree.",
                "type": "string"
              },
              "files": {
                "description": "Files contains observed file info for the dataset, if available.",
                "items": {
                  "properties": {
                    "path": {
                      "type": "string"
                    },
                    "size": {
                      "format": "int64",
                      "type": "integer"
                    }
                  },
                  "type": "object"
                },
                "type": "array"
              },
              "integrity": {
                "description": "Integrity contains observed integrity information, if available.",
                "properties": {
                  "files": {
                    "additionalProperties": {
                      "description": "DatasetFileStatus holds the observed size and MD5 hash of a single file.",
                      "properties": {
                        "md5": {
                          "description": "MD5 is the hex-encoded MD5 hash of the file as observed from the storage backend.\nEmpty if the backend did not provide it.",
                          "type": "string"
                        },
                        "size": {
                          "description": "Size is the file size in bytes.",
                          "format": "int64",
                          "type": "integer"
                        }
                      },
                      "required": [
                        "size"
                      ],
                      "type": "object"
                    },
                    "description": "Files maps each file path to its observed size and MD5 hash.",
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "observedGeneration": {
                "description": "ObservedGeneration reflects the generation most recently observed by the controller.",
                "format": "int64",
                "type": "integer"
              },
              "phase": {
                "description": "Phase is a high-level summary of the dataset state.",
                "enum": [
                  "Pending",
                  "Processing",
                  "Ready",
                  "Failed"
                ],
                "type": "string"
              },
              "pvName": {
                "description": "PVName is the name of the PersistentVolume provisioned for this Dataset.",
                "type": "string"
              },
              "pvcName": {
                "description": "PVCName is the name of the PersistentVolumeClaim provisioned for this Dataset.",
                "type": "string"
              },
              "ready": {
                "description": "Ready indicates whether the Dataset files are present, accessible,\nand passing integrity checks (if configured).",
                "type": "boolean"
              },
              "storageRef": {
                "description": "StorageRef is the confirmed location of the dataset files in SeaweedFS,\npopulated by the controller after a successful existence check.",
                "properties": {
                  "inferredPath": {
                    "description": "InferredPath is the inferred base directory path in SeaweedFS,\ne.g. \"/my-namespace/my-datastore\".",
                    "type": "string"
                  }
                },
                "type": "object"
              }
            },
            "required": [
              "ready"
            ],
            "type": "object",
            "readOnly": true
          }
        },
        "required": [
          "spec"
        ],
        "type": "object"
      }
    }
  }
}
```