resource

type AllocationMode string

type AllocationResult struct {
	// ResourceHandles contain the state associated with an allocation that
	// should be maintained throughout the lifetime of a claim. Each
	// ResourceHandle contains data that should be passed to a specific kubelet
	// plugin once it lands on a node. This data is returned by the driver
	// after a successful allocation and is opaque to Kubernetes. Driver
	// documentation may explain to users how to interpret this data if needed.
	//
	// Setting this field is optional. It has a maximum size of 32 entries.
	// If null (or empty), it is assumed this allocation will be processed by a
	// single kubelet plugin with no ResourceHandle data attached. The name of
	// the kubelet plugin invoked will match the DriverName set in the
	// ResourceClaimStatus this AllocationResult is embedded in.
	//
	// +listType=atomic
	// +optional
	ResourceHandles []ResourceHandle

	// This field will get set by the resource driver after it has allocated
	// the resource to inform the scheduler where it can schedule Pods using
	// the ResourceClaim.
	//
	// Setting this field is optional. If null, the resource is available
	// everywhere.
	// +optional
	AvailableOnNodes *core.NodeSelector

	// Shareable determines whether the resource supports more
	// than one consumer at a time.
	// +optional
	Shareable bool
}

type AllocationResultModel struct {
	// NamedResources describes the allocation result when using the named resources model.
	NamedResources *NamedResourcesAllocationResult
}

type DriverAllocationResult struct {
	// VendorRequestParameters are the per-request configuration parameters
	// from the time that the claim was allocated.
	VendorRequestParameters runtime.Object

	AllocationResultModel
}

type DriverRequests struct {
	// DriverName is the name used by the DRA driver kubelet plugin.
	DriverName string

	// VendorParameters are arbitrary setup parameters for all requests of the
	// claim. They are ignored while allocating the claim.
	VendorParameters runtime.Object

	// Requests describes all resources that are needed from the driver.
	Requests []ResourceRequest
}

type NamedResourcesAllocationResult struct {
	// Name is the name of the selected resource instance.
	Name string
}

type NamedResourcesAttribute struct {
	// Name is unique identifier among all resource instances managed by
	// the driver on the node. It must be a DNS subdomain.
	Name string

	NamedResourcesAttributeValue
}

type NamedResourcesAttributeValue struct {
	// QuantityValue is a quantity.
	QuantityValue *resource.Quantity
	// BoolValue is a true/false value.
	BoolValue *bool
	// IntValue is a 64-bit integer.
	IntValue *int64
	// IntSliceValue is an array of 64-bit integers.
	IntSliceValue *NamedResourcesIntSlice
	// StringValue is a string.
	StringValue *string
	// StringSliceValue is an array of strings.
	StringSliceValue *NamedResourcesStringSlice
	// VersionValue is a semantic version according to semver.org spec 2.0.0.
	VersionValue *string
}

type NamedResourcesFilter struct {
	// Selector is a selector like the one in Request. It must be true for
	// a resource instance to be suitable for a claim using the class.
	Selector string
}

type NamedResourcesInstance struct {
	// Name is unique identifier among all resource instances managed by
	// the driver on the node. It must be a DNS subdomain.
	Name string

	// Attributes defines the attributes of this resource instance.
	// The name of each attribute must be unique.
	Attributes []NamedResourcesAttribute
}

type NamedResourcesIntSlice struct {
	// Ints is the slice of 64-bit integers.
	Ints []int64
}

type NamedResourcesRequest struct {
	// Selector is a CEL expression which must evaluate to true if a
	// resource instance is suitable. The language is as defined in
	// https://kubernetes.io/docs/reference/using-api/cel/
	//
	// In addition, for each type NamedResourcesin AttributeValue there is a map that
	// resolves to the corresponding value of the instance under evaluation.
	// For example:
	//
	//    attributes.quantity["a"].isGreaterThan(quantity("0")) &&
	//    attributes.stringslice["b"].isSorted()
	Selector string
}

type NamedResourcesResources struct {
	// The list of all individual resources instances currently available.
	Instances []NamedResourcesInstance
}

type NamedResourcesStringSlice struct {
	// Strings is the slice of strings.
	Strings []string
}

type PodSchedulingContext struct {
	metav1.TypeMeta
	// Standard object metadata
	// +optional
	metav1.ObjectMeta

	// Spec describes where resources for the Pod are needed.
	Spec PodSchedulingContextSpec

	// Status describes where resources for the Pod can be allocated.
	Status PodSchedulingContextStatus
}

type PodSchedulingContextList struct {
	metav1.TypeMeta
	// Standard list metadata
	// +optional
	metav1.ListMeta

	// Items is the list of PodSchedulingContext objects.
	Items []PodSchedulingContext
}

type PodSchedulingContextSpec struct {
	// SelectedNode is the node for which allocation of ResourceClaims that
	// are referenced by the Pod and that use "WaitForFirstConsumer"
	// allocation is to be attempted.
	SelectedNode string

	// PotentialNodes lists nodes where the Pod might be able to run.
	//
	// The size of this field is limited to 128. This is large enough for
	// many clusters. Larger clusters may need more attempts to find a node
	// that suits all pending resources. This may get increased in the
	// future, but not reduced.
	// +optional
	PotentialNodes []string
}

type PodSchedulingContextStatus struct {
	// ResourceClaims describes resource availability for each
	// pod.spec.resourceClaim entry where the corresponding ResourceClaim
	// uses "WaitForFirstConsumer" allocation mode.
	// +optional
	ResourceClaims []ResourceClaimSchedulingStatus
}

type ResourceClaim struct {
	metav1.TypeMeta
	// Standard object metadata
	// +optional
	metav1.ObjectMeta

	// Spec describes the desired attributes of a resource that then needs
	// to be allocated. It can only be set once when creating the
	// ResourceClaim.
	Spec ResourceClaimSpec

	// Status describes whether the resource is available and with which
	// attributes.
	// +optional
	Status ResourceClaimStatus
}

type ResourceClaimConsumerReference struct {
	// APIGroup is the group for the resource being referenced. It is
	// empty for the core API. This matches the group in the APIVersion
	// that is used when creating the resources.
	// +optional
	APIGroup string
	// Resource is the type of resource being referenced, for example "pods".
	Resource string
	// Name is the name of resource being referenced.
	Name string
	// UID identifies exactly one incarnation of the resource.
	UID types.UID
}

type ResourceClaimList struct {
	metav1.TypeMeta
	// Standard list metadata
	// +optional
	metav1.ListMeta

	// Items is the list of resource claims.
	Items []ResourceClaim
}

type ResourceClaimParameters struct {
	metav1.TypeMeta
	// Standard object metadata
	metav1.ObjectMeta

	// If this object was created from some other resource, then this links
	// back to that resource. This field is used to find the in-tree representation
	// of the claim parameters when the parameter reference of the claim refers
	// to some unknown type.
	GeneratedFrom *ResourceClaimParametersReference

	// Shareable indicates whether the allocated claim is meant to be shareable
	// by multiple consumers at the same time.
	Shareable bool

	// DriverRequests describes all resources that are needed for the
	// allocated claim. A single claim may use resources coming from
	// different drivers. For each driver, this array has at most one
	// entry which then may have one or more per-driver requests.
	//
	// May be empty, in which case the claim can always be allocated.
	DriverRequests []DriverRequests
}

type ResourceClaimParametersList struct {
	metav1.TypeMeta
	// Standard list metadata
	metav1.ListMeta

	// Items is the list of node resource capacity objects.
	Items []ResourceClaimParameters
}

type ResourceClaimParametersReference struct {
	// APIGroup is the group for the resource being referenced. It is
	// empty for the core API. This matches the group in the APIVersion
	// that is used when creating the resources.
	// +optional
	APIGroup string
	// Kind is the type of resource being referenced. This is the same
	// value as in the parameter object's metadata, for example "ConfigMap".
	Kind string
	// Name is the name of resource being referenced.
	Name string
}

type ResourceClaimSchedulingStatus struct {
	// Name matches the pod.spec.resourceClaims[*].Name field.
	Name string

	// UnsuitableNodes lists nodes that the ResourceClaim cannot be
	// allocated for.
	//
	// The size of this field is limited to 128, the same as for
	// PodSchedulingSpec.PotentialNodes. This may get increased in the
	// future, but not reduced.
	// +optional
	UnsuitableNodes []string
}

type ResourceClaimSpec struct {
	// ResourceClassName references the driver and additional parameters
	// via the name of a ResourceClass that was created as part of the
	// driver deployment.
	ResourceClassName string

	// ParametersRef references a separate object with arbitrary parameters
	// that will be used by the driver when allocating a resource for the
	// claim.
	//
	// The object must be in the same namespace as the ResourceClaim.
	// +optional
	ParametersRef *ResourceClaimParametersReference

	// Allocation can start immediately or when a Pod wants to use the
	// resource. "WaitForFirstConsumer" is the default.
	// +optional
	AllocationMode AllocationMode
}

type ResourceClaimStatus struct {
	// DriverName is a copy of the driver name from the ResourceClass at
	// the time when allocation started.
	// +optional
	DriverName string

	// Allocation is set by the resource driver once a resource or set of
	// resources has been allocated successfully. If this is not specified, the
	// resources have not been allocated yet.
	// +optional
	Allocation *AllocationResult

	// ReservedFor indicates which entities are currently allowed to use
	// the claim. A Pod which references a ResourceClaim which is not
	// reserved for that Pod will not be started.
	//
	// There can be at most 32 such reservations. This may get increased in
	// the future, but not reduced.
	// +optional
	ReservedFor []ResourceClaimConsumerReference

	// DeallocationRequested indicates that a ResourceClaim is to be
	// deallocated.
	//
	// The driver then must deallocate this claim and reset the field
	// together with clearing the Allocation field.
	//
	// While DeallocationRequested is set, no new consumers may be added to
	// ReservedFor.
	// +optional
	DeallocationRequested bool
}

type ResourceClaimTemplate struct {
	metav1.TypeMeta
	// Standard object metadata
	// +optional
	metav1.ObjectMeta

	// Describes the ResourceClaim that is to be generated.
	//
	// This field is immutable. A ResourceClaim will get created by the
	// control plane for a Pod when needed and then not get updated
	// anymore.
	Spec ResourceClaimTemplateSpec
}

type ResourceClaimTemplateList struct {
	metav1.TypeMeta
	// Standard list metadata
	// +optional
	metav1.ListMeta

	// Items is the list of resource claim templates.
	Items []ResourceClaimTemplate
}

type ResourceClaimTemplateSpec struct {
	// ObjectMeta may contain labels and annotations that will be copied into the PVC
	// when creating it. No other fields are allowed and will be rejected during
	// validation.
	// +optional
	metav1.ObjectMeta

	// Spec for the ResourceClaim. The entire content is copied unchanged
	// into the ResourceClaim that gets created from this template. The
	// same fields as in a ResourceClaim are also valid here.
	Spec ResourceClaimSpec
}

type ResourceClass struct {
	metav1.TypeMeta
	// Standard object metadata
	// +optional
	metav1.ObjectMeta

	// DriverName defines the name of the dynamic resource driver that is
	// used for allocation of a ResourceClaim that uses this class.
	//
	// Resource drivers have a unique name in forward domain order
	// (acme.example.com).
	DriverName string

	// ParametersRef references an arbitrary separate object that may hold
	// parameters that will be used by the driver when allocating a
	// resource that uses this class. A dynamic resource driver can
	// distinguish between parameters stored here and and those stored in
	// ResourceClaimSpec.
	// +optional
	ParametersRef *ResourceClassParametersReference

	// Only nodes matching the selector will be considered by the scheduler
	// when trying to find a Node that fits a Pod when that Pod uses
	// a ResourceClaim that has not been allocated yet.
	//
	// Setting this field is optional. If null, all nodes are candidates.
	// +optional
	SuitableNodes *core.NodeSelector

	// If and only if allocation of claims using this class is handled
	// via structured parameters, then StructuredParameters must be set to true.
	StructuredParameters *bool
}

type ResourceClassList struct {
	metav1.TypeMeta
	// Standard list metadata
	// +optional
	metav1.ListMeta

	// Items is the list of resource classes.
	Items []ResourceClass
}

type ResourceClassParameters struct {
	metav1.TypeMeta
	// Standard object metadata
	metav1.ObjectMeta

	// If this object was created from some other resource, then this links
	// back to that resource. This field is used to find the in-tree representation
	// of the class parameters when the parameter reference of the class refers
	// to some unknown type.
	GeneratedFrom *ResourceClassParametersReference

	// VendorParameters are arbitrary setup parameters for all claims using
	// this class. They are ignored while allocating the claim. There must
	// not be more than one entry per driver.
	VendorParameters []VendorParameters

	// Filters describes additional contraints that must be met when using the class.
	Filters []ResourceFilter
}

type ResourceClassParametersList struct {
	metav1.TypeMeta
	// Standard list metadata
	metav1.ListMeta

	// Items is the list of node resource capacity objects.
	Items []ResourceClassParameters
}

type ResourceClassParametersReference struct {
	// APIGroup is the group for the resource being referenced. It is
	// empty for the core API. This matches the group in the APIVersion
	// that is used when creating the resources.
	// +optional
	APIGroup string
	// Kind is the type of resource being referenced. This is the same
	// value as in the parameter object's metadata.
	Kind string
	// Name is the name of resource being referenced.
	Name string
	// Namespace that contains the referenced resource. Must be empty
	// for cluster-scoped resources and non-empty for namespaced
	// resources.
	// +optional
	Namespace string
}

type ResourceFilter struct {
	// DriverName is the name used by the DRA driver kubelet plugin.
	DriverName string

	ResourceFilterModel
}

type ResourceFilterModel struct {
	// NamedResources describes a resource filter using the named resources model.
	NamedResources *NamedResourcesFilter
}

type ResourceHandle struct {
	// DriverName specifies the name of the resource driver whose kubelet
	// plugin should be invoked to process this ResourceHandle's data once it
	// lands on a node. This may differ from the DriverName set in
	// ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName string

	// Data contains the opaque data associated with this ResourceHandle. It is
	// set by the controller component of the resource driver whose name
	// matches the DriverName set in the ResourceClaimStatus this
	// ResourceHandle is embedded in. It is set at allocation time and is
	// intended for processing by the kubelet plugin whose name matches
	// the DriverName set in this ResourceHandle.
	//
	// The maximum size of this field is 16KiB. This may get increased in the
	// future, but not reduced.
	// +optional
	Data string

	// If StructuredData is set, then it needs to be used instead of Data.
	StructuredData *StructuredResourceHandle
}

type ResourceModel struct {
	// NamedResources describes available resources using the named resources model.
	NamedResources *NamedResourcesResources
}

type ResourceRequest struct {
	// VendorParameters are arbitrary setup parameters for the requested
	// resource. They are ignored while allocating a claim.
	VendorParameters runtime.Object

	ResourceRequestModel
}

type ResourceRequestModel struct {
	// NamedResources describes a request for resources with the named resources model.
	NamedResources *NamedResourcesRequest
}

type ResourceSlice struct {
	metav1.TypeMeta
	// Standard object metadata
	metav1.ObjectMeta

	// NodeName identifies the node which provides the resources
	// if they are local to a node.
	//
	// A field selector can be used to list only ResourceSlice
	// objects with a certain node name.
	NodeName string

	// DriverName identifies the DRA driver providing the capacity information.
	// A field selector can be used to list only ResourceSlice
	// objects with a certain driver name.
	DriverName string

	ResourceModel
}

type ResourceSliceList struct {
	metav1.TypeMeta
	// Standard list metadata
	metav1.ListMeta

	// Items is the list of node resource capacity objects.
	Items []ResourceSlice
}

type StructuredResourceHandle struct {
	// VendorClassParameters are the per-claim configuration parameters
	// from the resource class at the time that the claim was allocated.
	VendorClassParameters runtime.Object

	// VendorClaimParameters are the per-claim configuration parameters
	// from the resource claim parameters at the time that the claim was
	// allocated.
	VendorClaimParameters runtime.Object

	// NodeName is the name of the node providing the necessary resources
	// if the resources are local to a node.
	NodeName string

	// Results lists all allocated driver resources.
	Results []DriverAllocationResult
}

type VendorParameters struct {
	// DriverName is the name used by the DRA driver kubelet plugin.
	DriverName string

	// Parameters can be arbitrary setup parameters. They are ignored while
	// allocating a claim.
	Parameters runtime.Object
}