Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
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 ¶
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.
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, previewStrategy common.DryRunStrategy) error
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
DryRunStrategy common.DryRunStrategy
// 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 ¶
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.
type Options ¶ added in v0.7.0
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
// DryRunStrategy defines whether changes should actually be performed,
// or if it is just talk and no action.
DryRunStrategy common.DryRunStrategy
// 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 ¶ added in v0.10.0
type ResourceObjects struct {
LocalInv *resource.Info
Resources []*resource.Info
PruneIds []object.ObjMetadata
}
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 ¶ added in v0.10.0
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 ¶ added in v0.10.0
func (r *ResourceObjects) IdsForApply() []object.ObjMetadata
IdsForApply returns the Ids for all resources that should be applied, including the inventory object.
func (*ResourceObjects) IdsForPrune ¶ added in v0.10.0
func (r *ResourceObjects) IdsForPrune() []object.ObjMetadata
IdsForPrune returns the Ids for all resources that should be pruned.
func (*ResourceObjects) InfosForApply ¶ added in v0.10.0
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.
func (*ResourceObjects) InfosForPrune ¶ added in v0.18.0
func (r *ResourceObjects) InfosForPrune() []*resource.Info
Source Files
Directories
¶
| Path | Synopsis |
|---|---|
|
The solver package is responsible for constructing a taskqueue based on the set of resources that should be applied.
|
The solver package is responsible for constructing a taskqueue based on the set of resources that should be applied. |