kubernetes

package
v1.43.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 30, 2022 License: Apache-2.0, BSD-2-Clause, MIT, + 1 more Imports: 63 Imported by: 193

Documentation

Index

Constants

View Source 
const (
	// KubeConfig is the key to the kubeconfig
	KubeConfig = "kubeconfig"
	// AuthClientCertificate references the AuthInfo.ClientCertificate field of a kubeconfig
	AuthClientCertificate = "client-certificate"
	// AuthClientKey references the AuthInfo.ClientKey field of a kubeconfig
	AuthClientKey = "client-key"
	// AuthTokenFile references the AuthInfo.Tokenfile field of a kubeconfig
	AuthTokenFile = "tokenFile"
	// AuthImpersonate references the AuthInfo.Impersonate field of a kubeconfig
	AuthImpersonate = "act-as"
	// AuthProvider references the AuthInfo.AuthProvider field of a kubeconfig
	AuthProvider = "auth-provider"
	// AuthExec references the AuthInfo.Exec field of a kubeconfig
	AuthExec = "exec"
)

Variables

View Source 
var (
	DefaultMergeFuncs = MergeFuncs{
		corev1.SchemeGroupVersion.WithKind("Service").GroupKind(): func(newObj, oldObj *unstructured.Unstructured) {
			newSvcType, found, _ := unstructured.NestedString(newObj.Object, "spec", "type")
			if !found {
				newSvcType = string(corev1.ServiceTypeClusterIP)
				_ = unstructured.SetNestedField(newObj.Object, newSvcType, "spec", "type")
			}

			oldSvcType, found, _ := unstructured.NestedString(oldObj.Object, "spec", "type")
			if !found {
				oldSvcType = string(corev1.ServiceTypeClusterIP)
			}

			annotations, found, _ := unstructured.NestedMap(oldObj.Object, "metadata", "annotations")
			if found {
				mergedAnnotations := make(map[string]interface{})
				for key, value := range annotations {
					annotation := key
					annotationValue := value.(string)
					for _, keepAnnotation := range keepServiceAnnotations() {
						if strings.HasPrefix(annotation, keepAnnotation) {
							mergedAnnotations[annotation] = annotationValue
						}
					}
				}

				newAnnotations, found, _ := unstructured.NestedMap(newObj.Object, "metadata", "annotations")
				if found {
					for key, value := range newAnnotations {
						mergedAnnotations[key] = value.(string)
					}
				}

				_ = unstructured.SetNestedMap(newObj.Object, mergedAnnotations, "metadata", "annotations")
			}

			switch newSvcType {
			case string(corev1.ServiceTypeLoadBalancer), string(corev1.ServiceTypeNodePort):
				oldPorts, found, _ := unstructured.NestedSlice(oldObj.Object, "spec", "ports")
				if !found {

					break
				}

				newPorts, found, _ := unstructured.NestedSlice(newObj.Object, "spec", "ports")
				if !found {

					break
				}

				ports := make([]interface{}, 0, len(newPorts))
				for _, newPort := range newPorts {
					np := newPort.(map[string]interface{})
					npName, _, _ := unstructured.NestedString(np, "name")
					npPort, _ := nestedFloat64OrInt64(np, "port")
					nodePort, ok := nestedFloat64OrInt64(np, "nodePort")

					for _, oldPortObj := range oldPorts {
						op := oldPortObj.(map[string]interface{})
						opName, _, _ := unstructured.NestedString(op, "name")
						opPort, _ := nestedFloat64OrInt64(op, "port")

						if (opName == npName || opPort == npPort) && (!ok || nodePort == 0) {
							np["nodePort"] = op["nodePort"]
						}
					}

					ports = append(ports, np)
				}

				_ = unstructured.SetNestedSlice(newObj.Object, ports, "spec", "ports")

			case string(corev1.ServiceTypeExternalName):

				return
			}

			if oldSvcType != string(corev1.ServiceTypeExternalName) {
				newClusterIP, _, _ := unstructured.NestedString(newObj.Object, "spec", "clusterIP")
				if newClusterIP != corev1.ClusterIPNone || newSvcType != string(corev1.ServiceTypeClusterIP) {
					oldClusterIP, _, _ := unstructured.NestedString(oldObj.Object, "spec", "clusterIP")
					_ = unstructured.SetNestedField(newObj.Object, oldClusterIP, "spec", "clusterIP")
				}
			}

			newETP, _, _ := unstructured.NestedString(newObj.Object, "spec", "externalTrafficPolicy")
			oldETP, _, _ := unstructured.NestedString(oldObj.Object, "spec", "externalTrafficPolicy")

			if oldSvcType == string(corev1.ServiceTypeLoadBalancer) &&
				newSvcType == string(corev1.ServiceTypeLoadBalancer) &&
				newETP == string(corev1.ServiceExternalTrafficPolicyTypeLocal) &&
				oldETP == string(corev1.ServiceExternalTrafficPolicyTypeLocal) {
				newHealthCheckPort, _ := nestedFloat64OrInt64(newObj.Object, "spec", "healthCheckNodePort")
				if newHealthCheckPort == 0 {
					oldHealthCheckPort, _ := nestedFloat64OrInt64(oldObj.Object, "spec", "healthCheckNodePort")
					_ = unstructured.SetNestedField(newObj.Object, oldHealthCheckPort, "spec", "healthCheckNodePort")
				}
			}

		},
		corev1.SchemeGroupVersion.WithKind("ServiceAccount").GroupKind(): func(newObj, oldObj *unstructured.Unstructured) {

			newObj.Object["secrets"] = oldObj.Object["secrets"]
			newObj.Object["imagePullSecrets"] = oldObj.Object["imagePullSecrets"]
		},
		{Group: "autoscaling.k8s.io", Kind: "VerticalPodAutoscaler"}: func(newObj, oldObj *unstructured.Unstructured) {

			if oldStatus := oldObj.Object["status"]; oldStatus != nil {
				newObj.Object["status"] = oldStatus
			}
		},
	}

	DeploymentKeepReplicasMergeFunc = MergeFunc(func(newObj, oldObj *unstructured.Unstructured) {
		oldReplicas, ok := nestedFloat64OrInt64(oldObj.Object, "spec", "replicas")
		if !ok {
			return
		}
		_ = unstructured.SetNestedField(newObj.Object, oldReplicas, "spec", "replicas")
	})
)

DefaultMergeFuncs contains options for common k8s objects, e.g. Service, ServiceAccount.

View Source 
var (
	// GardenScheme is the scheme used in the Garden cluster.
	GardenScheme = runtime.NewScheme()
	// SeedScheme is the scheme used in the Seed cluster.
	SeedScheme = runtime.NewScheme()
	// ShootScheme is the scheme used in the Shoot cluster.
	ShootScheme = runtime.NewScheme()
	// PlantScheme is the scheme used in the Plant cluster
	PlantScheme = runtime.NewScheme()

	// DefaultDeleteOptions use foreground propagation policy and grace period of 60 seconds.
	DefaultDeleteOptions = []client.DeleteOption{
		client.PropagationPolicy(metav1.DeletePropagationForeground),
		client.GracePeriodSeconds(60),
	}
	// ForceDeleteOptions use background propagation policy and grace period of 0 seconds.
	ForceDeleteOptions = []client.DeleteOption{
		client.PropagationPolicy(metav1.DeletePropagationBackground),
		client.GracePeriodSeconds(0),
	}

	// GardenCodec is a codec factory using the Garden scheme.
	GardenCodec = serializer.NewCodecFactory(GardenScheme)

	// SeedSerializer is a YAML serializer using the Seed scheme.
	SeedSerializer = json.NewSerializerWithOptions(json.DefaultMetaFactory, SeedScheme, SeedScheme, json.SerializerOptions{Yaml: true, Pretty: false, Strict: false})
	// SeedCodec is a codec factory using the Seed scheme.
	SeedCodec = serializer.NewCodecFactory(SeedScheme)

	// ShootSerializer is a YAML serializer using the Shoot scheme.
	ShootSerializer = json.NewSerializerWithOptions(json.DefaultMetaFactory, ShootScheme, ShootScheme, json.SerializerOptions{Yaml: true, Pretty: false, Strict: false})
	// ShootCodec is a codec factory using the Shoot scheme.
	ShootCodec = serializer.NewCodecFactory(ShootScheme)
)
View Source 
var ForceNamespace = forceNamespace{}

ForceNamespace can be used for native chart objects do not come with a Release.Namespace option and leave the namespace field empty.

View Source 
var (
	// UseCachedRuntimeClients is a flag for enabling cached controller-runtime clients. The CachedRuntimeClients feature
	// gate (enabled by default sinde v1.34) causes this flag to be set to true.
	// If enabled, the client returned by Interface.Client() will be backed by Interface.Cache(), otherwise it will talk
	// directly to the API server.
	UseCachedRuntimeClients = false
)
View Source 
var Values = func(values interface{}) ValueOption { return &withValue{values} }

Values applies values to ApplyOptions or DeleteOptions.

Functions

func AggregatorCacheFunc added in v1.20.0 

func AggregatorCacheFunc(newCache cache.NewCacheFunc, typeToNewCache map[client.Object]cache.NewCacheFunc, scheme *runtime.Scheme) cache.NewCacheFunc

AggregatorCacheFunc returns a `cache.NewCacheFunc` which creates a cache that holds different cache implementations depending on the objects' GVKs.

func CheckForwardPodPort added in v1.32.0 

func CheckForwardPodPort(fw PortForwarder) error

CheckForwardPodPort tries to open a portForward connection with the passed PortForwarder. It returns nil if the port forward connection has been established successfully or an error otherwise.

func DefaultCreateOptions added in v1.11.0 

func DefaultCreateOptions() metav1.CreateOptions

DefaultCreateOptions are the default options for CREATE requests.

func DefaultGetOptions added in v1.11.0 

func DefaultGetOptions() metav1.GetOptions

DefaultGetOptions are the default options for GET requests.

func DefaultUpdateOptions added in v1.11.0 

func DefaultUpdateOptions() metav1.UpdateOptions

DefaultUpdateOptions are the default options for UPDATE requests.

func GetPodLogs 

func GetPodLogs(ctx context.Context, podInterface corev1client.PodInterface, name string, options *corev1.PodLogOptions) ([]byte, error)

GetPodLogs retrieves the pod logs of the pod of the given name with the given options.

func HasDeploymentRolloutCompleted added in v1.8.0 

func HasDeploymentRolloutCompleted(ctx context.Context, c client.Client, namespace, name string) (bool, error)

HasDeploymentRolloutCompleted checks for the number of updated & available replicas to be equal to the deployment's desired replicas count. Thus confirming a successful rollout of the deployment.

func NewRuntimeCache added in v1.7.0 

func NewRuntimeCache(config *rest.Config, options cache.Options) (cache.Cache, error)

NewRuntimeCache creates a new cache.Cache with the given config and options. It can be used for creating new controller-runtime clients with caches.

func NewRuntimeClientWithCache added in v1.7.0 

func NewRuntimeClientWithCache(ctx context.Context, config *rest.Config, options client.Options, uncachedObjects ...client.Object) (client.Client, error)

NewRuntimeClientWithCache creates a new client.client with the given config and options. The client uses a new cache, which will be started immediately using the given context.

func RESTConfigFromClientConnectionConfiguration added in v0.33.0 

func RESTConfigFromClientConnectionConfiguration(cfg *componentbaseconfig.ClientConnectionConfiguration, kubeconfig []byte, allowedFields ...string) (*rest.Config, error)

RESTConfigFromClientConnectionConfiguration creates a *rest.Config from a componentbaseconfig.ClientConnectionConfiguration and the configured kubeconfig. Allowed fields are not considered unsupported if used in the kubeconfig.

func RESTConfigFromKubeconfig added in v1.10.0 

func RESTConfigFromKubeconfig(kubeconfig []byte, allowedFields ...string) (*rest.Config, error)

RESTConfigFromKubeconfig returns a rest.Config from the bytes of a kubeconfig. Allowed fields are not considered unsupported if used in the kubeconfig.

func ScaleDeployment 

func ScaleDeployment(ctx context.Context, c client.Client, key client.ObjectKey, replicas int32) error

ScaleDeployment scales a Deployment.

func ScaleStatefulSet 

func ScaleStatefulSet(ctx context.Context, c client.Client, key client.ObjectKey, replicas int32) error

ScaleStatefulSet scales a StatefulSet.

func ScaleStatefulSetAndWaitUntilScaled added in v1.43.0 

func ScaleStatefulSetAndWaitUntilScaled(ctx context.Context, c client.Client, key client.ObjectKey, replicas int32) error

ScaleStatefulSetAndWaitUntilScaled scales a StatefulSet and wait until is scaled.

func ValidateConfig added in v0.33.0 

func ValidateConfig(config clientcmdapi.Config) error

ValidateConfig validates that the auth info of a given kubeconfig doesn't have unsupported fields.

func ValidateConfigWithAllowList added in v1.38.0 

func ValidateConfigWithAllowList(config clientcmdapi.Config, allowedFields []string) error

ValidateConfigWithAllowList validates that the auth info of a given kubeconfig doesn't have unsupported fields. It takes an additional list of allowed fields.

func WaitUntilDeploymentRolloutIsComplete added in v1.8.0 

func WaitUntilDeploymentRolloutIsComplete(ctx context.Context, client client.Client, namespace string, name string, interval, timeout time.Duration) error

WaitUntilDeploymentRolloutIsComplete waits for the number of updated & available replicas to be equal to the deployment's desired replicas count. It keeps retrying until timeout

func WaitUntilDeploymentScaledToDesiredReplicas added in v1.17.0 

func WaitUntilDeploymentScaledToDesiredReplicas(ctx context.Context, client client.Client, key types.NamespacedName, desiredReplicas int32) error

WaitUntilDeploymentScaledToDesiredReplicas waits for the number of available replicas to be equal to the deployment's desired replicas count.

func WaitUntilStatefulSetScaledToDesiredReplicas added in v1.43.0 

func WaitUntilStatefulSetScaledToDesiredReplicas(ctx context.Context, client client.Client, key types.NamespacedName, desiredReplicas int32) error

WaitUntilStatefulSetScaledToDesiredReplicas waits for the number of available replicas to be equal to the StatefulSet's desired replicas count.

Types

type Applier 

type Applier interface {
	ApplyManifest(ctx context.Context, unstructured UnstructuredReader, options MergeFuncs) error
	DeleteManifest(ctx context.Context, unstructured UnstructuredReader, opts ...DeleteManifestOption) error
}

Applier is an interface which describes declarative operations to apply multiple Kubernetes objects.

func NewApplier added in v1.6.0 

func NewApplier(c client.Client, restMapper meta.RESTMapper) Applier

NewApplier constructs a new Applier from the given client.

func NewApplierForConfig 

func NewApplierForConfig(config *rest.Config) (Applier, error)

NewApplierForConfig creates a new Applier for the given rest.Config. Use NewApplier if you already have a client and RESTMapper at hand, as this will create a new direct client.

type ApplyOption added in v1.2.0 

type ApplyOption interface {
	// MutateApplyOptions applies this configuration to the given apply options.
	MutateApplyOptions(opts *ApplyOptions)
}

ApplyOption is some configuration that modifies options for a apply request.

type ApplyOptions added in v1.2.0 

type ApplyOptions struct {
	// Values to pass to chart.
	Values interface{}

	// Additional MergeFunctions.
	MergeFuncs MergeFuncs

	// Forces the namespace for chart objects when applying the chart, this is because sometimes native chart
	// objects do not come with a Release.Namespace option and leave the namespace field empty
	ForceNamespace bool
}

ApplyOptions contains options for apply requests

type ChartApplier 

type ChartApplier interface {
	chartrenderer.Interface
	Apply(ctx context.Context, chartPath, namespace, name string, opts ...ApplyOption) error
	Delete(ctx context.Context, chartPath, namespace, name string, opts ...DeleteOption) error
}

ChartApplier is an interface that describes needed methods that render and apply Helm charts in Kubernetes clusters.

func NewChartApplier 

func NewChartApplier(renderer chartrenderer.Interface, applier Applier) ChartApplier

NewChartApplier returns a new chart applier.

func NewChartApplierForConfig 

func NewChartApplierForConfig(config *rest.Config) (ChartApplier, error)

NewChartApplierForConfig returns a new chart applier based on the given REST config.

type Config added in v1.11.0 

type Config struct {
	// contains filtered or unexported fields
}

Config carries options for new ClientSets.

func NewConfig added in v1.11.0 

func NewConfig() *Config

NewConfig returns a new Config with an empty REST config to allow testing ConfigFuncs without exporting the fields of the Config type.

type ConfigFunc 

type ConfigFunc func(config *Config) error

ConfigFunc is a function that mutates a Config struct. It implements the functional options pattern. See https://github.com/tmrts/go-patterns/blob/master/idiom/functional-options.md.

func WithAllowedUserFields added in v1.38.0 

func WithAllowedUserFields(allowedUserFields []string) ConfigFunc

WithAllowedUserFields allows to specify additional kubeconfig.user fields allowed during validation.

func WithCacheResyncPeriod added in v1.7.0 

func WithCacheResyncPeriod(resync time.Duration) ConfigFunc

WithCacheResyncPeriod returns a ConfigFunc that set the client's cache's resync period to the given duration.

func WithClientConfig added in v1.38.0 

func WithClientConfig(clientConfig clientcmd.ClientConfig) ConfigFunc

WithClientConfig adds a ClientConfig for validation at a later stage.

func WithClientConnectionOptions 

func WithClientConnectionOptions(cfg baseconfig.ClientConnectionConfiguration) ConfigFunc

WithClientConnectionOptions returns a ConfigFunc that transfers settings from the passed ClientConnectionConfiguration. The kubeconfig location in ClientConnectionConfiguration is disregarded, though!

func WithClientOptions 

func WithClientOptions(opt client.Options) ConfigFunc

WithClientOptions returns a ConfigFunc that sets the passed Options on the Config object.

func WithDisabledCachedClient added in v1.8.0 

func WithDisabledCachedClient() ConfigFunc

WithDisabledCachedClient disables the cache in the controller-runtime client, so Client() will talk directly to the API server.

func WithNewCacheFunc added in v1.20.0 

func WithNewCacheFunc(fn cache.NewCacheFunc) ConfigFunc

WithNewCacheFunc allows to set the function which is used to create a new cache.

func WithRESTConfig 

func WithRESTConfig(restConfig *rest.Config) ConfigFunc

WithRESTConfig returns a ConfigFunc that sets the passed rest.Config on the Config object.

func WithUncached added in v1.16.0 

func WithUncached(objs ...client.Object) ConfigFunc

WithUncached disables the cached client for the specified objects' GroupKinds.

type DeleteManifestOption added in v1.7.0 

type DeleteManifestOption interface {
	// MutateDeleteManifestOptions applies this configuration to the given delete options.
	MutateDeleteManifestOptions(opts *DeleteManifestOptions)
}

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

type DeleteManifestOptions added in v1.7.0 

type DeleteManifestOptions struct {
	// TolerateErrorFuncs are functions for which errors are tolerated.
	TolerateErrorFuncs []TolerateErrorFunc
}

DeleteManifestOptions contains options for delete requests.

type DeleteOption added in v1.2.0 

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

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

type DeleteOptions added in v1.2.0 

type DeleteOptions struct {
	// Values to pass to chart.
	Values interface{}

	// Forces the namespace for chart objects when applying the chart, this is because sometimes native chart
	// objects do not come with a Release.Namespace option and leave the namespace field empty
	ForceNamespace bool

	// TolerateErrorFuncs are functions for which errors are tolerated.
	TolerateErrorFuncs []TolerateErrorFunc
}

DeleteOptions contains options for delete requests

type Interface 

type Interface interface {
	RESTConfig() *rest.Config
	RESTClient() rest.Interface

	// Client returns the ClientSet's controller-runtime client. This client should be used by default, as it carries
	// a cache, which uses SharedIndexInformers to keep up-to-date.
	Client() client.Client
	// APIReader returns a client.Reader that directly reads from the API server.
	// Wherever possible, try to avoid reading directly from the API server and instead rely on the cache. Some ideas:
	// If you want to avoid conflicts, try using patch requests that don't require optimistic locking instead of reading
	// from the APIReader. If you need to make sure, that you're not reading stale data (e.g. a previous update is
	// observed), use some mechanism that can detect/tolerate stale reads (e.g. add a timestamp annotation during the
	// write operation and wait until you see it in the cache).
	APIReader() client.Reader
	// Cache returns the ClientSet's controller-runtime cache. It can be used to get Informers for arbitrary objects.
	Cache() cache.Cache

	// Applier returns an Applier which uses the ClientSet's client.
	Applier() Applier
	// ChartRenderer returns a ChartRenderer populated with the cluster's Capabilities.
	ChartRenderer() chartrenderer.Interface
	// ChartApplier returns a ChartApplier using the ClientSet's ChartRenderer and Applier.
	ChartApplier() ChartApplier

	Kubernetes() kubernetesclientset.Interface

	// Version returns the server version of the targeted Kubernetes cluster.
	Version() string
	// DiscoverVersion tries to retrieve the server version of the targeted Kubernetes cluster and updates the
	// ClientSet's saved version accordingly. Use Version if you only want to retrieve the kubernetes version instead
	// of refreshing the ClientSet's saved version.
	DiscoverVersion() (*version.Info, error)

	// Start starts the cache of the ClientSet's controller-runtime client and returns immediately.
	// It must be called first before using the client to retrieve objects from the API server.
	Start(ctx context.Context)
	// WaitForCacheSync waits for the cache of the ClientSet's controller-runtime client to be synced.
	WaitForCacheSync(ctx context.Context) bool
}

Interface is used to wrap the interactions with a Kubernetes cluster (which are performed with the help of kubernetes/client-go) in order to allow the implementation of several Kubernetes versions.

func NewClientFromBytes 

func NewClientFromBytes(kubeconfig []byte, fns ...ConfigFunc) (Interface, error)

NewClientFromBytes creates a new Client struct for a given kubeconfig byte slice.

func NewClientFromFile 

func NewClientFromFile(masterURL, kubeconfigPath string, fns ...ConfigFunc) (Interface, error)

NewClientFromFile creates a new Client struct for a given kubeconfig. The kubeconfig will be read from the filesystem at location <kubeconfigPath>. If given, <masterURL> overrides the master URL in the kubeconfig. If no filepath is given, the in-cluster configuration will be taken into account.

func NewClientFromSecret 

func NewClientFromSecret(ctx context.Context, c client.Client, namespace, secretName string, fns ...ConfigFunc) (Interface, error)

NewClientFromSecret creates a new Client struct for a given kubeconfig stored as a Secret in an existing Kubernetes cluster. This cluster will be accessed by the <k8sClient>. It will read the Secret <secretName> in <namespace>. The Secret must contain a field "kubeconfig" which will be used.

func NewClientFromSecretObject 

func NewClientFromSecretObject(secret *corev1.Secret, fns ...ConfigFunc) (Interface, error)

NewClientFromSecretObject creates a new Client struct for a given Kubernetes Secret object. The Secret must contain a field "kubeconfig" which will be used.

func NewWithConfig 

func NewWithConfig(fns ...ConfigFunc) (Interface, error)

NewWithConfig returns a new Kubernetes base client.

type MergeFunc 

type MergeFunc func(newObj, oldObj *unstructured.Unstructured)

MergeFunc determines how oldOj is merged into new oldObj.

type MergeFuncs added in v1.2.0 

type MergeFuncs map[schema.GroupKind]MergeFunc

MergeFuncs can be used modify the default merge functions for ApplyOptions: 

Apply(ctx, "chart", "my-ns", "my-release", MergeFuncs{
		corev1.SchemeGroupVersion.WithKind("Service").GroupKind(): func(newObj, oldObj *unstructured.Unstructured) {
			newObj.SetAnnotations(map[string]string{"foo":"bar"})
		}
})

func CopyApplierOptions 

func CopyApplierOptions(in MergeFuncs) MergeFuncs

CopyApplierOptions returns a copies of the provided applier options.

func (MergeFuncs) MutateApplyOptions added in v1.2.0 

func (m MergeFuncs) MutateApplyOptions(opts *ApplyOptions)

MutateApplyOptions applies this configuration to the given apply options.

type PodExecutor 

type PodExecutor interface {
	Execute(namespace, name, containerName, command, commandArg string) (io.Reader, error)
}

PodExecutor is the pod executor interface

func NewPodExecutor 

func NewPodExecutor(config *rest.Config) PodExecutor

NewPodExecutor returns a podExecutor

type PortForwarder added in v1.32.0 

type PortForwarder interface {
	ForwardPorts() error
	Ready() chan struct{}
}

PortForwarder knows how to forward a port connection Ready channel is expected to be closed once the connection becomes ready

func SetupPortForwarder added in v1.32.0 

func SetupPortForwarder(ctx context.Context, config *rest.Config, namespace, name string, local, remote int) (PortForwarder, error)

SetupPortForwarder sets up a PortForwarder which forwards the <remote> port of the pod with name <name> in namespace <namespace> to the <local> port. If <local> equals zero, a free port will be chosen randomly. When calling ForwardPorts on the returned PortForwarder, it will run until the given context is cancelled. Hence, the given context should carry a timeout and should be cancelled once the forwarding is no longer needed.

type TolerateErrorFunc added in v1.7.0 

type TolerateErrorFunc func(err error) bool

TolerateErrorFunc is a function for which err is tolerated.

func (TolerateErrorFunc) MutateDeleteManifestOptions added in v1.7.0 

func (t TolerateErrorFunc) MutateDeleteManifestOptions(opts *DeleteManifestOptions)

MutateDeleteManifestOptions applies this configuration to the given delete manifest options.

func (TolerateErrorFunc) MutateDeleteOptions added in v1.7.0 

func (t TolerateErrorFunc) MutateDeleteOptions(opts *DeleteOptions)

MutateDeleteOptions applies this configuration to the given delete options.

type UnstructuredReader 

type UnstructuredReader interface {
	Read() (*unstructured.Unstructured, error)
}

UnstructuredReader an interface that all manifest readers should implement

func NewManifestReader 

func NewManifestReader(manifest []byte) UnstructuredReader

NewManifestReader initializes a reader for yaml manifests

func NewNamespaceSettingReader 

func NewNamespaceSettingReader(mReader UnstructuredReader, namespace string) UnstructuredReader

NewNamespaceSettingReader initializes a reader for yaml manifests with support for setting the namespace

func NewObjectReferenceReader 

func NewObjectReferenceReader(objectReference *corev1.ObjectReference) UnstructuredReader

NewObjectReferenceReader initializes a reader from ObjectReference

type ValueOption added in v1.2.0 

type ValueOption interface {
	ApplyOption
	DeleteOption
}

ValueOption contains value options for Apply and Delete.

Source Files

View all Source files

Directories

Path Synopsis
builder
fake
internal
keys
mock
Package mock is a generated GoMock package.
 Package mock is a generated GoMock package.
Package mock is a generated GoMock package.
 Package mock is a generated GoMock package.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.