Back to godoc.org
sigs.k8s.io/controller-runtime / pkg / client

package client

v0.5.2
Latest Go to latest
Published: Mar 18, 2020 | License: Apache-2.0 | Module: sigs.k8s.io/controller-runtime

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

Variables

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{}
)
var CreateDryRunAll = DryRunAll

CreateDryRunAll sets the "dry run" option to "all".

Deprecated: Use DryRunAll

var DryRunAll = dryRunAll{}

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

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.

var PatchDryRunAll = DryRunAll

PatchDryRunAll sets the "dry run" option to "all".

Deprecated: Use DryRunAll

var UpdateDryRunAll = DryRunAll

UpdateDryRunAll sets the "dry run" option to "all".

Deprecated: Use DryRunAll

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.

type Client

type Client interface {
	Reader
	Writer
	StatusClient
}

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.

Code:

// Using a typed object.
pod := &corev1.Pod{
	ObjectMeta: metav1.ObjectMeta{
		Namespace: "namespace",
		Name:      "name",
	},
	Spec: corev1.PodSpec{
		Containers: []corev1.Container{
			corev1.Container{
				Image: "nginx",
				Name:  "nginx",
			},
		},
	},
}
// c is a created client.
_ = c.Create(context.Background(), pod)

// Using a unstructured object.
u := &unstructured.Unstructured{}
u.Object = map[string]interface{}{
	"name":      "name",
	"namespace": "namespace",
	"spec": map[string]interface{}{
		"replicas": 2,
		"selector": map[string]interface{}{
			"matchLabels": map[string]interface{}{
				"foo": "bar",
			},
		},
		"template": map[string]interface{}{
			"labels": map[string]interface{}{
				"foo": "bar",
			},
			"spec": map[string]interface{}{
				"containers": []map[string]interface{}{
					{
						"name":  "nginx",
						"image": "nginx",
					},
				},
			},
		},
	},
}
u.SetGroupVersionKind(schema.GroupVersionKind{
	Group:   "apps",
	Kind:    "Deployment",
	Version: "v1",
})
_ = c.Create(context.Background(), u)
Example (Delete)

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

Code:

// Using a typed object.
pod := &corev1.Pod{
	ObjectMeta: metav1.ObjectMeta{
		Namespace: "namespace",
		Name:      "name",
	},
}
// c is a created client.
_ = c.Delete(context.Background(), pod)

// Using a unstructured object.
u := &unstructured.Unstructured{}
u.SetName("name")
u.SetNamespace("namespace")
u.SetGroupVersionKind(schema.GroupVersionKind{
	Group:   "apps",
	Kind:    "Deployment",
	Version: "v1",
})
_ = c.Delete(context.Background(), u)
Example (DeleteAllOf)

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

Code:

// Using a typed object.
// c is a created client.
_ = c.DeleteAllOf(context.Background(), &corev1.Pod{}, client.InNamespace("foo"), client.MatchingLabels{"app": "foo"})

// Using an unstructured Object
u := &unstructured.UnstructuredList{}
u.SetGroupVersionKind(schema.GroupVersionKind{
	Group:   "apps",
	Kind:    "Deployment",
	Version: "v1",
})
_ = c.DeleteAllOf(context.Background(), u, client.InNamespace("foo"), client.MatchingLabels{"app": "foo"})
Example (Get)

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

Code:

// Using a typed object.
pod := &corev1.Pod{}
// c is a created client.
_ = c.Get(context.Background(), client.ObjectKey{
	Namespace: "namespace",
	Name:      "name",
}, pod)

// Using a unstructured object.
u := &unstructured.Unstructured{}
u.SetGroupVersionKind(schema.GroupVersionKind{
	Group:   "apps",
	Kind:    "Deployment",
	Version: "v1",
})
_ = c.Get(context.Background(), client.ObjectKey{
	Namespace: "namespace",
	Name:      "name",
}, u)
Example (List)

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

Code:

// Using a typed object.
pod := &corev1.PodList{}
// c is a created client.
_ = c.List(context.Background(), pod)

// Using a unstructured object.
u := &unstructured.UnstructuredList{}
u.SetGroupVersionKind(schema.GroupVersionKind{
	Group:   "apps",
	Kind:    "DeploymentList",
	Version: "v1",
})
_ = c.List(context.Background(), u)
Example (Update)

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

Code:

// Using a typed object.
pod := &corev1.Pod{}
// c is a created client.
_ = c.Get(context.Background(), client.ObjectKey{
	Namespace: "namespace",
	Name:      "name",
}, pod)
pod.SetFinalizers(append(pod.GetFinalizers(), "new-finalizer"))
_ = c.Update(context.Background(), pod)

// Using a unstructured object.
u := &unstructured.Unstructured{}
u.SetGroupVersionKind(schema.GroupVersionKind{
	Group:   "apps",
	Kind:    "Deployment",
	Version: "v1",
})
_ = c.Get(context.Background(), client.ObjectKey{
	Namespace: "namespace",
	Name:      "name",
}, u)
u.SetFinalizers(append(u.GetFinalizers(), "new-finalizer"))
_ = c.Update(context.Background(), u)

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

Code:

cl, err := client.New(config.GetConfigOrDie(), client.Options{})
if err != nil {
	fmt.Println("failed to create client")
	os.Exit(1)
}

podList := &corev1.PodList{}

err = cl.List(context.Background(), podList, client.InNamespace("default"))
if err != nil {
	fmt.Printf("failed to list pods in namespace default: %v\n", err)
	os.Exit(1)
}

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)

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 DelegatingClient

type DelegatingClient struct {
	Reader
	Writer
	StatusClient
}

DelegatingClient 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.

type DelegatingReader

type DelegatingReader struct {
	CacheReader  Reader
	ClientReader Reader
}

DelegatingReader forms a Reader that will cause Get and List requests for unstructured types to use the ClientReader while requests for any other type of object with use the CacheReader. This avoids accidentally caching the entire cluster in the common case of loading arbitrary unstructured objects (e.g. from OwnerReferences).

func (*DelegatingReader) Get

func (d *DelegatingReader) Get(ctx context.Context, key ObjectKey, obj runtime.Object) error

Get retrieves an obj for a given object key from the Kubernetes Cluster.

func (*DelegatingReader) List

func (d *DelegatingReader) List(ctx context.Context, list runtime.Object, opts ...ListOption) error

List retrieves list of objects for a given namespace and list options.

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(obj runtime.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.

Code:

// someIndexer is a FieldIndexer over a Cache
_ = someIndexer.IndexField(&corev1.Pod{}, "spec.volumes.secret.secretName", func(o runtime.Object) []string {
	var res []string
	for _, vol := range o.(*corev1.Pod).Spec.Volumes {
		if vol.Secret == nil {
			continue
		}
		// just return the raw field value -- the indexer will take care of dealing with namespaces for us
		res = append(res, vol.Secret.SecretName)
	}
	return res
})

// elsewhere (e.g. in your reconciler)
mySecretName := "someSecret" // derived from the reconcile.Request, for instance
var podsWithSecrets corev1.PodList
_ = c.List(context.Background(), &podsWithSecrets, client.MatchingFields{"spec.volumes.secret.secretName": mySecretName})

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)

func (FieldOwner) ApplyToPatch

func (f FieldOwner) ApplyToPatch(opts *PatchOptions)

func (FieldOwner) ApplyToUpdate

func (f FieldOwner) ApplyToUpdate(opts *UpdateOptions)

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)

func (GracePeriodSeconds) ApplyToDeleteAllOf

func (s GracePeriodSeconds) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

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)

func (HasLabels) ApplyToList

func (m HasLabels) ApplyToList(opts *ListOptions)

type InNamespace

type InNamespace string

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

func (InNamespace) ApplyToDeleteAllOf

func (n InNamespace) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

func (InNamespace) ApplyToList

func (n InNamespace) ApplyToList(opts *ListOptions)

type IndexerFunc

type IndexerFunc func(runtime.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)

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 MatchingField

func MatchingField(name, val string) MatchingFields

MatchingField filters the list operation on the given field selector (or index in the case of cached lists).

Deprecated: Use MatchingFields

func (MatchingFields) ApplyToDeleteAllOf

func (m MatchingFields) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

func (MatchingFields) ApplyToList

func (m MatchingFields) ApplyToList(opts *ListOptions)

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)

func (MatchingFieldsSelector) ApplyToList

func (m MatchingFieldsSelector) ApplyToList(opts *ListOptions)

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)

func (MatchingLabels) ApplyToList

func (m MatchingLabels) ApplyToList(opts *ListOptions)

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)

func (MatchingLabelsSelector) ApplyToList

func (m MatchingLabelsSelector) ApplyToList(opts *ListOptions)

type ObjectKey

type ObjectKey = types.NamespacedName

ObjectKey identifies a Kubernetes Object.

func ObjectKeyFromObject

func ObjectKeyFromObject(obj runtime.Object) (ObjectKey, error)

ObjectKeyFromObject returns the ObjectKey given a runtime.Object

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 ConstantPatch

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

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

Deprecated: use RawPatch instead

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.

func RawPatch

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

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

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

func (Preconditions) ApplyToDelete

func (p Preconditions) ApplyToDelete(opts *DeleteOptions)

func (Preconditions) ApplyToDeleteAllOf

func (p Preconditions) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

type PropagationPolicy

type PropagationPolicy metav1.DeletionPropagation

func (PropagationPolicy) ApplyToDelete

func (p PropagationPolicy) ApplyToDelete(opts *DeleteOptions)

func (PropagationPolicy) ApplyToDeleteAllOf

func (p PropagationPolicy) ApplyToDeleteAllOf(opts *DeleteAllOfOptions)

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 runtime.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 runtime.Object, 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 runtime.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 runtime.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 runtime.Object, opts ...CreateOption) error

	// Delete deletes the given obj from Kubernetes cluster.
	Delete(ctx context.Context, obj runtime.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 runtime.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 runtime.Object, patch Patch, opts ...PatchOption) error

	// DeleteAllOf deletes all objects of the given type matching the given options.
	DeleteAllOf(ctx context.Context, obj runtime.Object, opts ...DeleteAllOfOption) error
}

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

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier