apply

Documentation

Index

• type Applier
  • func NewApplier(factory util.Factory, ioStreams genericclioptions.IOStreams) *Applier
  • func (a *Applier) Initialize(cmd *cobra.Command) error
  • func (a *Applier) Run(ctx context.Context, objects []*resource.Info, options Options) <-chan event.Event
  • func (a *Applier) SetFlags(cmd *cobra.Command) error
• type BasicPrinter
  • func (b *BasicPrinter) Print(ch <-chan event.Event, preview bool)
• type Destroyer
  • func NewDestroyer(factory util.Factory, ioStreams genericclioptions.IOStreams) *Destroyer
  • func (d *Destroyer) Initialize(cmd *cobra.Command, paths []string) error
  • func (d *Destroyer) Run() <-chan event.Event
  • func (d *Destroyer) SetFlags(cmd *cobra.Command) error
• type Options
• type ResourceObjects
  • func (r *ResourceObjects) AllIds() []object.ObjMetadata
  • func (r *ResourceObjects) IdsForApply() []object.ObjMetadata
  • func (r *ResourceObjects) IdsForPrune() []object.ObjMetadata
  • func (r *ResourceObjects) InfosForApply() []*resource.Info

Types

type Applier

type Applier struct {
	ApplyOptions *apply.ApplyOptions
	PruneOptions *prune.PruneOptions
	StatusPoller poller.Poller

	// InventoryFactoryFunc wraps and returns an interface for the
	// object which will load and store the inventory.
	InventoryFactoryFunc func(*resource.Info) inventory.Inventory
	// contains filtered or unexported fields
}

Applier performs the step of applying a set of resources into a cluster, conditionally waits for all of them to be fully reconciled and finally performs prune to clean up any resources that has been deleted. The applier performs its function by executing a list queue of tasks, each of which is one of the steps in the process of applying a set of resources to the cluster. The actual execution of these tasks are handled by a StatusRunner. So the taskqueue is effectively a specification that is executed by the StatusRunner. Based on input parameters and/or the set of resources that needs to be applied to the cluster, different sets of tasks might be needed.

func NewApplier

func NewApplier(factory util.Factory, ioStreams genericclioptions.IOStreams) *Applier

newApplier returns a new Applier. It will set up the ApplyOptions and StatusOptions which are responsible for capturing any command line flags. It currently requires IOStreams, but this is a legacy from when the ApplyOptions were responsible for printing progress. This is now handled by a separate printer with the KubectlPrinterAdapter bridging between the two.

func (*Applier) Initialize

func (a *Applier) Initialize(cmd *cobra.Command) error

Initialize sets up the Applier for actually doing an apply against a cluster. This involves validating command line inputs and configuring clients for communicating with the cluster.

func (*Applier) Run

func (a *Applier) Run(ctx context.Context, objects []*resource.Info, options Options) <-chan event.Event

Run performs the Apply step. This happens asynchronously with updates on progress and any errors are reported back on the event channel. Cancelling the operation or setting timeout on how long to Wait for it complete can be done with the passed in context. Note: There sn't currently any way to interrupt the operation before all the given resources have been applied to the cluster. Any cancellation or timeout will only affect how long we Wait for the resources to become current.

func (*Applier) SetFlags

func (a *Applier) SetFlags(cmd *cobra.Command) error

SetFlags configures the command line flags needed for apply and status. This is a temporary solution as we should separate the configuration of cobra flags from the Applier.

type BasicPrinter

type BasicPrinter struct {
	IOStreams genericclioptions.IOStreams
}

BasicPrinter is a simple implementation that just prints the events from the channel in the default format for kubectl. We need to support different printers for different output formats.

func (*BasicPrinter) Print

func (b *BasicPrinter) Print(ch <-chan event.Event, preview bool)

Print outputs the events from the provided channel in a simple format on StdOut. As we support other printer implementations this should probably be an interface. This function will block until the channel is closed.

type Destroyer

type Destroyer struct {
	ApplyOptions *apply.ApplyOptions
	PruneOptions *prune.PruneOptions

	DryRun bool
	// contains filtered or unexported fields
}

Destroyer performs the step of grabbing all the previous inventory objects and prune them. This also deletes all the previous inventory objects

func NewDestroyer

func NewDestroyer(factory util.Factory, ioStreams genericclioptions.IOStreams) *Destroyer

NewDestroyer returns a new destroyer. It will set up the ApplyOptions and PruneOptions which are responsible for capturing any command line flags. It currently requires IOStreams, but this is a legacy from when the ApplyOptions were responsible for printing progress. This is now handled by a separate printer with the KubectlPrinterAdapter bridging between the two.

func (*Destroyer) Initialize

func (d *Destroyer) Initialize(cmd *cobra.Command, paths []string) error

Initialize sets up the Destroyer for actually doing an destroy against a cluster. This involves validating command line inputs and configuring clients for communicating with the cluster.

func (*Destroyer) Run

func (d *Destroyer) Run() <-chan event.Event

Run performs the destroy step. This happens asynchronously on progress and any errors are reported back on the event channel.

func (*Destroyer) SetFlags

func (d *Destroyer) SetFlags(cmd *cobra.Command) error

SetFlags configures the command line flags needed for destroy This is a temporary solution as we should separate the configuration of cobra flags from the Destroyer.

type Options

type Options struct {
	// ReconcileTimeout defines whether the applier should wait
	// until all applied resources have been reconciled, and if so,
	// how long to wait.
	ReconcileTimeout time.Duration

	// PollInterval defines how often we should poll for the status
	// of resources.
	PollInterval time.Duration

	// EmitStatusEvents defines whether status events should be
	// emitted on the eventChannel to the caller.
	EmitStatusEvents bool

	// NoPrune defines whether pruning of previously applied
	// objects should happen after apply.
	NoPrune bool

	// DryRun defines whether changes should actually be performed,
	// or if it is just talk and no action.
	DryRun bool

	// PrunePropagationPolicy defines the deletion propagation policy
	// that should be used for pruning. If this is not provided, the
	// default is to use the Background policy.
	PrunePropagationPolicy metav1.DeletionPropagation

	// PruneTimeout defines whether we should wait for all resources
	// to be fully deleted after pruning, and if so, how long we should
	// wait.
	PruneTimeout time.Duration
}

type ResourceObjects

type ResourceObjects struct {
	CurrentInventory    *resource.Info
	PreviousInventories []*resource.Info
	Resources           []*resource.Info
}

ResourceObjects contains information about the resources that will be applied and the existing inventories used to determine resources that should be pruned.

func (*ResourceObjects) AllIds

func (r *ResourceObjects) AllIds() []object.ObjMetadata

AllIds returns the Ids for all resources that are relevant. This includes resources that will be applied or pruned.

func (*ResourceObjects) IdsForApply

func (r *ResourceObjects) IdsForApply() []object.ObjMetadata

IdsForApply returns the Ids for all resources that should be applied, including the inventory object.

func (*ResourceObjects) IdsForPrune

func (r *ResourceObjects) IdsForPrune() []object.ObjMetadata

IdsForPrune returns the Ids for all resources that should be pruned.

func (*ResourceObjects) InfosForApply

func (r *ResourceObjects) InfosForApply() []*resource.Info

InfosForApply returns the infos representation for all the resources that should be applied, including the inventory object. The resources will be in sorted order.