Documentation

Overview

Package client contains functionality for interacting with Kubernetes API servers.

Clients

Clients are split into two interfaces -- Readers and Writers. Readers get and list, while writers create, update, and delete.

The New function can be used to create a new client that talks directly to the API server.

A common pattern in Kubernetes to read from a cache and write to the API server. This pattern is covered by the DelegatingClient type, which can be used to have a client whose Reader is different from the Writer.

Options

Many client operations in Kubernetes support options. These options are represented as variadic arguments at the end of a given method call. For instance, to use a label selector on list, you can call

err := someReader.List(context.Background(), &podList, client.MatchingLabels{"somelabel": "someval"})

Indexing

Indexes may be added to caches using a FieldIndexer. This allows you to easily and efficiently look up objects with certain properties. You can then make use of the index by specifying a field selector on calls to List on the Reader corresponding to the given Cache.

For instance, a Secret controller might have an index on the `.spec.volumes.secret.secretName` field in Pod objects, so that it could easily look up all pods that reference a given secret.

Index

Examples

Constants

This section is empty.

Variables

View Source
var (
	// Apply uses server-side apply to patch the given object.
	Apply = applyPatch{}

	// Merge uses the raw object as a merge patch, without modifications.
	// Use MergeFrom if you wish to compute a diff instead.
	Merge = mergePatch{}
)
View Source
var DryRunAll = dryRunAll{}

    DryRunAll sets the "dry run" option to "all", executing all validation, etc without persisting the change to storage.

    View Source
    var ForceOwnership = forceOwnership{}

      ForceOwnership indicates that in case of conflicts with server-side apply, the client should acquire ownership of the conflicting field. Most controllers should use this.

      Functions

      func IgnoreNotFound

      func IgnoreNotFound(err error) error

        IgnoreNotFound returns nil on NotFound errors. All other values that are not NotFound errors or nil are returned unmodified.

        Types

        type Client

        type Client interface {
        	Reader
        	Writer
        	StatusClient
        
        	// Scheme returns the scheme this client is using.
        	Scheme() *runtime.Scheme
        	// RESTMapper returns the rest this client is using.
        	RESTMapper() meta.RESTMapper
        }

          Client knows how to perform CRUD operations on Kubernetes objects.

          Example (Create)

            This example shows how to use the client with typed and unstructured objects to create objects.

            Output:
            
            
            Example (Delete)

              This example shows how to use the client with typed and unstructured objects to delete objects.

              Output:
              
              
              Example (DeleteAllOf)

                This example shows how to use the client with typed and unstrucurted objects to delete collections of objects.

                Output:
                
                
                Example (Get)

                  This example shows how to use the client with typed and unstructured objects to retrieve a objects.

                  Output:
                  
                  
                  Example (List)

                    This example shows how to use the client with typed and unstructured objects to list objects.

                    Output:
                    
                    
                    Example (Patch)

                      This example shows how to use the client with typed and unstructured objects to patch objects.

                      Output:
                      
                      
                      Example (PatchStatus)

                        This example shows how to use the client with typed and unstructured objects to patch objects' status.

                        Output:
                        
                        
                        Example (Update)

                          This example shows how to use the client with typed and unstructured objects to update objects.

                          Output:
                          
                          

                          func New

                          func New(config *rest.Config, options Options) (Client, error)

                            New returns a new Client using the provided config and Options. The returned client reads *and* writes directly from the server (it doesn't use object caches). It understands how to work with normal types (both custom resources and aggregated/built-in resources), as well as unstructured types.

                            In the case of normal types, the scheme will be used to look up the corresponding group, version, and kind for the given type. In the case of unstructured types, the group, version, and kind will be extracted from the corresponding fields on the object.

                            Example
                            Output:
                            
                            

                            func NewDelegatingClient

                            func NewDelegatingClient(in NewDelegatingClientInput) (Client, error)

                              NewDelegatingClient creates a new delegating client.

                              A delegating client forms a Client by composing separate reader, writer and statusclient interfaces. This way, you can have an Client that reads from a cache and writes to the API server.

                              func NewDryRunClient

                              func NewDryRunClient(c Client) Client

                                NewDryRunClient wraps an existing client and enforces DryRun mode on all mutating api calls.

                                func NewNamespacedClient

                                func NewNamespacedClient(c Client, ns string) Client

                                  NewNamespacedClient wraps an existing client enforcing the namespace value. All functions using this client will have the same namespace declared here.

                                  type Continue

                                  type Continue string

                                    Continue sets a continuation token to retrieve chunks of results when using limit. Continue does not implement DeleteAllOfOption interface because the server does not support setting it for deletecollection operations.

                                    func (Continue) ApplyToList

                                    func (c Continue) ApplyToList(opts *ListOptions)

                                      ApplyToList applies this configuration to the given an List options.

                                      type CreateOption

                                      type CreateOption interface {
                                      	// ApplyToCreate applies this configuration to the given create options.
                                      	ApplyToCreate(*CreateOptions)
                                      }

                                        CreateOption is some configuration that modifies options for a create request.

                                        type CreateOptions

                                        type CreateOptions struct {
                                        	// 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
                                        	DryRun []string
                                        
                                        	// FieldManager is the name of the user or component submitting
                                        	// this request.  It must be set with server-side apply.
                                        	FieldManager string
                                        
                                        	// Raw represents raw CreateOptions, as passed to the API server.
                                        	Raw *metav1.CreateOptions
                                        }

                                          CreateOptions contains options for create requests. It's generally a subset of metav1.CreateOptions.

                                          func (*CreateOptions) ApplyOptions

                                          func (o *CreateOptions) ApplyOptions(opts []CreateOption) *CreateOptions

                                            ApplyOptions applies the given create options on these options, and then returns itself (for convenient chaining).

                                            func (*CreateOptions) ApplyToCreate

                                            func (o *CreateOptions) ApplyToCreate(co *CreateOptions)

                                              ApplyToCreate implements CreateOption

                                              func (*CreateOptions) AsCreateOptions

                                              func (o *CreateOptions) AsCreateOptions() *metav1.CreateOptions

                                                AsCreateOptions returns these options as a metav1.CreateOptions. This may mutate the Raw field.

                                                type DeleteAllOfOption

                                                type DeleteAllOfOption interface {
                                                	// ApplyToDeleteAllOf applies this configuration to the given deletecollection options.
                                                	ApplyToDeleteAllOf(*DeleteAllOfOptions)
                                                }

                                                  DeleteAllOfOption is some configuration that modifies options for a delete request.

                                                  type DeleteAllOfOptions

                                                  type DeleteAllOfOptions struct {
                                                  	ListOptions
                                                  	DeleteOptions
                                                  }

                                                    DeleteAllOfOptions contains options for deletecollection (deleteallof) requests. It's just list and delete options smooshed together.

                                                    func (*DeleteAllOfOptions) ApplyOptions

                                                    func (o *DeleteAllOfOptions) ApplyOptions(opts []DeleteAllOfOption) *DeleteAllOfOptions

                                                      ApplyOptions applies the given deleteallof options on these options, and then returns itself (for convenient chaining).

                                                      func (*DeleteAllOfOptions) ApplyToDeleteAllOf

                                                      func (o *DeleteAllOfOptions) ApplyToDeleteAllOf(do *DeleteAllOfOptions)

                                                        ApplyToDeleteAllOf implements DeleteAllOfOption

                                                        type DeleteOption

                                                        type DeleteOption interface {
                                                        	// ApplyToDelete applies this configuration to the given delete options.
                                                        	ApplyToDelete(*DeleteOptions)
                                                        }

                                                          DeleteOption is some configuration that modifies options for a delete request.

                                                          type DeleteOptions

                                                          type DeleteOptions struct {
                                                          	// GracePeriodSeconds is 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.
                                                          	GracePeriodSeconds *int64
                                                          
                                                          	// Preconditions must be fulfilled before a deletion is carried out. If not
                                                          	// possible, a 409 Conflict status will be returned.
                                                          	Preconditions *metav1.Preconditions
                                                          
                                                          	// PropagationPolicy determined 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.
                                                          	PropagationPolicy *metav1.DeletionPropagation
                                                          
                                                          	// Raw represents raw DeleteOptions, as passed to the API server.
                                                          	Raw *metav1.DeleteOptions
                                                          
                                                          	// 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
                                                          	DryRun []string
                                                          }

                                                            DeleteOptions contains options for delete requests. It's generally a subset of metav1.DeleteOptions.

                                                            func (*DeleteOptions) ApplyOptions

                                                            func (o *DeleteOptions) ApplyOptions(opts []DeleteOption) *DeleteOptions

                                                              ApplyOptions applies the given delete options on these options, and then returns itself (for convenient chaining).

                                                              func (*DeleteOptions) ApplyToDelete

                                                              func (o *DeleteOptions) ApplyToDelete(do *DeleteOptions)

                                                                ApplyToDelete implements DeleteOption

                                                                func (*DeleteOptions) AsDeleteOptions

                                                                func (o *DeleteOptions) AsDeleteOptions() *metav1.DeleteOptions

                                                                  AsDeleteOptions returns these options as a metav1.DeleteOptions. This may mutate the Raw field.

                                                                  type FieldIndexer

                                                                  type FieldIndexer interface {
                                                                  	// IndexFields adds an index with the given field name on the given object type
                                                                  	// by using the given function to extract the value for that field.  If you want
                                                                  	// compatibility with the Kubernetes API server, only return one key, and only use
                                                                  	// fields that the API server supports.  Otherwise, you can return multiple keys,
                                                                  	// and "equality" in the field selector means that at least one key matches the value.
                                                                  	// The FieldIndexer will automatically take care of indexing over namespace
                                                                  	// and supporting efficient all-namespace queries.
                                                                  	IndexField(ctx context.Context, obj Object, field string, extractValue IndexerFunc) error
                                                                  }

                                                                    FieldIndexer knows how to index over a particular "field" such that it can later be used by a field selector.

                                                                    Example (SecretName)

                                                                      This example shows how to set up and consume a field selector over a pod's volumes' secretName field.

                                                                      Output:
                                                                      
                                                                      

                                                                      type FieldOwner

                                                                      type FieldOwner string

                                                                        FieldOwner set the field manager name for the given server-side apply patch.

                                                                        func (FieldOwner) ApplyToCreate

                                                                        func (f FieldOwner) ApplyToCreate(opts *CreateOptions)

                                                                          ApplyToCreate applies this configuration to the given create options.

                                                                          func (FieldOwner) ApplyToPatch

                                                                          func (f FieldOwner) ApplyToPatch(opts *PatchOptions)

                                                                            ApplyToPatch applies this configuration to the given patch options.

                                                                            func (FieldOwner) ApplyToUpdate

                                                                            func (f FieldOwner) ApplyToUpdate(opts *UpdateOptions)

                                                                              ApplyToUpdate applies this configuration to the given update options.

                                                                              type GracePeriodSeconds

                                                                              type GracePeriodSeconds int64

                                                                                GracePeriodSeconds sets the grace period for the deletion to the given number of seconds.

                                                                                func (GracePeriodSeconds) ApplyToDelete

                                                                                func (s GracePeriodSeconds) ApplyToDelete(opts *DeleteOptions)

                                                                                  ApplyToDelete applies this configuration to the given delete options.

                                                                                  func (GracePeriodSeconds) ApplyToDeleteAllOf

                                                                                  func (s GracePeriodSeconds) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                    ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                    type HasLabels

                                                                                    type HasLabels []string

                                                                                      HasLabels filters the list/delete operation checking if the set of labels exists without checking their values.

                                                                                      func (HasLabels) ApplyToDeleteAllOf

                                                                                      func (m HasLabels) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                        ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                        func (HasLabels) ApplyToList

                                                                                        func (m HasLabels) ApplyToList(opts *ListOptions)

                                                                                          ApplyToList applies this configuration to the given list options.

                                                                                          type InNamespace

                                                                                          type InNamespace string

                                                                                            InNamespace restricts the list/delete operation to the given namespace.

                                                                                            func (InNamespace) ApplyToDeleteAllOf

                                                                                            func (n InNamespace) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                              ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                              func (InNamespace) ApplyToList

                                                                                              func (n InNamespace) ApplyToList(opts *ListOptions)

                                                                                                ApplyToList applies this configuration to the given list options.

                                                                                                type IndexerFunc

                                                                                                type IndexerFunc func(Object) []string

                                                                                                  IndexerFunc knows how to take an object and turn it into a series of non-namespaced keys. Namespaced objects are automatically given namespaced and non-spaced variants, so keys do not need to include namespace.

                                                                                                  type Limit

                                                                                                  type Limit int64

                                                                                                    Limit specifies the maximum number of results to return from the server. Limit does not implement DeleteAllOfOption interface because the server does not support setting it for deletecollection operations.

                                                                                                    func (Limit) ApplyToList

                                                                                                    func (l Limit) ApplyToList(opts *ListOptions)

                                                                                                      ApplyToList applies this configuration to the given an list options.

                                                                                                      type ListOption

                                                                                                      type ListOption interface {
                                                                                                      	// ApplyToList applies this configuration to the given list options.
                                                                                                      	ApplyToList(*ListOptions)
                                                                                                      }

                                                                                                        ListOption is some configuration that modifies options for a list request.

                                                                                                        type ListOptions

                                                                                                        type ListOptions struct {
                                                                                                        	// LabelSelector filters results by label.  Use SetLabelSelector to
                                                                                                        	// set from raw string form.
                                                                                                        	LabelSelector labels.Selector
                                                                                                        	// FieldSelector filters results by a particular field.  In order
                                                                                                        	// to use this with cache-based implementations, restrict usage to
                                                                                                        	// a single field-value pair that's been added to the indexers.
                                                                                                        	FieldSelector fields.Selector
                                                                                                        
                                                                                                        	// Namespace represents the namespace to list for, or empty for
                                                                                                        	// non-namespaced objects, or to list across all namespaces.
                                                                                                        	Namespace string
                                                                                                        
                                                                                                        	// Limit specifies the maximum number of results to return from the server. The server may
                                                                                                        	// not support this field on all resource types, but if it does and more results remain it
                                                                                                        	// will set the continue field on the returned list object. This field is not supported if watch
                                                                                                        	// is true in the Raw ListOptions.
                                                                                                        	Limit int64
                                                                                                        	// Continue is a token returned by the server that lets a client retrieve chunks of results
                                                                                                        	// from the server by specifying limit. The server may reject requests for continuation tokens
                                                                                                        	// it does not recognize and will return a 410 error if the token can no longer be used because
                                                                                                        	// it has expired. This field is not supported if watch is true in the Raw ListOptions.
                                                                                                        	Continue string
                                                                                                        
                                                                                                        	// Raw represents raw ListOptions, as passed to the API server.  Note
                                                                                                        	// that these may not be respected by all implementations of interface,
                                                                                                        	// and the LabelSelector, FieldSelector, Limit and Continue fields are ignored.
                                                                                                        	Raw *metav1.ListOptions
                                                                                                        }

                                                                                                          ListOptions contains options for limiting or filtering results. It's generally a subset of metav1.ListOptions, with support for pre-parsed selectors (since generally, selectors will be executed against the cache).

                                                                                                          func (*ListOptions) ApplyOptions

                                                                                                          func (o *ListOptions) ApplyOptions(opts []ListOption) *ListOptions

                                                                                                            ApplyOptions applies the given list options on these options, and then returns itself (for convenient chaining).

                                                                                                            func (*ListOptions) ApplyToList

                                                                                                            func (o *ListOptions) ApplyToList(lo *ListOptions)

                                                                                                              ApplyToList implements ListOption for ListOptions

                                                                                                              func (*ListOptions) AsListOptions

                                                                                                              func (o *ListOptions) AsListOptions() *metav1.ListOptions

                                                                                                                AsListOptions returns these options as a flattened metav1.ListOptions. This may mutate the Raw field.

                                                                                                                type MatchingFields

                                                                                                                type MatchingFields fields.Set

                                                                                                                  MatchingFields filters the list/delete operation on the given field Set (or index in the case of cached lists).

                                                                                                                  func (MatchingFields) ApplyToDeleteAllOf

                                                                                                                  func (m MatchingFields) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                                                    ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                                                    func (MatchingFields) ApplyToList

                                                                                                                    func (m MatchingFields) ApplyToList(opts *ListOptions)

                                                                                                                      ApplyToList applies this configuration to the given list options.

                                                                                                                      type MatchingFieldsSelector

                                                                                                                      type MatchingFieldsSelector struct {
                                                                                                                      	fields.Selector
                                                                                                                      }

                                                                                                                        MatchingFieldsSelector filters the list/delete operation on the given field selector (or index in the case of cached lists). A struct is used because fields.Selector is an interface, which cannot be aliased.

                                                                                                                        func (MatchingFieldsSelector) ApplyToDeleteAllOf

                                                                                                                        func (m MatchingFieldsSelector) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                                                          ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                                                          func (MatchingFieldsSelector) ApplyToList

                                                                                                                          func (m MatchingFieldsSelector) ApplyToList(opts *ListOptions)

                                                                                                                            ApplyToList applies this configuration to the given list options.

                                                                                                                            type MatchingLabels

                                                                                                                            type MatchingLabels map[string]string

                                                                                                                              MatchingLabels filters the list/delete operation on the given set of labels.

                                                                                                                              func (MatchingLabels) ApplyToDeleteAllOf

                                                                                                                              func (m MatchingLabels) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                                                                ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                                                                func (MatchingLabels) ApplyToList

                                                                                                                                func (m MatchingLabels) ApplyToList(opts *ListOptions)

                                                                                                                                  ApplyToList applies this configuration to the given list options.

                                                                                                                                  type MatchingLabelsSelector

                                                                                                                                  type MatchingLabelsSelector struct {
                                                                                                                                  	labels.Selector
                                                                                                                                  }

                                                                                                                                    MatchingLabelsSelector filters the list/delete operation on the given label selector (or index in the case of cached lists). A struct is used because labels.Selector is an interface, which cannot be aliased.

                                                                                                                                    func (MatchingLabelsSelector) ApplyToDeleteAllOf

                                                                                                                                    func (m MatchingLabelsSelector) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                                                                      ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                                                                      func (MatchingLabelsSelector) ApplyToList

                                                                                                                                      func (m MatchingLabelsSelector) ApplyToList(opts *ListOptions)

                                                                                                                                        ApplyToList applies this configuration to the given list options.

                                                                                                                                        type MergeFromOption

                                                                                                                                        type MergeFromOption interface {
                                                                                                                                        	// ApplyToMergeFrom applies this configuration to the given patch options.
                                                                                                                                        	ApplyToMergeFrom(*MergeFromOptions)
                                                                                                                                        }

                                                                                                                                          MergeFromOption is some configuration that modifies options for a merge-from patch data.

                                                                                                                                          type MergeFromOptions

                                                                                                                                          type MergeFromOptions struct {
                                                                                                                                          	// OptimisticLock, when true, includes `metadata.resourceVersion` into the final
                                                                                                                                          	// patch data. If the `resourceVersion` field doesn't match what's stored,
                                                                                                                                          	// the operation results in a conflict and clients will need to try again.
                                                                                                                                          	OptimisticLock bool
                                                                                                                                          }

                                                                                                                                            MergeFromOptions contains options to generate a merge-from patch data.

                                                                                                                                            type MergeFromWithOptimisticLock

                                                                                                                                            type MergeFromWithOptimisticLock struct{}

                                                                                                                                              MergeFromWithOptimisticLock can be used if clients want to make sure a patch is being applied to the latest resource version of an object.

                                                                                                                                              The behavior is similar to what an Update would do, without the need to send the whole object. Usually this method is useful if you might have multiple clients acting on the same object and the same API version, but with different versions of the Go structs.

                                                                                                                                              For example, an "older" copy of a Widget that has fields A and B, and a "newer" copy with A, B, and C. Sending an update using the older struct definition results in C being dropped, whereas using a patch does not.

                                                                                                                                              func (MergeFromWithOptimisticLock) ApplyToMergeFrom

                                                                                                                                              func (m MergeFromWithOptimisticLock) ApplyToMergeFrom(in *MergeFromOptions)

                                                                                                                                                ApplyToMergeFrom applies this configuration to the given patch options.

                                                                                                                                                type NewDelegatingClientInput

                                                                                                                                                type NewDelegatingClientInput struct {
                                                                                                                                                	CacheReader       Reader
                                                                                                                                                	Client            Client
                                                                                                                                                	UncachedObjects   []Object
                                                                                                                                                	CacheUnstructured bool
                                                                                                                                                }

                                                                                                                                                  NewDelegatingClientInput encapsulates the input parameters to create a new delegating client.

                                                                                                                                                  type Object

                                                                                                                                                  type Object interface {
                                                                                                                                                  	metav1.Object
                                                                                                                                                  	runtime.Object
                                                                                                                                                  }

                                                                                                                                                    Object is a Kubernetes object, allows functions to work indistinctly with any resource that implements both Object interfaces.

                                                                                                                                                    Semantically, these are objects which are both serializable (runtime.Object) and identifiable (metav1.Object) -- think any object which you could write as YAML or JSON, and then `kubectl create`.

                                                                                                                                                    Code-wise, this means that any object which embeds both ObjectMeta (which provides metav1.Object) and TypeMeta (which provides half of runtime.Object) and has a `DeepCopyObject` implementation (the other half of runtime.Object) will implement this by default.

                                                                                                                                                    For example, nearly all the built-in types are Objects, as well as all KubeBuilder-generated CRDs (unless you do something real funky to them).

                                                                                                                                                    By and large, most things that implement runtime.Object also implement Object -- it's very rare to have *just* a runtime.Object implementation (the cases tend to be funky built-in types like Webhook payloads that don't have a `metadata` field).

                                                                                                                                                    Notice that XYZList types are distinct: they implement ObjectList instead.

                                                                                                                                                    type ObjectKey

                                                                                                                                                    type ObjectKey = types.NamespacedName

                                                                                                                                                      ObjectKey identifies a Kubernetes Object.

                                                                                                                                                      func ObjectKeyFromObject

                                                                                                                                                      func ObjectKeyFromObject(obj Object) ObjectKey

                                                                                                                                                        ObjectKeyFromObject returns the ObjectKey given a runtime.Object

                                                                                                                                                        type ObjectList

                                                                                                                                                        type ObjectList interface {
                                                                                                                                                        	metav1.ListInterface
                                                                                                                                                        	runtime.Object
                                                                                                                                                        }

                                                                                                                                                          ObjectList is a Kubernetes object list, allows functions to work indistinctly with any resource that implements both runtime.Object and metav1.ListInterface interfaces.

                                                                                                                                                          Semantically, this is any object which may be serialized (ObjectMeta), and is a kubernetes list wrapper (has items, pagination fields, etc) -- think the wrapper used in a response from a `kubectl list --output yaml` call.

                                                                                                                                                          Code-wise, this means that any object which embedds both ListMeta (which provides metav1.ListInterface) and TypeMeta (which provides half of runtime.Object) and has a `DeepCopyObject` implementation (the other half of runtime.Object) will implement this by default.

                                                                                                                                                          For example, nearly all the built-in XYZList types are ObjectLists, as well as the XYZList types for all KubeBuilder-generated CRDs (unless you do something real funky to them).

                                                                                                                                                          By and large, most things that are XYZList and implement runtime.Object also implement ObjectList -- it's very rare to have *just* a runtime.Object implementation (the cases tend to be funky built-in types like Webhook payloads that don't have a `metadata` field).

                                                                                                                                                          This is similar to Object, which is almost always implemented by the items in the list themselves.

                                                                                                                                                          type Options

                                                                                                                                                          type Options struct {
                                                                                                                                                          	// Scheme, if provided, will be used to map go structs to GroupVersionKinds
                                                                                                                                                          	Scheme *runtime.Scheme
                                                                                                                                                          
                                                                                                                                                          	// Mapper, if provided, will be used to map GroupVersionKinds to Resources
                                                                                                                                                          	Mapper meta.RESTMapper
                                                                                                                                                          }

                                                                                                                                                            Options are creation options for a Client

                                                                                                                                                            type Patch

                                                                                                                                                            type Patch interface {
                                                                                                                                                            	// Type is the PatchType of the patch.
                                                                                                                                                            	Type() types.PatchType
                                                                                                                                                            	// Data is the raw data representing the patch.
                                                                                                                                                            	Data(obj runtime.Object) ([]byte, error)
                                                                                                                                                            }

                                                                                                                                                              Patch is a patch that can be applied to a Kubernetes object.

                                                                                                                                                              func MergeFrom

                                                                                                                                                              func MergeFrom(obj runtime.Object) Patch

                                                                                                                                                                MergeFrom creates a Patch that patches using the merge-patch strategy with the given object as base. The difference between MergeFrom and StrategicMergeFrom lays in the handling of modified list fields. When using MergeFrom, existing lists will be completely replaced by new lists. When using StrategicMergeFrom, the list field's `patchStrategy` is respected if specified in the API type, e.g. the existing list is not replaced completely but rather merged with the new one using the list's `patchMergeKey`. See https://kubernetes.io/docs/tasks/manage-kubernetes-objects/update-api-object-kubectl-patch/ for more details on the difference between merge-patch and strategic-merge-patch.

                                                                                                                                                                func MergeFromWithOptions

                                                                                                                                                                func MergeFromWithOptions(obj runtime.Object, opts ...MergeFromOption) Patch

                                                                                                                                                                  MergeFromWithOptions creates a Patch that patches using the merge-patch strategy with the given object as base. See MergeFrom for more details.

                                                                                                                                                                  func RawPatch

                                                                                                                                                                  func RawPatch(patchType types.PatchType, data []byte) Patch

                                                                                                                                                                    RawPatch constructs a new Patch with the given PatchType and data.

                                                                                                                                                                    func StrategicMergeFrom

                                                                                                                                                                    func StrategicMergeFrom(obj Object, opts ...MergeFromOption) Patch

                                                                                                                                                                      StrategicMergeFrom creates a Patch that patches using the strategic-merge-patch strategy with the given object as base. The difference between MergeFrom and StrategicMergeFrom lays in the handling of modified list fields. When using MergeFrom, existing lists will be completely replaced by new lists. When using StrategicMergeFrom, the list field's `patchStrategy` is respected if specified in the API type, e.g. the existing list is not replaced completely but rather merged with the new one using the list's `patchMergeKey`. See https://kubernetes.io/docs/tasks/manage-kubernetes-objects/update-api-object-kubectl-patch/ for more details on the difference between merge-patch and strategic-merge-patch. Please note, that CRDs don't support strategic-merge-patch, see https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#advanced-features-and-flexibility

                                                                                                                                                                      type PatchOption

                                                                                                                                                                      type PatchOption interface {
                                                                                                                                                                      	// ApplyToPatch applies this configuration to the given patch options.
                                                                                                                                                                      	ApplyToPatch(*PatchOptions)
                                                                                                                                                                      }

                                                                                                                                                                        PatchOption is some configuration that modifies options for a patch request.

                                                                                                                                                                        type PatchOptions

                                                                                                                                                                        type PatchOptions struct {
                                                                                                                                                                        	// 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
                                                                                                                                                                        	DryRun []string
                                                                                                                                                                        
                                                                                                                                                                        	// 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
                                                                                                                                                                        
                                                                                                                                                                        	// FieldManager is the name of the user or component submitting
                                                                                                                                                                        	// this request.  It must be set with server-side apply.
                                                                                                                                                                        	FieldManager string
                                                                                                                                                                        
                                                                                                                                                                        	// Raw represents raw PatchOptions, as passed to the API server.
                                                                                                                                                                        	Raw *metav1.PatchOptions
                                                                                                                                                                        }

                                                                                                                                                                          PatchOptions contains options for patch requests.

                                                                                                                                                                          func (*PatchOptions) ApplyOptions

                                                                                                                                                                          func (o *PatchOptions) ApplyOptions(opts []PatchOption) *PatchOptions

                                                                                                                                                                            ApplyOptions applies the given patch options on these options, and then returns itself (for convenient chaining).

                                                                                                                                                                            func (*PatchOptions) ApplyToPatch

                                                                                                                                                                            func (o *PatchOptions) ApplyToPatch(po *PatchOptions)

                                                                                                                                                                              ApplyToPatch implements PatchOptions

                                                                                                                                                                              func (*PatchOptions) AsPatchOptions

                                                                                                                                                                              func (o *PatchOptions) AsPatchOptions() *metav1.PatchOptions

                                                                                                                                                                                AsPatchOptions returns these options as a metav1.PatchOptions. This may mutate the Raw field.

                                                                                                                                                                                type Preconditions

                                                                                                                                                                                type Preconditions metav1.Preconditions

                                                                                                                                                                                  Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.

                                                                                                                                                                                  func (Preconditions) ApplyToDelete

                                                                                                                                                                                  func (p Preconditions) ApplyToDelete(opts *DeleteOptions)

                                                                                                                                                                                    ApplyToDelete applies this configuration to the given delete options.

                                                                                                                                                                                    func (Preconditions) ApplyToDeleteAllOf

                                                                                                                                                                                    func (p Preconditions) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                                                                                                                      ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                                                                                                                      type PropagationPolicy

                                                                                                                                                                                      type PropagationPolicy metav1.DeletionPropagation

                                                                                                                                                                                        PropagationPolicy determined 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.

                                                                                                                                                                                        func (PropagationPolicy) ApplyToDelete

                                                                                                                                                                                        func (p PropagationPolicy) ApplyToDelete(opts *DeleteOptions)

                                                                                                                                                                                          ApplyToDelete applies the given delete options on these options. It will propagate to the dependents of the object to let the garbage collector handle it.

                                                                                                                                                                                          func (PropagationPolicy) ApplyToDeleteAllOf

                                                                                                                                                                                          func (p PropagationPolicy) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

                                                                                                                                                                                            ApplyToDeleteAllOf applies this configuration to the given an List options.

                                                                                                                                                                                            type Reader

                                                                                                                                                                                            type Reader interface {
                                                                                                                                                                                            	// Get retrieves an obj for the given object key from the Kubernetes Cluster.
                                                                                                                                                                                            	// obj must be a struct pointer so that obj can be updated with the response
                                                                                                                                                                                            	// returned by the Server.
                                                                                                                                                                                            	Get(ctx context.Context, key ObjectKey, obj Object) error
                                                                                                                                                                                            
                                                                                                                                                                                            	// List retrieves list of objects for a given namespace and list options. On a
                                                                                                                                                                                            	// successful call, Items field in the list will be populated with the
                                                                                                                                                                                            	// result returned from the server.
                                                                                                                                                                                            	List(ctx context.Context, list ObjectList, opts ...ListOption) error
                                                                                                                                                                                            }

                                                                                                                                                                                              Reader knows how to read and list Kubernetes objects.

                                                                                                                                                                                              type StatusClient

                                                                                                                                                                                              type StatusClient interface {
                                                                                                                                                                                              	Status() StatusWriter
                                                                                                                                                                                              }

                                                                                                                                                                                                StatusClient knows how to create a client which can update status subresource for kubernetes objects.

                                                                                                                                                                                                type StatusWriter

                                                                                                                                                                                                type StatusWriter interface {
                                                                                                                                                                                                	// Update updates the fields corresponding to the status subresource for the
                                                                                                                                                                                                	// given obj. obj must be a struct pointer so that obj can be updated
                                                                                                                                                                                                	// with the content returned by the Server.
                                                                                                                                                                                                	Update(ctx context.Context, obj Object, opts ...UpdateOption) error
                                                                                                                                                                                                
                                                                                                                                                                                                	// Patch patches the given object's subresource. obj must be a struct
                                                                                                                                                                                                	// pointer so that obj can be updated with the content returned by the
                                                                                                                                                                                                	// Server.
                                                                                                                                                                                                	Patch(ctx context.Context, obj Object, patch Patch, opts ...PatchOption) error
                                                                                                                                                                                                }

                                                                                                                                                                                                  StatusWriter knows how to update status subresource of a Kubernetes object.

                                                                                                                                                                                                  type UpdateOption

                                                                                                                                                                                                  type UpdateOption interface {
                                                                                                                                                                                                  	// ApplyToUpdate applies this configuration to the given update options.
                                                                                                                                                                                                  	ApplyToUpdate(*UpdateOptions)
                                                                                                                                                                                                  }

                                                                                                                                                                                                    UpdateOption is some configuration that modifies options for a update request.

                                                                                                                                                                                                    type UpdateOptions

                                                                                                                                                                                                    type UpdateOptions struct {
                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                    	DryRun []string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// FieldManager is the name of the user or component submitting
                                                                                                                                                                                                    	// this request.  It must be set with server-side apply.
                                                                                                                                                                                                    	FieldManager string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// Raw represents raw UpdateOptions, as passed to the API server.
                                                                                                                                                                                                    	Raw *metav1.UpdateOptions
                                                                                                                                                                                                    }

                                                                                                                                                                                                      UpdateOptions contains options for create requests. It's generally a subset of metav1.UpdateOptions.

                                                                                                                                                                                                      func (*UpdateOptions) ApplyOptions

                                                                                                                                                                                                      func (o *UpdateOptions) ApplyOptions(opts []UpdateOption) *UpdateOptions

                                                                                                                                                                                                        ApplyOptions applies the given update options on these options, and then returns itself (for convenient chaining).

                                                                                                                                                                                                        func (*UpdateOptions) ApplyToUpdate

                                                                                                                                                                                                        func (o *UpdateOptions) ApplyToUpdate(uo *UpdateOptions)

                                                                                                                                                                                                          ApplyToUpdate implements UpdateOption

                                                                                                                                                                                                          func (*UpdateOptions) AsUpdateOptions

                                                                                                                                                                                                          func (o *UpdateOptions) AsUpdateOptions() *metav1.UpdateOptions

                                                                                                                                                                                                            AsUpdateOptions returns these options as a metav1.UpdateOptions. This may mutate the Raw field.

                                                                                                                                                                                                            type Writer

                                                                                                                                                                                                            type Writer interface {
                                                                                                                                                                                                            	// Create saves the object obj in the Kubernetes cluster.
                                                                                                                                                                                                            	Create(ctx context.Context, obj Object, opts ...CreateOption) error
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Delete deletes the given obj from Kubernetes cluster.
                                                                                                                                                                                                            	Delete(ctx context.Context, obj Object, opts ...DeleteOption) error
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Update updates the given obj in the Kubernetes cluster. obj must be a
                                                                                                                                                                                                            	// struct pointer so that obj can be updated with the content returned by the Server.
                                                                                                                                                                                                            	Update(ctx context.Context, obj Object, opts ...UpdateOption) error
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Patch patches the given obj in the Kubernetes cluster. obj must be a
                                                                                                                                                                                                            	// struct pointer so that obj can be updated with the content returned by the Server.
                                                                                                                                                                                                            	Patch(ctx context.Context, obj Object, patch Patch, opts ...PatchOption) error
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// DeleteAllOf deletes all objects of the given type matching the given options.
                                                                                                                                                                                                            	DeleteAllOf(ctx context.Context, obj Object, opts ...DeleteAllOfOption) error
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Writer knows how to create, delete, and update Kubernetes objects.

                                                                                                                                                                                                              Directories

                                                                                                                                                                                                              Path Synopsis
                                                                                                                                                                                                              Package apiutil contains utilities for working with raw Kubernetes API machinery, such as creating RESTMappers and raw REST clients, and extracting the GVK of an object.
                                                                                                                                                                                                              Package apiutil contains utilities for working with raw Kubernetes API machinery, such as creating RESTMappers and raw REST clients, and extracting the GVK of an object.
                                                                                                                                                                                                              Package config contains libraries for initializing REST configs for talking to the Kubernetes API
                                                                                                                                                                                                              Package config contains libraries for initializing REST configs for talking to the Kubernetes API
                                                                                                                                                                                                              Package fake provides a fake client for testing.
                                                                                                                                                                                                              Package fake provides a fake client for testing.