1131 lines
57 KiB
Go
1131 lines
57 KiB
Go
/*
|
|
Copyright 2015 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
// Package v1 contains API types that are common to all versions.
|
|
//
|
|
// The package contains two categories of types:
|
|
// - external (serialized) types that lack their own version (e.g TypeMeta)
|
|
// - internal (never-serialized) types that are needed by several different
|
|
// api groups, and so live here, to avoid duplication and/or import loops
|
|
// (e.g. LabelSelector).
|
|
// In the future, we will probably move these categories of objects into
|
|
// separate packages.
|
|
package v1
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/types"
|
|
)
|
|
|
|
// TypeMeta describes an individual object in an API response or request
|
|
// with strings representing the type of the object and its API schema version.
|
|
// Structures that are versioned or persisted should inline TypeMeta.
|
|
//
|
|
// +k8s:deepcopy-gen=false
|
|
type TypeMeta struct {
|
|
// Kind is a string value representing the REST resource this object represents.
|
|
// Servers may infer this from the endpoint the client submits requests to.
|
|
// Cannot be updated.
|
|
// In CamelCase.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
|
|
// +optional
|
|
Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`
|
|
|
|
// APIVersion defines the versioned schema of this representation of an object.
|
|
// Servers should convert recognized schemas to the latest internal value, and
|
|
// may reject unrecognized values.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
|
|
// +optional
|
|
APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,2,opt,name=apiVersion"`
|
|
}
|
|
|
|
// ListMeta describes metadata that synthetic resources must have, including lists and
|
|
// various status objects. A resource may have only one of {ObjectMeta, ListMeta}.
|
|
type ListMeta struct {
|
|
// selfLink is a URL representing this object.
|
|
// Populated by the system.
|
|
// Read-only.
|
|
// +optional
|
|
SelfLink string `json:"selfLink,omitempty" protobuf:"bytes,1,opt,name=selfLink"`
|
|
|
|
// String that identifies the server's internal version of this object that
|
|
// can be used by clients to determine when objects have changed.
|
|
// Value must be treated as opaque by clients and passed unmodified back to the server.
|
|
// Populated by the system.
|
|
// Read-only.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency
|
|
// +optional
|
|
ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,2,opt,name=resourceVersion"`
|
|
|
|
// continue may be set if the user set a limit on the number of items returned, and indicates that
|
|
// the server has more data available. The value is opaque and may be used to issue another request
|
|
// to the endpoint that served this list to retrieve the next set of available objects. Continuing a
|
|
// consistent list may not be possible if the server configuration has changed or more than a few
|
|
// minutes have passed. The resourceVersion field returned when using this continue value will be
|
|
// identical to the value in the first response, unless you have received this token from an error
|
|
// message.
|
|
Continue string `json:"continue,omitempty" protobuf:"bytes,3,opt,name=continue"`
|
|
}
|
|
|
|
// These are internal finalizer values for Kubernetes-like APIs, must be qualified name unless defined here
|
|
const (
|
|
FinalizerOrphanDependents string = "orphan"
|
|
FinalizerDeleteDependents string = "foregroundDeletion"
|
|
)
|
|
|
|
// ObjectMeta is metadata that all persisted resources must have, which includes all objects
|
|
// users must create.
|
|
type ObjectMeta struct {
|
|
// Name must be unique within a namespace. Is required when creating resources, although
|
|
// some resources may allow a client to request the generation of an appropriate name
|
|
// automatically. Name is primarily intended for creation idempotence and configuration
|
|
// definition.
|
|
// Cannot be updated.
|
|
// More info: http://kubernetes.io/docs/user-guide/identifiers#names
|
|
// +optional
|
|
Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
|
|
|
|
// GenerateName is an optional prefix, used by the server, to generate a unique
|
|
// name ONLY IF the Name field has not been provided.
|
|
// If this field is used, the name returned to the client will be different
|
|
// than the name passed. This value will also be combined with a unique suffix.
|
|
// The provided value has the same validation rules as the Name field,
|
|
// and may be truncated by the length of the suffix required to make the value
|
|
// unique on the server.
|
|
//
|
|
// If this field is specified and the generated name exists, the server will
|
|
// NOT return a 409 - instead, it will either return 201 Created or 500 with Reason
|
|
// ServerTimeout indicating a unique name could not be found in the time allotted, and the client
|
|
// should retry (optionally after the time indicated in the Retry-After header).
|
|
//
|
|
// Applied only if Name is not specified.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency
|
|
// +optional
|
|
GenerateName string `json:"generateName,omitempty" protobuf:"bytes,2,opt,name=generateName"`
|
|
|
|
// Namespace defines the space within each name must be unique. An empty namespace is
|
|
// equivalent to the "default" namespace, but "default" is the canonical representation.
|
|
// Not all objects are required to be scoped to a namespace - the value of this field for
|
|
// those objects will be empty.
|
|
//
|
|
// Must be a DNS_LABEL.
|
|
// Cannot be updated.
|
|
// More info: http://kubernetes.io/docs/user-guide/namespaces
|
|
// +optional
|
|
Namespace string `json:"namespace,omitempty" protobuf:"bytes,3,opt,name=namespace"`
|
|
|
|
// SelfLink is a URL representing this object.
|
|
// Populated by the system.
|
|
// Read-only.
|
|
// +optional
|
|
SelfLink string `json:"selfLink,omitempty" protobuf:"bytes,4,opt,name=selfLink"`
|
|
|
|
// UID is the unique in time and space value for this object. It is typically generated by
|
|
// the server on successful creation of a resource and is not allowed to change on PUT
|
|
// operations.
|
|
//
|
|
// Populated by the system.
|
|
// Read-only.
|
|
// More info: http://kubernetes.io/docs/user-guide/identifiers#uids
|
|
// +optional
|
|
UID types.UID `json:"uid,omitempty" protobuf:"bytes,5,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`
|
|
|
|
// An opaque value that represents the internal version of this object that can
|
|
// be used by clients to determine when objects have changed. May be used for optimistic
|
|
// concurrency, change detection, and the watch operation on a resource or set of resources.
|
|
// Clients must treat these values as opaque and passed unmodified back to the server.
|
|
// They may only be valid for a particular resource or set of resources.
|
|
//
|
|
// Populated by the system.
|
|
// Read-only.
|
|
// Value must be treated as opaque by clients and .
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency
|
|
// +optional
|
|
ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,6,opt,name=resourceVersion"`
|
|
|
|
// A sequence number representing a specific generation of the desired state.
|
|
// Populated by the system. Read-only.
|
|
// +optional
|
|
Generation int64 `json:"generation,omitempty" protobuf:"varint,7,opt,name=generation"`
|
|
|
|
// CreationTimestamp is a timestamp representing the server time when this object was
|
|
// created. It is not guaranteed to be set in happens-before order across separate operations.
|
|
// Clients may not set this value. It is represented in RFC3339 form and is in UTC.
|
|
//
|
|
// Populated by the system.
|
|
// Read-only.
|
|
// Null for lists.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
|
|
// +optional
|
|
CreationTimestamp Time `json:"creationTimestamp,omitempty" protobuf:"bytes,8,opt,name=creationTimestamp"`
|
|
|
|
// DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This
|
|
// field is set by the server when a graceful deletion is requested by the user, and is not
|
|
// directly settable by a client. The resource is expected to be deleted (no longer visible
|
|
// from resource lists, and not reachable by name) after the time in this field, once the
|
|
// finalizers list is empty. As long as the finalizers list contains items, deletion is blocked.
|
|
// Once the deletionTimestamp is set, this value may not be unset or be set further into the
|
|
// future, although it may be shortened or the resource may be deleted prior to this time.
|
|
// For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react
|
|
// by sending a graceful termination signal to the containers in the pod. After that 30 seconds,
|
|
// the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup,
|
|
// remove the pod from the API. In the presence of network partitions, this object may still
|
|
// exist after this timestamp, until an administrator or automated process can determine the
|
|
// resource is fully terminated.
|
|
// If not set, graceful deletion of the object has not been requested.
|
|
//
|
|
// Populated by the system when a graceful deletion is requested.
|
|
// Read-only.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
|
|
// +optional
|
|
DeletionTimestamp *Time `json:"deletionTimestamp,omitempty" protobuf:"bytes,9,opt,name=deletionTimestamp"`
|
|
|
|
// Number of seconds allowed for this object to gracefully terminate before
|
|
// it will be removed from the system. Only set when deletionTimestamp is also set.
|
|
// May only be shortened.
|
|
// Read-only.
|
|
// +optional
|
|
DeletionGracePeriodSeconds *int64 `json:"deletionGracePeriodSeconds,omitempty" protobuf:"varint,10,opt,name=deletionGracePeriodSeconds"`
|
|
|
|
// Map of string keys and values that can be used to organize and categorize
|
|
// (scope and select) objects. May match selectors of replication controllers
|
|
// and services.
|
|
// More info: http://kubernetes.io/docs/user-guide/labels
|
|
// +optional
|
|
Labels map[string]string `json:"labels,omitempty" protobuf:"bytes,11,rep,name=labels"`
|
|
|
|
// Annotations is an unstructured key value map stored with a resource that may be
|
|
// set by external tools to store and retrieve arbitrary metadata. They are not
|
|
// queryable and should be preserved when modifying objects.
|
|
// More info: http://kubernetes.io/docs/user-guide/annotations
|
|
// +optional
|
|
Annotations map[string]string `json:"annotations,omitempty" protobuf:"bytes,12,rep,name=annotations"`
|
|
|
|
// List of objects depended by this object. If ALL objects in the list have
|
|
// been deleted, this object will be garbage collected. If this object is managed by a controller,
|
|
// then an entry in this list will point to this controller, with the controller field set to true.
|
|
// There cannot be more than one managing controller.
|
|
// +optional
|
|
// +patchMergeKey=uid
|
|
// +patchStrategy=merge
|
|
OwnerReferences []OwnerReference `json:"ownerReferences,omitempty" patchStrategy:"merge" patchMergeKey:"uid" protobuf:"bytes,13,rep,name=ownerReferences"`
|
|
|
|
// An initializer is a controller which enforces some system invariant at object creation time.
|
|
// This field is a list of initializers that have not yet acted on this object. If nil or empty,
|
|
// this object has been completely initialized. Otherwise, the object is considered uninitialized
|
|
// and is hidden (in list/watch and get calls) from clients that haven't explicitly asked to
|
|
// observe uninitialized objects.
|
|
//
|
|
// When an object is created, the system will populate this list with the current set of initializers.
|
|
// Only privileged users may set or modify this list. Once it is empty, it may not be modified further
|
|
// by any user.
|
|
//
|
|
// DEPRECATED - initializers are an alpha field and will be removed in v1.15.
|
|
Initializers *Initializers `json:"initializers,omitempty" protobuf:"bytes,16,opt,name=initializers"`
|
|
|
|
// Must be empty before the object is deleted from the registry. Each entry
|
|
// is an identifier for the responsible component that will remove the entry
|
|
// from the list. If the deletionTimestamp of the object is non-nil, entries
|
|
// in this list can only be removed.
|
|
// +optional
|
|
// +patchStrategy=merge
|
|
Finalizers []string `json:"finalizers,omitempty" patchStrategy:"merge" protobuf:"bytes,14,rep,name=finalizers"`
|
|
|
|
// The name of the cluster which the object belongs to.
|
|
// This is used to distinguish resources with same name and namespace in different clusters.
|
|
// This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request.
|
|
// +optional
|
|
ClusterName string `json:"clusterName,omitempty" protobuf:"bytes,15,opt,name=clusterName"`
|
|
|
|
// ManagedFields maps workflow-id and version to the set of fields
|
|
// that are managed by that workflow. This is mostly for internal
|
|
// housekeeping, and users typically shouldn't need to set or
|
|
// understand this field. A workflow can be the user's name, a
|
|
// controller's name, or the name of a specific apply path like
|
|
// "ci-cd". The set of fields is always in the version that the
|
|
// workflow used when modifying the object.
|
|
//
|
|
// This field is alpha and can be changed or removed without notice.
|
|
//
|
|
// +optional
|
|
ManagedFields []ManagedFieldsEntry `json:"managedFields,omitempty" protobuf:"bytes,17,rep,name=managedFields"`
|
|
}
|
|
|
|
// Initializers tracks the progress of initialization.
|
|
type Initializers struct {
|
|
// Pending is a list of initializers that must execute in order before this object is visible.
|
|
// When the last pending initializer is removed, and no failing result is set, the initializers
|
|
// struct will be set to nil and the object is considered as initialized and visible to all
|
|
// clients.
|
|
// +patchMergeKey=name
|
|
// +patchStrategy=merge
|
|
Pending []Initializer `json:"pending" protobuf:"bytes,1,rep,name=pending" patchStrategy:"merge" patchMergeKey:"name"`
|
|
// If result is set with the Failure field, the object will be persisted to storage and then deleted,
|
|
// ensuring that other clients can observe the deletion.
|
|
Result *Status `json:"result,omitempty" protobuf:"bytes,2,opt,name=result"`
|
|
}
|
|
|
|
// Initializer is information about an initializer that has not yet completed.
|
|
type Initializer struct {
|
|
// name of the process that is responsible for initializing this object.
|
|
Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
|
|
}
|
|
|
|
const (
|
|
// NamespaceDefault means the object is in the default namespace which is applied when not specified by clients
|
|
NamespaceDefault string = "default"
|
|
// NamespaceAll is the default argument to specify on a context when you want to list or filter resources across all namespaces
|
|
NamespaceAll string = ""
|
|
// NamespaceNone is the argument for a context when there is no namespace.
|
|
NamespaceNone string = ""
|
|
// NamespaceSystem is the system namespace where we place system components.
|
|
NamespaceSystem string = "kube-system"
|
|
// NamespacePublic is the namespace where we place public info (ConfigMaps)
|
|
NamespacePublic string = "kube-public"
|
|
)
|
|
|
|
// OwnerReference contains enough information to let you identify an owning
|
|
// object. An owning object must be in the same namespace as the dependent, or
|
|
// be cluster-scoped, so there is no namespace field.
|
|
type OwnerReference struct {
|
|
// API version of the referent.
|
|
APIVersion string `json:"apiVersion" protobuf:"bytes,5,opt,name=apiVersion"`
|
|
// Kind of the referent.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
|
|
Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"`
|
|
// Name of the referent.
|
|
// More info: http://kubernetes.io/docs/user-guide/identifiers#names
|
|
Name string `json:"name" protobuf:"bytes,3,opt,name=name"`
|
|
// UID of the referent.
|
|
// More info: http://kubernetes.io/docs/user-guide/identifiers#uids
|
|
UID types.UID `json:"uid" protobuf:"bytes,4,opt,name=uid,casttype=k8s.io/apimachinery/pkg/types.UID"`
|
|
// If true, this reference points to the managing controller.
|
|
// +optional
|
|
Controller *bool `json:"controller,omitempty" protobuf:"varint,6,opt,name=controller"`
|
|
// If true, AND if the owner has the "foregroundDeletion" finalizer, then
|
|
// the owner cannot be deleted from the key-value store until this
|
|
// reference is removed.
|
|
// Defaults to false.
|
|
// To set this field, a user needs "delete" permission of the owner,
|
|
// otherwise 422 (Unprocessable Entity) will be returned.
|
|
// +optional
|
|
BlockOwnerDeletion *bool `json:"blockOwnerDeletion,omitempty" protobuf:"varint,7,opt,name=blockOwnerDeletion"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// ListOptions is the query options to a standard REST list call.
|
|
type ListOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
|
|
// A selector to restrict the list of returned objects by their labels.
|
|
// Defaults to everything.
|
|
// +optional
|
|
LabelSelector string `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"`
|
|
// A selector to restrict the list of returned objects by their fields.
|
|
// Defaults to everything.
|
|
// +optional
|
|
FieldSelector string `json:"fieldSelector,omitempty" protobuf:"bytes,2,opt,name=fieldSelector"`
|
|
|
|
// +k8s:deprecated=includeUninitialized,protobuf=6
|
|
|
|
// Watch for changes to the described resources and return them as a stream of
|
|
// add, update, and remove notifications. Specify resourceVersion.
|
|
// +optional
|
|
Watch bool `json:"watch,omitempty" protobuf:"varint,3,opt,name=watch"`
|
|
// When specified with a watch call, shows changes that occur after that particular version of a resource.
|
|
// Defaults to changes from the beginning of history.
|
|
// When specified for list:
|
|
// - if unset, then the result is returned from remote storage based on quorum-read flag;
|
|
// - if it's 0, then we simply return what we currently have in cache, no guarantee;
|
|
// - if set to non zero, then the result is at least as fresh as given rv.
|
|
// +optional
|
|
ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,4,opt,name=resourceVersion"`
|
|
// Timeout for the list/watch call.
|
|
// This limits the duration of the call, regardless of any activity or inactivity.
|
|
// +optional
|
|
TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" protobuf:"varint,5,opt,name=timeoutSeconds"`
|
|
|
|
// limit is a maximum number of responses to return for a list call. If more items exist, the
|
|
// server will set the `continue` field on the list metadata to a value that can be used with the
|
|
// same initial query to retrieve the next set of results. Setting a limit may return fewer than
|
|
// the requested amount of items (up to zero items) in the event all requested objects are
|
|
// filtered out and clients should only use the presence of the continue field to determine whether
|
|
// more results are available. Servers may choose not to support the limit argument and will return
|
|
// all of the available results. If limit is specified and the continue field is empty, clients may
|
|
// assume that no more results are available. This field is not supported if watch is true.
|
|
//
|
|
// The server guarantees that the objects returned when using continue will be identical to issuing
|
|
// a single list call without a limit - that is, no objects created, modified, or deleted after the
|
|
// first request is issued will be included in any subsequent continued requests. This is sometimes
|
|
// referred to as a consistent snapshot, and ensures that a client that is using limit to receive
|
|
// smaller chunks of a very large result can ensure they see all possible objects. If objects are
|
|
// updated during a chunked list the version of the object that was present at the time the first list
|
|
// result was calculated is returned.
|
|
Limit int64 `json:"limit,omitempty" protobuf:"varint,7,opt,name=limit"`
|
|
// The continue option should be set when retrieving more results from the server. Since this value is
|
|
// server defined, clients may only use the continue value from a previous query result with identical
|
|
// query parameters (except for the value of continue) and the server may reject a continue value it
|
|
// does not recognize. If the specified continue value is no longer valid whether due to expiration
|
|
// (generally five to fifteen minutes) or a configuration change on the server, the server will
|
|
// respond with a 410 ResourceExpired error together with a continue token. If the client needs a
|
|
// consistent list, it must restart their list without the continue field. Otherwise, the client may
|
|
// send another list request with the token received with the 410 error, the server will respond with
|
|
// a list starting from the next key, but from the latest snapshot, which is inconsistent from the
|
|
// previous list results - objects that are created, modified, or deleted after the first list request
|
|
// will be included in the response, as long as their keys are after the "next key".
|
|
//
|
|
// This field is not supported when watch is true. Clients may start a watch from the last
|
|
// resourceVersion value returned by the server and not miss any modifications.
|
|
Continue string `json:"continue,omitempty" protobuf:"bytes,8,opt,name=continue"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// ExportOptions is the query options to the standard REST get call.
|
|
// Deprecated. Planned for removal in 1.18.
|
|
type ExportOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
// Should this value be exported. Export strips fields that a user can not specify.
|
|
// Deprecated. Planned for removal in 1.18.
|
|
Export bool `json:"export" protobuf:"varint,1,opt,name=export"`
|
|
// Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'.
|
|
// Deprecated. Planned for removal in 1.18.
|
|
Exact bool `json:"exact" protobuf:"varint,2,opt,name=exact"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// GetOptions is the standard query options to the standard REST get call.
|
|
type GetOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
// When specified:
|
|
// - if unset, then the result is returned from remote storage based on quorum-read flag;
|
|
// - if it's 0, then we simply return what we currently have in cache, no guarantee;
|
|
// - if set to non zero, then the result is at least as fresh as given rv.
|
|
ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,1,opt,name=resourceVersion"`
|
|
// +k8s:deprecated=includeUninitialized,protobuf=2
|
|
}
|
|
|
|
// DeletionPropagation decides if a deletion will propagate to the dependents of
|
|
// the object, and how the garbage collector will handle the propagation.
|
|
type DeletionPropagation string
|
|
|
|
const (
|
|
// Orphans the dependents.
|
|
DeletePropagationOrphan DeletionPropagation = "Orphan"
|
|
// Deletes the object from the key-value store, the garbage collector will
|
|
// delete the dependents in the background.
|
|
DeletePropagationBackground DeletionPropagation = "Background"
|
|
// The object exists in the key-value store until the garbage collector
|
|
// deletes all the dependents whose ownerReference.blockOwnerDeletion=true
|
|
// from the key-value store. API sever will put the "foregroundDeletion"
|
|
// finalizer on the object, and sets its deletionTimestamp. This policy is
|
|
// cascading, i.e., the dependents will be deleted with Foreground.
|
|
DeletePropagationForeground DeletionPropagation = "Foreground"
|
|
)
|
|
|
|
const (
|
|
// DryRunAll means to complete all processing stages, but don't
|
|
// persist changes to storage.
|
|
DryRunAll = "All"
|
|
)
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// DeleteOptions may be provided when deleting an API object.
|
|
type DeleteOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
|
|
// The duration in seconds before the object should be deleted. Value must be non-negative integer.
|
|
// The value zero indicates delete immediately. If this value is nil, the default grace period for the
|
|
// specified type will be used.
|
|
// Defaults to a per object value if not specified. zero means delete immediately.
|
|
// +optional
|
|
GracePeriodSeconds *int64 `json:"gracePeriodSeconds,omitempty" protobuf:"varint,1,opt,name=gracePeriodSeconds"`
|
|
|
|
// Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be
|
|
// returned.
|
|
// +optional
|
|
Preconditions *Preconditions `json:"preconditions,omitempty" protobuf:"bytes,2,opt,name=preconditions"`
|
|
|
|
// Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7.
|
|
// Should the dependent objects be orphaned. If true/false, the "orphan"
|
|
// finalizer will be added to/removed from the object's finalizers list.
|
|
// Either this field or PropagationPolicy may be set, but not both.
|
|
// +optional
|
|
OrphanDependents *bool `json:"orphanDependents,omitempty" protobuf:"varint,3,opt,name=orphanDependents"`
|
|
|
|
// Whether and how garbage collection will be performed.
|
|
// Either this field or OrphanDependents may be set, but not both.
|
|
// The default policy is decided by the existing finalizer set in the
|
|
// metadata.finalizers and the resource-specific default policy.
|
|
// Acceptable values are: 'Orphan' - orphan the dependents; 'Background' -
|
|
// allow the garbage collector to delete the dependents in the background;
|
|
// 'Foreground' - a cascading policy that deletes all dependents in the
|
|
// foreground.
|
|
// +optional
|
|
PropagationPolicy *DeletionPropagation `json:"propagationPolicy,omitempty" protobuf:"varint,4,opt,name=propagationPolicy"`
|
|
|
|
// When present, indicates that modifications should not be
|
|
// persisted. An invalid or unrecognized dryRun directive will
|
|
// result in an error response and no further processing of the
|
|
// request. Valid values are:
|
|
// - All: all dry run stages will be processed
|
|
// +optional
|
|
DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,5,rep,name=dryRun"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// CreateOptions may be provided when creating an API object.
|
|
type CreateOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
|
|
// When present, indicates that modifications should not be
|
|
// persisted. An invalid or unrecognized dryRun directive will
|
|
// result in an error response and no further processing of the
|
|
// request. Valid values are:
|
|
// - All: all dry run stages will be processed
|
|
// +optional
|
|
DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,1,rep,name=dryRun"`
|
|
// +k8s:deprecated=includeUninitialized,protobuf=2
|
|
|
|
// fieldManager is a name associated with the actor or entity
|
|
// that is making these changes. The value must be less than or
|
|
// 128 characters long, and only contain printable characters,
|
|
// as defined by https://golang.org/pkg/unicode/#IsPrint.
|
|
// +optional
|
|
FieldManager string `json:"fieldManager,omitempty" protobuf:"bytes,3,name=fieldManager"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// PatchOptions may be provided when patching an API object.
|
|
// PatchOptions is meant to be a superset of UpdateOptions.
|
|
type PatchOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
|
|
// When present, indicates that modifications should not be
|
|
// persisted. An invalid or unrecognized dryRun directive will
|
|
// result in an error response and no further processing of the
|
|
// request. Valid values are:
|
|
// - All: all dry run stages will be processed
|
|
// +optional
|
|
DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,1,rep,name=dryRun"`
|
|
|
|
// Force is going to "force" Apply requests. It means user will
|
|
// re-acquire conflicting fields owned by other people. Force
|
|
// flag must be unset for non-apply patch requests.
|
|
// +optional
|
|
Force *bool `json:"force,omitempty" protobuf:"varint,2,opt,name=force"`
|
|
|
|
// fieldManager is a name associated with the actor or entity
|
|
// that is making these changes. The value must be less than or
|
|
// 128 characters long, and only contain printable characters,
|
|
// as defined by https://golang.org/pkg/unicode/#IsPrint. This
|
|
// field is required for apply requests
|
|
// (application/apply-patch) but optional for non-apply patch
|
|
// types (JsonPatch, MergePatch, StrategicMergePatch).
|
|
// +optional
|
|
FieldManager string `json:"fieldManager,omitempty" protobuf:"bytes,3,name=fieldManager"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// UpdateOptions may be provided when updating an API object.
|
|
// All fields in UpdateOptions should also be present in PatchOptions.
|
|
type UpdateOptions struct {
|
|
TypeMeta `json:",inline"`
|
|
|
|
// When present, indicates that modifications should not be
|
|
// persisted. An invalid or unrecognized dryRun directive will
|
|
// result in an error response and no further processing of the
|
|
// request. Valid values are:
|
|
// - All: all dry run stages will be processed
|
|
// +optional
|
|
DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,1,rep,name=dryRun"`
|
|
|
|
// fieldManager is a name associated with the actor or entity
|
|
// that is making these changes. The value must be less than or
|
|
// 128 characters long, and only contain printable characters,
|
|
// as defined by https://golang.org/pkg/unicode/#IsPrint.
|
|
// +optional
|
|
FieldManager string `json:"fieldManager,omitempty" protobuf:"bytes,2,name=fieldManager"`
|
|
}
|
|
|
|
// Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
|
|
type Preconditions struct {
|
|
// Specifies the target UID.
|
|
// +optional
|
|
UID *types.UID `json:"uid,omitempty" protobuf:"bytes,1,opt,name=uid,casttype=k8s.io/apimachinery/pkg/types.UID"`
|
|
// Specifies the target ResourceVersion
|
|
// +optional
|
|
ResourceVersion *string `json:"resourceVersion,omitempty" protobuf:"bytes,2,opt,name=resourceVersion"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// Status is a return value for calls that don't return other objects.
|
|
type Status struct {
|
|
TypeMeta `json:",inline"`
|
|
// Standard list metadata.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
|
|
// +optional
|
|
ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
|
|
|
|
// Status of the operation.
|
|
// One of: "Success" or "Failure".
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status
|
|
// +optional
|
|
Status string `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"`
|
|
// A human-readable description of the status of this operation.
|
|
// +optional
|
|
Message string `json:"message,omitempty" protobuf:"bytes,3,opt,name=message"`
|
|
// A machine-readable description of why this operation is in the
|
|
// "Failure" status. If this value is empty there
|
|
// is no information available. A Reason clarifies an HTTP status
|
|
// code but does not override it.
|
|
// +optional
|
|
Reason StatusReason `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason,casttype=StatusReason"`
|
|
// Extended data associated with the reason. Each reason may define its
|
|
// own extended details. This field is optional and the data returned
|
|
// is not guaranteed to conform to any schema except that defined by
|
|
// the reason type.
|
|
// +optional
|
|
Details *StatusDetails `json:"details,omitempty" protobuf:"bytes,5,opt,name=details"`
|
|
// Suggested HTTP return code for this status, 0 if not set.
|
|
// +optional
|
|
Code int32 `json:"code,omitempty" protobuf:"varint,6,opt,name=code"`
|
|
}
|
|
|
|
// StatusDetails is a set of additional properties that MAY be set by the
|
|
// server to provide additional information about a response. The Reason
|
|
// field of a Status object defines what attributes will be set. Clients
|
|
// must ignore fields that do not match the defined type of each attribute,
|
|
// and should assume that any attribute may be empty, invalid, or under
|
|
// defined.
|
|
type StatusDetails struct {
|
|
// The name attribute of the resource associated with the status StatusReason
|
|
// (when there is a single name which can be described).
|
|
// +optional
|
|
Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
|
|
// The group attribute of the resource associated with the status StatusReason.
|
|
// +optional
|
|
Group string `json:"group,omitempty" protobuf:"bytes,2,opt,name=group"`
|
|
// The kind attribute of the resource associated with the status StatusReason.
|
|
// On some operations may differ from the requested resource Kind.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
|
|
// +optional
|
|
Kind string `json:"kind,omitempty" protobuf:"bytes,3,opt,name=kind"`
|
|
// UID of the resource.
|
|
// (when there is a single resource which can be described).
|
|
// More info: http://kubernetes.io/docs/user-guide/identifiers#uids
|
|
// +optional
|
|
UID types.UID `json:"uid,omitempty" protobuf:"bytes,6,opt,name=uid,casttype=k8s.io/apimachinery/pkg/types.UID"`
|
|
// The Causes array includes more details associated with the StatusReason
|
|
// failure. Not all StatusReasons may provide detailed causes.
|
|
// +optional
|
|
Causes []StatusCause `json:"causes,omitempty" protobuf:"bytes,4,rep,name=causes"`
|
|
// If specified, the time in seconds before the operation should be retried. Some errors may indicate
|
|
// the client must take an alternate action - for those errors this field may indicate how long to wait
|
|
// before taking the alternate action.
|
|
// +optional
|
|
RetryAfterSeconds int32 `json:"retryAfterSeconds,omitempty" protobuf:"varint,5,opt,name=retryAfterSeconds"`
|
|
}
|
|
|
|
// Values of Status.Status
|
|
const (
|
|
StatusSuccess = "Success"
|
|
StatusFailure = "Failure"
|
|
)
|
|
|
|
// StatusReason is an enumeration of possible failure causes. Each StatusReason
|
|
// must map to a single HTTP status code, but multiple reasons may map
|
|
// to the same HTTP status code.
|
|
// TODO: move to apiserver
|
|
type StatusReason string
|
|
|
|
const (
|
|
// StatusReasonUnknown means the server has declined to indicate a specific reason.
|
|
// The details field may contain other information about this error.
|
|
// Status code 500.
|
|
StatusReasonUnknown StatusReason = ""
|
|
|
|
// StatusReasonUnauthorized means the server can be reached and understood the request, but requires
|
|
// the user to present appropriate authorization credentials (identified by the WWW-Authenticate header)
|
|
// in order for the action to be completed. If the user has specified credentials on the request, the
|
|
// server considers them insufficient.
|
|
// Status code 401
|
|
StatusReasonUnauthorized StatusReason = "Unauthorized"
|
|
|
|
// StatusReasonForbidden means the server can be reached and understood the request, but refuses
|
|
// to take any further action. It is the result of the server being configured to deny access for some reason
|
|
// to the requested resource by the client.
|
|
// Details (optional):
|
|
// "kind" string - the kind attribute of the forbidden resource
|
|
// on some operations may differ from the requested
|
|
// resource.
|
|
// "id" string - the identifier of the forbidden resource
|
|
// Status code 403
|
|
StatusReasonForbidden StatusReason = "Forbidden"
|
|
|
|
// StatusReasonNotFound means one or more resources required for this operation
|
|
// could not be found.
|
|
// Details (optional):
|
|
// "kind" string - the kind attribute of the missing resource
|
|
// on some operations may differ from the requested
|
|
// resource.
|
|
// "id" string - the identifier of the missing resource
|
|
// Status code 404
|
|
StatusReasonNotFound StatusReason = "NotFound"
|
|
|
|
// StatusReasonAlreadyExists means the resource you are creating already exists.
|
|
// Details (optional):
|
|
// "kind" string - the kind attribute of the conflicting resource
|
|
// "id" string - the identifier of the conflicting resource
|
|
// Status code 409
|
|
StatusReasonAlreadyExists StatusReason = "AlreadyExists"
|
|
|
|
// StatusReasonConflict means the requested operation cannot be completed
|
|
// due to a conflict in the operation. The client may need to alter the
|
|
// request. Each resource may define custom details that indicate the
|
|
// nature of the conflict.
|
|
// Status code 409
|
|
StatusReasonConflict StatusReason = "Conflict"
|
|
|
|
// StatusReasonGone means the item is no longer available at the server and no
|
|
// forwarding address is known.
|
|
// Status code 410
|
|
StatusReasonGone StatusReason = "Gone"
|
|
|
|
// StatusReasonInvalid means the requested create or update operation cannot be
|
|
// completed due to invalid data provided as part of the request. The client may
|
|
// need to alter the request. When set, the client may use the StatusDetails
|
|
// message field as a summary of the issues encountered.
|
|
// Details (optional):
|
|
// "kind" string - the kind attribute of the invalid resource
|
|
// "id" string - the identifier of the invalid resource
|
|
// "causes" - one or more StatusCause entries indicating the data in the
|
|
// provided resource that was invalid. The code, message, and
|
|
// field attributes will be set.
|
|
// Status code 422
|
|
StatusReasonInvalid StatusReason = "Invalid"
|
|
|
|
// StatusReasonServerTimeout means the server can be reached and understood the request,
|
|
// but cannot complete the action in a reasonable time. The client should retry the request.
|
|
// This is may be due to temporary server load or a transient communication issue with
|
|
// another server. Status code 500 is used because the HTTP spec provides no suitable
|
|
// server-requested client retry and the 5xx class represents actionable errors.
|
|
// Details (optional):
|
|
// "kind" string - the kind attribute of the resource being acted on.
|
|
// "id" string - the operation that is being attempted.
|
|
// "retryAfterSeconds" int32 - the number of seconds before the operation should be retried
|
|
// Status code 500
|
|
StatusReasonServerTimeout StatusReason = "ServerTimeout"
|
|
|
|
// StatusReasonTimeout means that the request could not be completed within the given time.
|
|
// Clients can get this response only when they specified a timeout param in the request,
|
|
// or if the server cannot complete the operation within a reasonable amount of time.
|
|
// The request might succeed with an increased value of timeout param. The client *should*
|
|
// wait at least the number of seconds specified by the retryAfterSeconds field.
|
|
// Details (optional):
|
|
// "retryAfterSeconds" int32 - the number of seconds before the operation should be retried
|
|
// Status code 504
|
|
StatusReasonTimeout StatusReason = "Timeout"
|
|
|
|
// StatusReasonTooManyRequests means the server experienced too many requests within a
|
|
// given window and that the client must wait to perform the action again. A client may
|
|
// always retry the request that led to this error, although the client should wait at least
|
|
// the number of seconds specified by the retryAfterSeconds field.
|
|
// Details (optional):
|
|
// "retryAfterSeconds" int32 - the number of seconds before the operation should be retried
|
|
// Status code 429
|
|
StatusReasonTooManyRequests StatusReason = "TooManyRequests"
|
|
|
|
// StatusReasonBadRequest means that the request itself was invalid, because the request
|
|
// doesn't make any sense, for example deleting a read-only object. This is different than
|
|
// StatusReasonInvalid above which indicates that the API call could possibly succeed, but the
|
|
// data was invalid. API calls that return BadRequest can never succeed.
|
|
StatusReasonBadRequest StatusReason = "BadRequest"
|
|
|
|
// StatusReasonMethodNotAllowed means that the action the client attempted to perform on the
|
|
// resource was not supported by the code - for instance, attempting to delete a resource that
|
|
// can only be created. API calls that return MethodNotAllowed can never succeed.
|
|
StatusReasonMethodNotAllowed StatusReason = "MethodNotAllowed"
|
|
|
|
// StatusReasonNotAcceptable means that the accept types indicated by the client were not acceptable
|
|
// to the server - for instance, attempting to receive protobuf for a resource that supports only json and yaml.
|
|
// API calls that return NotAcceptable can never succeed.
|
|
// Status code 406
|
|
StatusReasonNotAcceptable StatusReason = "NotAcceptable"
|
|
|
|
// StatusReasonRequestEntityTooLarge means that the request entity is too large.
|
|
// Status code 413
|
|
StatusReasonRequestEntityTooLarge StatusReason = "RequestEntityTooLarge"
|
|
|
|
// StatusReasonUnsupportedMediaType means that the content type sent by the client is not acceptable
|
|
// to the server - for instance, attempting to send protobuf for a resource that supports only json and yaml.
|
|
// API calls that return UnsupportedMediaType can never succeed.
|
|
// Status code 415
|
|
StatusReasonUnsupportedMediaType StatusReason = "UnsupportedMediaType"
|
|
|
|
// StatusReasonInternalError indicates that an internal error occurred, it is unexpected
|
|
// and the outcome of the call is unknown.
|
|
// Details (optional):
|
|
// "causes" - The original error
|
|
// Status code 500
|
|
StatusReasonInternalError StatusReason = "InternalError"
|
|
|
|
// StatusReasonExpired indicates that the request is invalid because the content you are requesting
|
|
// has expired and is no longer available. It is typically associated with watches that can't be
|
|
// serviced.
|
|
// Status code 410 (gone)
|
|
StatusReasonExpired StatusReason = "Expired"
|
|
|
|
// StatusReasonServiceUnavailable means that the request itself was valid,
|
|
// but the requested service is unavailable at this time.
|
|
// Retrying the request after some time might succeed.
|
|
// Status code 503
|
|
StatusReasonServiceUnavailable StatusReason = "ServiceUnavailable"
|
|
)
|
|
|
|
// StatusCause provides more information about an api.Status failure, including
|
|
// cases when multiple errors are encountered.
|
|
type StatusCause struct {
|
|
// A machine-readable description of the cause of the error. If this value is
|
|
// empty there is no information available.
|
|
// +optional
|
|
Type CauseType `json:"reason,omitempty" protobuf:"bytes,1,opt,name=reason,casttype=CauseType"`
|
|
// A human-readable description of the cause of the error. This field may be
|
|
// presented as-is to a reader.
|
|
// +optional
|
|
Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"`
|
|
// The field of the resource that has caused this error, as named by its JSON
|
|
// serialization. May include dot and postfix notation for nested attributes.
|
|
// Arrays are zero-indexed. Fields may appear more than once in an array of
|
|
// causes due to fields having multiple errors.
|
|
// Optional.
|
|
//
|
|
// Examples:
|
|
// "name" - the field "name" on the current resource
|
|
// "items[0].name" - the field "name" on the first array entry in "items"
|
|
// +optional
|
|
Field string `json:"field,omitempty" protobuf:"bytes,3,opt,name=field"`
|
|
}
|
|
|
|
// CauseType is a machine readable value providing more detail about what
|
|
// occurred in a status response. An operation may have multiple causes for a
|
|
// status (whether Failure or Success).
|
|
type CauseType string
|
|
|
|
const (
|
|
// CauseTypeFieldValueNotFound is used to report failure to find a requested value
|
|
// (e.g. looking up an ID).
|
|
CauseTypeFieldValueNotFound CauseType = "FieldValueNotFound"
|
|
// CauseTypeFieldValueRequired is used to report required values that are not
|
|
// provided (e.g. empty strings, null values, or empty arrays).
|
|
CauseTypeFieldValueRequired CauseType = "FieldValueRequired"
|
|
// CauseTypeFieldValueDuplicate is used to report collisions of values that must be
|
|
// unique (e.g. unique IDs).
|
|
CauseTypeFieldValueDuplicate CauseType = "FieldValueDuplicate"
|
|
// CauseTypeFieldValueInvalid is used to report malformed values (e.g. failed regex
|
|
// match).
|
|
CauseTypeFieldValueInvalid CauseType = "FieldValueInvalid"
|
|
// CauseTypeFieldValueNotSupported is used to report valid (as per formatting rules)
|
|
// values that can not be handled (e.g. an enumerated string).
|
|
CauseTypeFieldValueNotSupported CauseType = "FieldValueNotSupported"
|
|
// CauseTypeUnexpectedServerResponse is used to report when the server responded to the client
|
|
// without the expected return type. The presence of this cause indicates the error may be
|
|
// due to an intervening proxy or the server software malfunctioning.
|
|
CauseTypeUnexpectedServerResponse CauseType = "UnexpectedServerResponse"
|
|
// FieldManagerConflict is used to report when another client claims to manage this field,
|
|
// It should only be returned for a request using server-side apply.
|
|
CauseTypeFieldManagerConflict CauseType = "FieldManagerConflict"
|
|
)
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// List holds a list of objects, which may not be known by the server.
|
|
type List struct {
|
|
TypeMeta `json:",inline"`
|
|
// Standard list metadata.
|
|
// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
|
|
// +optional
|
|
ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
|
|
|
|
// List of objects
|
|
Items []runtime.RawExtension `json:"items" protobuf:"bytes,2,rep,name=items"`
|
|
}
|
|
|
|
// APIVersions lists the versions that are available, to allow clients to
|
|
// discover the API at /api, which is the root path of the legacy v1 API.
|
|
//
|
|
// +protobuf.options.(gogoproto.goproto_stringer)=false
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
type APIVersions struct {
|
|
TypeMeta `json:",inline"`
|
|
// versions are the api versions that are available.
|
|
Versions []string `json:"versions" protobuf:"bytes,1,rep,name=versions"`
|
|
// a map of client CIDR to server address that is serving this group.
|
|
// This is to help clients reach servers in the most network-efficient way possible.
|
|
// Clients can use the appropriate server address as per the CIDR that they match.
|
|
// In case of multiple matches, clients should use the longest matching CIDR.
|
|
// The server returns only those CIDRs that it thinks that the client can match.
|
|
// For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP.
|
|
// Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP.
|
|
ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs" protobuf:"bytes,2,rep,name=serverAddressByClientCIDRs"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// APIGroupList is a list of APIGroup, to allow clients to discover the API at
|
|
// /apis.
|
|
type APIGroupList struct {
|
|
TypeMeta `json:",inline"`
|
|
// groups is a list of APIGroup.
|
|
Groups []APIGroup `json:"groups" protobuf:"bytes,1,rep,name=groups"`
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// APIGroup contains the name, the supported versions, and the preferred version
|
|
// of a group.
|
|
type APIGroup struct {
|
|
TypeMeta `json:",inline"`
|
|
// name is the name of the group.
|
|
Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
|
|
// versions are the versions supported in this group.
|
|
Versions []GroupVersionForDiscovery `json:"versions" protobuf:"bytes,2,rep,name=versions"`
|
|
// preferredVersion is the version preferred by the API server, which
|
|
// probably is the storage version.
|
|
// +optional
|
|
PreferredVersion GroupVersionForDiscovery `json:"preferredVersion,omitempty" protobuf:"bytes,3,opt,name=preferredVersion"`
|
|
// a map of client CIDR to server address that is serving this group.
|
|
// This is to help clients reach servers in the most network-efficient way possible.
|
|
// Clients can use the appropriate server address as per the CIDR that they match.
|
|
// In case of multiple matches, clients should use the longest matching CIDR.
|
|
// The server returns only those CIDRs that it thinks that the client can match.
|
|
// For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP.
|
|
// Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP.
|
|
// +optional
|
|
ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs,omitempty" protobuf:"bytes,4,rep,name=serverAddressByClientCIDRs"`
|
|
}
|
|
|
|
// ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
|
|
type ServerAddressByClientCIDR struct {
|
|
// The CIDR with which clients can match their IP to figure out the server address that they should use.
|
|
ClientCIDR string `json:"clientCIDR" protobuf:"bytes,1,opt,name=clientCIDR"`
|
|
// Address of this server, suitable for a client that matches the above CIDR.
|
|
// This can be a hostname, hostname:port, IP or IP:port.
|
|
ServerAddress string `json:"serverAddress" protobuf:"bytes,2,opt,name=serverAddress"`
|
|
}
|
|
|
|
// GroupVersion contains the "group/version" and "version" string of a version.
|
|
// It is made a struct to keep extensibility.
|
|
type GroupVersionForDiscovery struct {
|
|
// groupVersion specifies the API group and version in the form "group/version"
|
|
GroupVersion string `json:"groupVersion" protobuf:"bytes,1,opt,name=groupVersion"`
|
|
// version specifies the version in the form of "version". This is to save
|
|
// the clients the trouble of splitting the GroupVersion.
|
|
Version string `json:"version" protobuf:"bytes,2,opt,name=version"`
|
|
}
|
|
|
|
// APIResource specifies the name of a resource and whether it is namespaced.
|
|
type APIResource struct {
|
|
// name is the plural name of the resource.
|
|
Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
|
|
// singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely.
|
|
// The singularName is more correct for reporting status on a single item and both singular and plural are allowed
|
|
// from the kubectl CLI interface.
|
|
SingularName string `json:"singularName" protobuf:"bytes,6,opt,name=singularName"`
|
|
// namespaced indicates if a resource is namespaced or not.
|
|
Namespaced bool `json:"namespaced" protobuf:"varint,2,opt,name=namespaced"`
|
|
// group is the preferred group of the resource. Empty implies the group of the containing resource list.
|
|
// For subresources, this may have a different value, for example: Scale".
|
|
Group string `json:"group,omitempty" protobuf:"bytes,8,opt,name=group"`
|
|
// version is the preferred version of the resource. Empty implies the version of the containing resource list
|
|
// For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)".
|
|
Version string `json:"version,omitempty" protobuf:"bytes,9,opt,name=version"`
|
|
// kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')
|
|
Kind string `json:"kind" protobuf:"bytes,3,opt,name=kind"`
|
|
// verbs is a list of supported kube verbs (this includes get, list, watch, create,
|
|
// update, patch, delete, deletecollection, and proxy)
|
|
Verbs Verbs `json:"verbs" protobuf:"bytes,4,opt,name=verbs"`
|
|
// shortNames is a list of suggested short names of the resource.
|
|
ShortNames []string `json:"shortNames,omitempty" protobuf:"bytes,5,rep,name=shortNames"`
|
|
// categories is a list of the grouped resources this resource belongs to (e.g. 'all')
|
|
Categories []string `json:"categories,omitempty" protobuf:"bytes,7,rep,name=categories"`
|
|
// The hash value of the storage version, the version this resource is
|
|
// converted to when written to the data store. Value must be treated
|
|
// as opaque by clients. Only equality comparison on the value is valid.
|
|
// This is an alpha feature and may change or be removed in the future.
|
|
// The field is populated by the apiserver only if the
|
|
// StorageVersionHash feature gate is enabled.
|
|
// This field will remain optional even if it graduates.
|
|
// +optional
|
|
StorageVersionHash string `json:"storageVersionHash,omitempty" protobuf:"bytes,10,opt,name=storageVersionHash"`
|
|
}
|
|
|
|
// Verbs masks the value so protobuf can generate
|
|
//
|
|
// +protobuf.nullable=true
|
|
// +protobuf.options.(gogoproto.goproto_stringer)=false
|
|
type Verbs []string
|
|
|
|
func (vs Verbs) String() string {
|
|
return fmt.Sprintf("%v", []string(vs))
|
|
}
|
|
|
|
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
|
|
|
|
// APIResourceList is a list of APIResource, it is used to expose the name of the
|
|
// resources supported in a specific group and version, and if the resource
|
|
// is namespaced.
|
|
type APIResourceList struct {
|
|
TypeMeta `json:",inline"`
|
|
// groupVersion is the group and version this APIResourceList is for.
|
|
GroupVersion string `json:"groupVersion" protobuf:"bytes,1,opt,name=groupVersion"`
|
|
// resources contains the name of the resources and if they are namespaced.
|
|
APIResources []APIResource `json:"resources" protobuf:"bytes,2,rep,name=resources"`
|
|
}
|
|
|
|
// RootPaths lists the paths available at root.
|
|
// For example: "/healthz", "/apis".
|
|
type RootPaths struct {
|
|
// paths are the paths available at root.
|
|
Paths []string `json:"paths" protobuf:"bytes,1,rep,name=paths"`
|
|
}
|
|
|
|
// TODO: remove me when watch is refactored
|
|
func LabelSelectorQueryParam(version string) string {
|
|
return "labelSelector"
|
|
}
|
|
|
|
// TODO: remove me when watch is refactored
|
|
func FieldSelectorQueryParam(version string) string {
|
|
return "fieldSelector"
|
|
}
|
|
|
|
// String returns available api versions as a human-friendly version string.
|
|
func (apiVersions APIVersions) String() string {
|
|
return strings.Join(apiVersions.Versions, ",")
|
|
}
|
|
|
|
func (apiVersions APIVersions) GoString() string {
|
|
return apiVersions.String()
|
|
}
|
|
|
|
// Patch is provided to give a concrete name and type to the Kubernetes PATCH request body.
|
|
type Patch struct{}
|
|
|
|
// Note:
|
|
// There are two different styles of label selectors used in versioned types:
|
|
// an older style which is represented as just a string in versioned types, and a
|
|
// newer style that is structured. LabelSelector is an internal representation for the
|
|
// latter style.
|
|
|
|
// A label selector is a label query over a set of resources. The result of matchLabels and
|
|
// matchExpressions are ANDed. An empty label selector matches all objects. A null
|
|
// label selector matches no objects.
|
|
type LabelSelector struct {
|
|
// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
|
|
// map is equivalent to an element of matchExpressions, whose key field is "key", the
|
|
// operator is "In", and the values array contains only "value". The requirements are ANDed.
|
|
// +optional
|
|
MatchLabels map[string]string `json:"matchLabels,omitempty" protobuf:"bytes,1,rep,name=matchLabels"`
|
|
// matchExpressions is a list of label selector requirements. The requirements are ANDed.
|
|
// +optional
|
|
MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty" protobuf:"bytes,2,rep,name=matchExpressions"`
|
|
}
|
|
|
|
// A label selector requirement is a selector that contains values, a key, and an operator that
|
|
// relates the key and values.
|
|
type LabelSelectorRequirement struct {
|
|
// key is the label key that the selector applies to.
|
|
// +patchMergeKey=key
|
|
// +patchStrategy=merge
|
|
Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
|
|
// operator represents a key's relationship to a set of values.
|
|
// Valid operators are In, NotIn, Exists and DoesNotExist.
|
|
Operator LabelSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=LabelSelectorOperator"`
|
|
// values is an array of string values. If the operator is In or NotIn,
|
|
// the values array must be non-empty. If the operator is Exists or DoesNotExist,
|
|
// the values array must be empty. This array is replaced during a strategic
|
|
// merge patch.
|
|
// +optional
|
|
Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
|
|
}
|
|
|
|
// A label selector operator is the set of operators that can be used in a selector requirement.
|
|
type LabelSelectorOperator string
|
|
|
|
const (
|
|
LabelSelectorOpIn LabelSelectorOperator = "In"
|
|
LabelSelectorOpNotIn LabelSelectorOperator = "NotIn"
|
|
LabelSelectorOpExists LabelSelectorOperator = "Exists"
|
|
LabelSelectorOpDoesNotExist LabelSelectorOperator = "DoesNotExist"
|
|
)
|
|
|
|
// ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource
|
|
// that the fieldset applies to.
|
|
type ManagedFieldsEntry struct {
|
|
// Manager is an identifier of the workflow managing these fields.
|
|
Manager string `json:"manager,omitempty" protobuf:"bytes,1,opt,name=manager"`
|
|
// Operation is the type of operation which lead to this ManagedFieldsEntry being created.
|
|
// The only valid values for this field are 'Apply' and 'Update'.
|
|
Operation ManagedFieldsOperationType `json:"operation,omitempty" protobuf:"bytes,2,opt,name=operation,casttype=ManagedFieldsOperationType"`
|
|
// APIVersion defines the version of this resource that this field set
|
|
// applies to. The format is "group/version" just like the top-level
|
|
// APIVersion field. It is necessary to track the version of a field
|
|
// set because it cannot be automatically converted.
|
|
APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"`
|
|
// Time is timestamp of when these fields were set. It should always be empty if Operation is 'Apply'
|
|
// +optional
|
|
Time *Time `json:"time,omitempty" protobuf:"bytes,4,opt,name=time"`
|
|
// Fields identifies a set of fields.
|
|
// +optional
|
|
Fields *Fields `json:"fields,omitempty" protobuf:"bytes,5,opt,name=fields,casttype=Fields"`
|
|
}
|
|
|
|
// ManagedFieldsOperationType is the type of operation which lead to a ManagedFieldsEntry being created.
|
|
type ManagedFieldsOperationType string
|
|
|
|
const (
|
|
ManagedFieldsOperationApply ManagedFieldsOperationType = "Apply"
|
|
ManagedFieldsOperationUpdate ManagedFieldsOperationType = "Update"
|
|
)
|
|
|
|
// Fields stores a set of fields in a data structure like a Trie.
|
|
// To understand how this is used, see: https://github.com/kubernetes-sigs/structured-merge-diff
|
|
type Fields struct {
|
|
// Map stores a set of fields in a data structure like a Trie.
|
|
//
|
|
// Each key is either a '.' representing the field itself, and will always map to an empty set,
|
|
// or a string representing a sub-field or item. The string will follow one of these four formats:
|
|
// 'f:<name>', where <name> is the name of a field in a struct, or key in a map
|
|
// 'v:<value>', where <value> is the exact json formatted value of a list item
|
|
// 'i:<index>', where <index> is position of a item in a list
|
|
// 'k:<keys>', where <keys> is a map of a list item's key fields to their unique values
|
|
// If a key maps to an empty Fields value, the field that key represents is part of the set.
|
|
//
|
|
// The exact format is defined in k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal
|
|
Map map[string]Fields `json:",inline" protobuf:"bytes,1,rep,name=map"`
|
|
}
|