filters

Documentation

Index

• func FieldPath(p string, data map[string]string) ([]string, error)
• func FilterAll(f yaml.Filter) kio.Filter
• func FilterOne(f kio.Filter) yaml.Filter
• func Flatten(schema *spec.Schema) kio.Filter
• func Has(functions ...yaml.Filter) yaml.Filter
• func InstallOrder() kio.Filter
• func PipeOne(r kio.Reader, f ...yaml.Filter) (*yaml.RNode, error)
• func ResetStyle() yaml.Filter
• func SetNamespace(namespace string) yaml.Filter
• func SetPath(p string, v *yaml.RNode) yaml.Filter
• func SetValues(nameValue []string, forceString bool) yaml.Filter
• func SortByKind(priority []string) kio.Filter
• func UninstallOrder() kio.Filter
• func When(condition bool, filter yaml.Filter) yaml.Filter
• func WithContext(ctx context.Context, f ContextFilterFunc) yaml.Filter
• type ApplicationFilter
  • func (f *ApplicationFilter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error)
• type ContextFilterFunc
• type PatchFilter
  • func (f *PatchFilter) Filter(node *yaml.RNode) (*yaml.RNode, error)
• type Pipeline
  • func (p *Pipeline) Execute() error
  • func (p *Pipeline) Read() ([]*yaml.RNode, error)
• type ResourceMetaFilter
  • func (f *ResourceMetaFilter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error)
• type TeeMatchedFilter
  • func TeeMatched(pathMatcher yaml.PathMatcher, filters ...yaml.Filter) TeeMatchedFilter
  • func (f TeeMatchedFilter) Filter(rn *yaml.RNode) (*yaml.RNode, error)
• type UnsupportedPatchError
  • func (e *UnsupportedPatchError) Error() string
• type WorkloadFilter
  • func (f *WorkloadFilter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error)

Functions

func FieldPath

func FieldPath(p string, data map[string]string) ([]string, error)

FieldPath evaluates a path template using the supplied context and then splits it into individual path segments (honoring escaped delimiters).

func FilterAll

func FilterAll(f yaml.Filter) kio.Filter

FilterAll is similar to `kio.FilterAll` except instead of evaluating for side effects, only the non-nil nodes returned by the filter are preserved.

func FilterOne

func FilterOne(f kio.Filter) yaml.Filter

FilterOne is the opposite of kio.FilterAll, useful if you have a filter that is optimized for filtering batches of nodes, but you just need to call `Pipe` on a single node.

func Flatten

func Flatten(schema *spec.Schema) kio.Filter

Flatten never returns more than a single node, every other node is merged into that first node using the supplied schema

func Has

func Has(functions ...yaml.Filter) yaml.Filter

Has is similar to `yaml.Tee` except it only produces a result if the supplied functions evaluate to a non-nil result.

func InstallOrder

func InstallOrder() kio.Filter

InstallOrder returns a filter that sorts nodes in the order in which they should be created in a cluster. This uses the Helm ordering which is more complete than the Kustomize ordering.

func PipeOne

func PipeOne(r kio.Reader, f ...yaml.Filter) (*yaml.RNode, error)

PipeOne acts as a pipeline for a single node. If the supplied reader produces more than one node, this will fail.

func ResetStyle

func ResetStyle() yaml.Filter

ResetStyle clears the style from the YAML nodes. This is one way to make parsing JSON into more useful YAML.

func SetNamespace

func SetNamespace(namespace string) yaml.Filter

SetNamespace is like `SetK8sNamespace` except it skips cluster scoped resources.

func SetPath

func SetPath(p string, v *yaml.RNode) yaml.Filter

SetPath returns a filter that sets the node value at the specified path. Note that this path uses "." separators rather then "/".

func SetValues

func SetValues(nameValue []string, forceString bool) yaml.Filter

SetValues returns a filter that sets the supplied "path=value" specifications onto incoming nodes. Use forceString to bypass tagging the node values.

func SortByKind

func SortByKind(priority []string) kio.Filter

SortByKind returns a filter that sorts nodes based on the supplied list of kinds.

func UninstallOrder

func UninstallOrder() kio.Filter

UninstallOrder returns a filter that sorts nodes in the order in which they should be deleted from a cluster. This is not directly the reverse of the installation order.

func When

func When(condition bool, filter yaml.Filter) yaml.Filter

When is used for conditionally constructing filter chains. Unlike other filters, the condition is evaluated before the pipeline is executed. This is primarily useful to avoid needing to declare a pipeline as a slice of filters which is then built up conditionally.

func WithContext

func WithContext(ctx context.Context, f ContextFilterFunc) yaml.Filter

WithContext binds a context to a context filter function.

Types

type ApplicationFilter

type ApplicationFilter struct {
	// Flag indicating if this filter should act as a pass-through.
	Enabled bool
	// Flag indicating we should show resources which do not belong to an application.
	ShowUnownedResources bool
	// The ordered names of the labels that contains the application name, default is "app.kubernetes.io/name, k8s-app, app".
	ApplicationNameLabels []string
	// The name of the label that contains the application instance name, default is "app.kubernetes.io/instance".
	ApplicationInstanceLabel string
}

ApplicationFilter produces applications based on the observed resources.

func (*ApplicationFilter) Filter

func (f *ApplicationFilter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error)

Filter keeps all the application resources and creates application resources for all other nodes that are not associated with an application.

type ContextFilterFunc

type ContextFilterFunc func(context.Context, *yaml.RNode) (*yaml.RNode, error)

ContextFilterFunc is a context-aware YAML filter function.

type PatchFilter

type PatchFilter struct {
	// The media type of the patch being applied.
	PatchType string
	// The actual raw patch.
	PatchData []byte
}

PatchFilter is used to apply an arbitrary patch.

func (*PatchFilter) Filter

func (f *PatchFilter) Filter(node *yaml.RNode) (*yaml.RNode, error)

Filter applies the configured patch.

type Pipeline

type Pipeline struct {
	Inputs                []kio.Reader
	Filters               []kio.Filter
	Outputs               []kio.Writer
	ContinueOnEmptyResult bool
}

Pipeline is an alternate to the kio.Pipeline. This pipeline has the following differences: 1. The read/filter is separated so this pipeline can be used as a reader in another pipeline 2. This pipeline does not try to reconcile Kustomize annotations 3. This pipeline does not support callbacks 4. This pipeline implicitly clears empty annotations

func (*Pipeline) Execute

func (p *Pipeline) Execute() error

Execute reads and filters the nodes before sending them to the writers.

func (*Pipeline) Read

func (p *Pipeline) Read() ([]*yaml.RNode, error)

Read evaluates the inputs and filters, ignoring the writers.

type ResourceMetaFilter

type ResourceMetaFilter struct {
	// Regular expression matching the group.
	Group string `json:"group,omitempty" yaml:"group,omitempty"`
	// Regular expression matching the version.
	Version string `json:"version,omitempty" yaml:"version,omitempty"`
	// Regular expression matching the kind.
	Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
	// Regular expression matching the namespace.
	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
	// Regular expression matching the name.
	Name string `json:"name,omitempty" yaml:"name,omitempty"`
	// Kubernetes selector matching labels.
	LabelSelector string `json:"labelSelector,omitempty" yaml:"labelSelector,omitempty"`
	// Kubernetes selector matching annotations
	AnnotationSelector string `json:"annotationSelector,omitempty" yaml:"annotationSelector,omitempty"`

	// Invert the matching behavior (i.e. keep non-matching nodes).
	InvertMatch bool `json:"invertMatch,omitempty" yaml:"invertMatch,omitempty"`
}

ResourceMetaFilter filters nodes based on their resource metadata using regular expressions or Kubernetes selectors.

func (*ResourceMetaFilter) Filter

func (f *ResourceMetaFilter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error)

type TeeMatchedFilter

type TeeMatchedFilter struct {
	PathMatcher yaml.PathMatcher
	Filters     []yaml.Filter
}

TeeMatchedFilter is a filter that applies a set of filters to the nodes matched by a path matcher.

func TeeMatched

func TeeMatched(pathMatcher yaml.PathMatcher, filters ...yaml.Filter) TeeMatchedFilter

TeeMatched acts as a "tee" filter for nodes matched by the supplied path matcher: each matched node is processed by the supplied filters and the result of the entire operation is the initial node (or an error).

func (TeeMatchedFilter) Filter

func (f TeeMatchedFilter) Filter(rn *yaml.RNode) (*yaml.RNode, error)

Filter always returns the supplied node, however all matching nodes will have been processed by the configured filters.

type UnsupportedPatchError

type UnsupportedPatchError struct {
	PatchType string
}

UnsupportedPatchError is raised when a patch format is not recognized.

func (*UnsupportedPatchError) Error

func (e *UnsupportedPatchError) Error() string

type WorkloadFilter

type WorkloadFilter struct {
	// Flag indicating if this filter should act as a pass-through.
	Enabled bool
	// Secondary filter which can be optionally used to accept non-workload resources.
	NonWorkloadFilter *ResourceMetaFilter
}

WorkloadFilter keeps only workload resources, i.e. those that directly or indirectly own pods. For this filter to work, all intermediate resources must be present and must have owner metadata specified.

func (*WorkloadFilter) Filter

func (f *WorkloadFilter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error)

Filter keeps all the workload resources.