split inventory and resources in the apply interface

Author: Liujingfang1

cmd/apply/cmdapply.go

@@ -17,6 +17,7 @@ import (
 	"sigs.k8s.io/cli-utils/cmd/printers"
 	"sigs.k8s.io/cli-utils/pkg/apply"
 	"sigs.k8s.io/cli-utils/pkg/common"
+	"sigs.k8s.io/cli-utils/pkg/inventory"
 	"sigs.k8s.io/cli-utils/pkg/provider"
 	"sigs.k8s.io/kustomize/kyaml/setters2"
 )
@@ -110,13 +111,17 @@ func (r *ApplyRunner) RunE(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	inv, objs, err := inventory.SplitUnstructureds(objs)
+	if err != nil {
+		return err
+	}
 
 	// Run the applier. It will return a channel where we can receive updates
 	// to keep track of progress and any issues.
 	if err := r.Applier.Initialize(); err != nil {
 		return err
 	}
-	ch := r.Applier.Run(context.Background(), objs, apply.Options{
+	ch := r.Applier.Run(context.Background(), inv, objs, apply.Options{
 		ServerSideOptions: r.serverSideOptions,
 		PollInterval:      r.period,
 		ReconcileTimeout:  r.reconcileTimeout,

cmd/preview/cmdpreview.go

@@ -100,6 +100,10 @@ func (r *PreviewRunner) RunE(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	inv, objs, err := inventory.SplitUnstructureds(objs)
+	if err != nil {
+		return err
+	}
 
 	// if destroy flag is set in preview, transmit it to destroyer DryRunStrategy flag
 	// and pivot execution to destroy with dry-run
@@ -119,17 +123,13 @@ func (r *PreviewRunner) RunE(cmd *cobra.Command, args []string) error {
 
 		// Run the applier. It will return a channel where we can receive updates
 		// to keep track of progress and any issues.
-		ch = r.Applier.Run(ctx, objs, apply.Options{
+		ch = r.Applier.Run(ctx, inv, objs, apply.Options{
 			EmitStatusEvents:  false,
 			NoPrune:           noPrune,
 			DryRunStrategy:    drs,
 			ServerSideOptions: r.serverSideOptions,
 		})
 	} else {
-		inv, _, err := inventory.SplitUnstructureds(objs)
-		if err != nil {
-			return err
-		}
 		err = r.Destroyer.Initialize()
 		if err != nil {
 			return err

pkg/apply/applier.go

@@ -5,6 +5,7 @@ package apply
 
 import (
 	"context"
+	"fmt"
 	"sort"
 	"time"
 
@@ -87,15 +88,16 @@ func (a *Applier) Initialize() error {
 // calculates the set of objects to be pruned (pruneIds), and orders the
 // resources for the subsequent apply. Returns the sorted resources to
 // apply as well as the objects for the prune, or an error if one occurred.
-func (a *Applier) prepareObjects(objs []*unstructured.Unstructured) (*ResourceObjects, error) {
-	localInv, localObjs, err := inventory.SplitUnstructureds(objs)
-	if err != nil {
+func (a *Applier) prepareObjects(localInv *unstructured.Unstructured, localObjs []*unstructured.Unstructured) (*ResourceObjects, error) {
+	if localInv == nil {
+		return nil, fmt.Errorf("the local inventory can't be nil")
+	}
+	if err := inventory.ValidateNoInventory(localObjs); err != nil {
 		return nil, err
 	}
-
 	// Ensures the namespace exists before applying the inventory object into it.
 	if invNamespace := inventoryNamespaceInSet(localInv, localObjs); invNamespace != nil {
-		if err = a.invClient.ApplyInventoryNamespace(invNamespace); err != nil {
+		if err := a.invClient.ApplyInventoryNamespace(invNamespace); err != nil {
 			return nil, err
 		}
 	}
@@ -128,15 +130,16 @@ type ResourceObjects struct {
 	PruneIds  []object.ObjMetadata
 }
 
-// InfosForApply returns the infos representation for all the resources
-// that should be applied, including the inventory object. The
+// ObjsForApply returns the unstructured representation for all the resources
+// that should be applied, not including the inventory object. The
 // resources will be in sorted order.
 func (r *ResourceObjects) ObjsForApply() []*unstructured.Unstructured {
 	return r.Resources
 }
 
-func (r *ResourceObjects) ObjsForPrune() []*unstructured.Unstructured {
-	return append([]*unstructured.Unstructured{r.LocalInv}, r.Resources...)
+// Inventory returns the unstructured representation of the inventory object.
+func (r *ResourceObjects) Inventory() *unstructured.Unstructured {
+	return r.LocalInv
 }
 
 // IdsForApply returns the Ids for all resources that should be applied,
@@ -169,7 +172,7 @@ func (r *ResourceObjects) AllIds() []object.ObjMetadata {
 // 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 (a *Applier) Run(ctx context.Context, objects []*unstructured.Unstructured, options Options) <-chan event.Event {
+func (a *Applier) Run(ctx context.Context, inventory *unstructured.Unstructured, objects []*unstructured.Unstructured, options Options) <-chan event.Event {
 	eventChannel := make(chan event.Event)
 	setDefaults(&options)
 	a.invClient.SetDryRunStrategy(options.DryRunStrategy) // client shared with prune, so sets dry-run for prune too.
@@ -179,7 +182,7 @@ func (a *Applier) Run(ctx context.Context, objects []*unstructured.Unstructured,
 		// This provides us with a slice of all the objects that will be
 		// applied to the cluster. This takes care of ordering resources
 		// and handling the inventory object.
-		resourceObjects, err := a.prepareObjects(objects)
+		resourceObjects, err := a.prepareObjects(inventory, objects)
 		if err != nil {
 			handleError(eventChannel, err)
 			return

pkg/apply/applier_test.go

@@ -204,7 +204,7 @@ func TestApplier(t *testing.T) {
 
 	for tn, tc := range testCases {
 		t.Run(tn, func(t *testing.T) {
-			infos, err := createObjs(tc.resources)
+			inv, infos, err := createObjs(tc.resources)
 			assert.NoError(t, err)
 
 			tf := cmdtesting.NewTestFactory().WithNamespace(tc.namespace)
@@ -231,7 +231,7 @@ func TestApplier(t *testing.T) {
 			applier.StatusPoller = poller
 
 			ctx := context.Background()
-			eventChannel := applier.Run(ctx, infos, Options{
+			eventChannel := applier.Run(ctx, inv, infos, Options{
 				ReconcileTimeout: tc.reconcileTimeout,
 				EmitStatusEvents: true,
 				NoPrune:          !tc.prune,
@@ -387,6 +387,8 @@ func TestInventoryNamespaceInSet(t *testing.T) {
 
 func TestReadAndPrepareObjects(t *testing.T) {
 	testCases := map[string]struct {
+		// local inventory input into applier.prepareObjects
+		inventory *unstructured.Unstructured
 		// locally read resources input into applier.prepareObjects
 		resources []*unstructured.Unstructured
 		// objects already stored in the cluster inventory
@@ -405,40 +407,41 @@ func TestReadAndPrepareObjects(t *testing.T) {
 			isError:   true,
 		},
 		"multiple inventory objects": {
-			resources: []*unstructured.Unstructured{inventoryObj, inventoryObj},
+			inventory: inventoryObj,
+			resources: []*unstructured.Unstructured{inventoryObj},
 			isError:   true,
 		},
 		"only inventory object": {
-			resources: []*unstructured.Unstructured{inventoryObj},
+			inventory: inventoryObj,
 			localInv:  inventoryObj,
 			isError:   false,
 		},
 		"only inventory object, prune one object": {
-			resources:   []*unstructured.Unstructured{inventoryObj},
+			inventory:   inventoryObj,
 			clusterObjs: []*unstructured.Unstructured{obj1},
 			localInv:    inventoryObj,
 			pruneObjs:   []*unstructured.Unstructured{obj1},
 			isError:     false,
 		},
 		"inventory object already at the beginning": {
-			resources: []*unstructured.Unstructured{inventoryObj, obj1,
-				clusterScopedObj},
+			inventory: inventoryObj,
+			resources: []*unstructured.Unstructured{obj1, clusterScopedObj},
 			localInv:  inventoryObj,
 			localObjs: []*unstructured.Unstructured{obj1, clusterScopedObj},
 			isError:   false,
 		},
 		"inventory object already at the beginning, prune one": {
-			resources: []*unstructured.Unstructured{inventoryObj, obj1,
-				clusterScopedObj},
+			inventory:   inventoryObj,
+			resources:   []*unstructured.Unstructured{obj1, clusterScopedObj},
 			clusterObjs: []*unstructured.Unstructured{obj2},
 			localInv:    inventoryObj,
 			localObjs:   []*unstructured.Unstructured{obj1, clusterScopedObj},
 			pruneObjs:   []*unstructured.Unstructured{obj2},
 			isError:     false,
 		},
 		"inventory object not at the beginning": {
-			resources: []*unstructured.Unstructured{obj1, obj2, inventoryObj,
-				clusterScopedObj},
+			inventory:   inventoryObj,
+			resources:   []*unstructured.Unstructured{obj1, obj2, clusterScopedObj},
 			clusterObjs: []*unstructured.Unstructured{obj2},
 			localInv:    inventoryObj,
 			localObjs:   []*unstructured.Unstructured{obj1, obj2, clusterScopedObj},
@@ -454,7 +457,7 @@ func TestReadAndPrepareObjects(t *testing.T) {
 			fakeInvClient := inventory.NewFakeInventoryClient(clusterObjs)
 			// Create applier with fake inventory client, and call prepareObjects
 			applier := &Applier{invClient: fakeInvClient}
-			resourceObjs, err := applier.prepareObjects(tc.resources)
+			resourceObjs, err := applier.prepareObjects(tc.inventory, tc.resources)
 			if !tc.isError && err != nil {
 				t.Fatalf("unexpected error received: %s", err)
 			}
@@ -533,17 +536,17 @@ func toIdentifier(t *testing.T, resourceInfo resourceInfo, namespace string) obj
 	}
 }
 
-func createObjs(resources []resourceInfo) ([]*unstructured.Unstructured, error) {
+func createObjs(resources []resourceInfo) (*unstructured.Unstructured, []*unstructured.Unstructured, error) {
 	var objs []*unstructured.Unstructured
 	for _, ri := range resources {
 		u := &unstructured.Unstructured{}
 		err := runtime.DecodeInto(codec, []byte(ri.manifest), u)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		objs = append(objs, u)
 	}
-	return objs, nil
+	return inventory.SplitUnstructureds(objs)
 }
 
 // The handler interface allows different testcases to provide

pkg/apply/destroyer.go

@@ -66,17 +66,12 @@ func (d *Destroyer) Run(inv *unstructured.Unstructured) <-chan event.Event {
 		defer close(ch)
 		d.invClient.SetDryRunStrategy(d.DryRunStrategy)
 
-		// Force a pruning of all cluster resources by clearing out the
-		// local resources, and sending only the inventory object to the
-		// prune.
-		invs := []*unstructured.Unstructured{inv}
-
 		// Start the event transformer goroutine so we can transform
 		// the Prune events emitted from the Prune function to Delete
 		// Events. That we use Prune to implement destroy is an
 		// implementation detail and the events should not be Prune events.
 		tempChannel, completedChannel := runPruneEventTransformer(ch)
-		err := d.PruneOptions.Prune(invs, sets.NewString(), tempChannel, prune.Options{
+		err := d.PruneOptions.Prune(inv, nil, sets.NewString(), tempChannel, prune.Options{
 			DryRunStrategy:    d.DryRunStrategy,
 			PropagationPolicy: metav1.DeletePropagationBackground,
 		})

pkg/apply/prune/prune.go

@@ -80,12 +80,8 @@ type Options struct {
 // (retrieved from previous inventory objects) but omitted in
 // the current apply. Prune also delete all previous inventory
 // objects. Returns an error if there was a problem.
-func (po *PruneOptions) Prune(localObjs []*unstructured.Unstructured, currentUIDs sets.String,
+func (po *PruneOptions) Prune(localInv *unstructured.Unstructured, localObjs []*unstructured.Unstructured, currentUIDs sets.String,
 	eventChannel chan<- event.Event, o Options) error {
-	localInv, localObjs, err := inventory.SplitUnstructureds(localObjs)
-	if err != nil {
-		return err
-	}
 	invNamespace := localInv.GetNamespace()
 	klog.V(4).Infof("prune local inventory object: %s/%s", invNamespace, localInv.GetName())
 	clusterObjs, err := po.InvClient.GetClusterObjs(localInv)

pkg/apply/prune/prune_test.go

@@ -161,7 +161,6 @@ func TestPrune(t *testing.T) {
 				po.InvClient = inventory.NewFakeInventoryClient(clusterObjs)
 				// Set up the currently applied objects.
 				currentInventory := createInventoryInfo(tc.currentObjs...)
-				currentObjs := append(tc.currentObjs, currentInventory)
 				// Set up the fake dynamic client to recognize all objects, and the RESTMapper.
 				po.client = fake.NewSimpleDynamicClient(scheme.Scheme,
 					namespace, pdb, role)
@@ -173,7 +172,7 @@ func TestPrune(t *testing.T) {
 				err := func() error {
 					defer close(eventChannel)
 					// Run the prune and validate.
-					return po.Prune(currentObjs, populateObjectIds(tc.currentObjs, t), eventChannel, Options{
+					return po.Prune(currentInventory, tc.currentObjs, populateObjectIds(tc.currentObjs, t), eventChannel, Options{
 						DryRunStrategy: drs,
 					})
 				}()

pkg/apply/solver/solver.go

@@ -51,7 +51,7 @@ type Options struct {
 
 type resourceObjects interface {
 	ObjsForApply() []*unstructured.Unstructured
-	ObjsForPrune() []*unstructured.Unstructured
+	Inventory() *unstructured.Unstructured
 	IdsForApply() []object.ObjMetadata
 	IdsForPrune() []object.ObjMetadata
 }
@@ -128,7 +128,8 @@ func (t *TaskQueueSolver) BuildTaskQueue(ro resourceObjects,
 	if o.Prune {
 		tasks = append(tasks,
 			&task.PruneTask{
-				Objects:           ro.ObjsForPrune(),
+				Objects:           ro.ObjsForApply(),
+				InventoryObject:   ro.Inventory(),
 				PruneOptions:      t.PruneOptions,
 				PropagationPolicy: o.PrunePropagationPolicy,
 				DryRunStrategy:    o.DryRunStrategy,

pkg/apply/solver/solver_test.go

@@ -309,6 +309,7 @@ func getType(task taskrunner.Task) reflect.Type {
 
 type fakeResourceObjects struct {
 	objsForApply []*unstructured.Unstructured
+	inventory    *unstructured.Unstructured
 	idsForApply  []object.ObjMetadata
 	idsForPrune  []object.ObjMetadata
 }
@@ -317,8 +318,8 @@ func (f *fakeResourceObjects) ObjsForApply() []*unstructured.Unstructured {
 	return f.objsForApply
 }
 
-func (f *fakeResourceObjects) ObjsForPrune() []*unstructured.Unstructured {
-	return f.objsForApply
+func (f *fakeResourceObjects) Inventory() *unstructured.Unstructured {
+	return f.inventory
 }
 
 func (f *fakeResourceObjects) IdsForApply() []object.ObjMetadata {

pkg/apply/task/prune_task.go

@@ -16,6 +16,7 @@ import (
 // set of resources that have just been applied.
 type PruneTask struct {
 	PruneOptions      *prune.PruneOptions
+	InventoryObject   *unstructured.Unstructured
 	Objects           []*unstructured.Unstructured
 	DryRunStrategy    common.DryRunStrategy
 	PropagationPolicy metav1.DeletionPropagation
@@ -28,7 +29,7 @@ type PruneTask struct {
 func (p *PruneTask) Start(taskContext *taskrunner.TaskContext) {
 	go func() {
 		currentUIDs := taskContext.AllResourceUIDs()
-		err := p.PruneOptions.Prune(p.Objects,
+		err := p.PruneOptions.Prune(p.InventoryObject, p.Objects,
 			currentUIDs, taskContext.EventChannel(), prune.Options{
 				DryRunStrategy:    p.DryRunStrategy,
 				PropagationPolicy: p.PropagationPolicy,