Inventory client uses factory function

seans3 · seans3 · commit a4e3b45135de · 2020-08-06T22:25:28.000-07:00
diff --git a/pkg/apply/destroyer.go b/pkg/apply/destroyer.go
@@ -44,6 +44,7 @@ type Destroyer struct {
 	ioStreams      genericclioptions.IOStreams
 	ApplyOptions   *apply.ApplyOptions
 	PruneOptions   *prune.PruneOptions
+	invClient      inventory.InventoryClient
 	DryRunStrategy common.DryRunStrategy
 }
 
@@ -64,6 +65,7 @@ func (d *Destroyer) Initialize(cmd *cobra.Command, paths []string) error {
 	if err != nil {
 		return errors.WrapPrefix(err, "error creating inventory client", 1)
 	}
+	d.invClient = invClient
 	err = d.PruneOptions.Initialize(d.factory, invClient)
 	if err != nil {
 		return errors.WrapPrefix(err, "error setting up PruneOptions", 1)
@@ -97,7 +99,7 @@ func (d *Destroyer) Run() <-chan event.Event {
 		// deleting everything. We can ignore the error, since the Prune
 		// will catch the same problems.
 		invInfo, nonInvInfos, _ := inventory.SplitInfos(infos)
-		invInfo, err = inventory.ClearInventoryObj(invInfo)
+		invInfo, err = d.invClient.ClearInventoryObj(invInfo)
 		if err != nil {
 			ch <- event.Event{
 				Type: event.ErrorType,
@@ -121,8 +123,8 @@ func (d *Destroyer) Run() <-chan event.Event {
 		// Now delete the inventory object as well.
 		inv := inventory.FindInventoryObj(infos)
 		if inv != nil {
-			d.PruneOptions.InvClient.SetDryRunStrategy(d.DryRunStrategy)
-			_ = d.PruneOptions.InvClient.DeleteInventoryObj(inv)
+			d.invClient.SetDryRunStrategy(d.DryRunStrategy)
+			_ = d.invClient.DeleteInventoryObj(inv)
 		}
 
 		// Close the tempChannel to signal to the event transformer that
diff --git a/pkg/inventory/fake-inventory-client.go b/pkg/inventory/fake-inventory-client.go
@@ -63,6 +63,11 @@ func (fic *FakeInventoryClient) DeleteInventoryObj(inv *resource.Info) error {
 	return nil
 }
 
+// ClearInventoryObj implements InventoryClient interface function. It does nothing for now.
+func (fic *FakeInventoryClient) ClearInventoryObj(inv *resource.Info) (*resource.Info, error) {
+	return inv, nil
+}
+
 func (fic *FakeInventoryClient) SetDryRunStrategy(drs common.DryRunStrategy) {}
 
 // SetError forces an error on the subsequent client call if it returns an error.
diff --git a/pkg/inventory/inventory-client.go b/pkg/inventory/inventory-client.go
@@ -34,18 +34,22 @@ type InventoryClient interface {
 	Replace(inv *resource.Info, objs []object.ObjMetadata) error
 	// DeleteInventoryObj deletes the passed inventory object from the APIServer.
 	DeleteInventoryObj(inv *resource.Info) error
+	// ClearInventoryObj clears all obj references from the passed inventory object,
+	// returning the cleared inventory object or an error.
+	ClearInventoryObj(inv *resource.Info) (*resource.Info, error)
 	// SetDryRunStrategy sets the dry run strategy on whether this we actually mutate.
 	SetDryRunStrategy(drs common.DryRunStrategy)
 }
 
 // ClusterInventoryClient is a concrete implementation of the
 // InventoryClient interface.
 type ClusterInventoryClient struct {
-	builderFunc    func() *resource.Builder
-	mapper         meta.RESTMapper
-	validator      validation.Schema
-	clientFunc     func(*meta.RESTMapping) (resource.RESTClient, error)
-	dryRunStrategy common.DryRunStrategy
+	builderFunc          func() *resource.Builder
+	mapper               meta.RESTMapper
+	validator            validation.Schema
+	clientFunc           func(*meta.RESTMapping) (resource.RESTClient, error)
+	dryRunStrategy       common.DryRunStrategy
+	InventoryFactoryFunc InventoryFactoryFunc
 }
 
 var _ InventoryClient = &ClusterInventoryClient{}
@@ -64,11 +68,12 @@ func NewInventoryClient(factory cmdutil.Factory) (*ClusterInventoryClient, error
 	}
 	builderFunc := factory.NewBuilder
 	clusterInventoryClient := ClusterInventoryClient{
-		builderFunc:    builderFunc,
-		mapper:         mapper,
-		validator:      validator,
-		clientFunc:     factory.UnstructuredClientForMapping,
-		dryRunStrategy: common.DryRunNone,
+		builderFunc:          builderFunc,
+		mapper:               mapper,
+		validator:            validator,
+		clientFunc:           factory.UnstructuredClientForMapping,
+		dryRunStrategy:       common.DryRunNone,
+		InventoryFactoryFunc: WrapInventoryObj,
 	}
 	return &clusterInventoryClient, nil
 }
@@ -88,7 +93,7 @@ func (cic *ClusterInventoryClient) Merge(localInv *resource.Info, objs []object.
 	}
 	if clusterInv == nil {
 		// Wrap inventory object and store the inventory in it.
-		inv := WrapInventoryObj(localInv)
+		inv := cic.InventoryFactoryFunc(localInv)
 		if err := inv.Store(objs); err != nil {
 			return nil, err
 		}
@@ -114,7 +119,7 @@ func (cic *ClusterInventoryClient) Merge(localInv *resource.Info, objs []object.
 		unionObjs := object.Union(clusterObjs, objs)
 		klog.V(4).Infof("num objects to prune: %d", len(pruneIds))
 		klog.V(4).Infof("num merged objects to store in inventory: %d", len(unionObjs))
-		wrappedInv := WrapInventoryObj(clusterInv)
+		wrappedInv := cic.InventoryFactoryFunc(clusterInv)
 		if err = wrappedInv.Store(unionObjs); err != nil {
 			return pruneIds, err
 		}
@@ -148,7 +153,7 @@ func (cic *ClusterInventoryClient) Replace(localInv *resource.Info, objs []objec
 	if err != nil {
 		return err
 	}
-	wrappedInv := WrapInventoryObj(clusterInv)
+	wrappedInv := cic.InventoryFactoryFunc(clusterInv)
 	if err = wrappedInv.Store(objs); err != nil {
 		return err
 	}
@@ -178,7 +183,7 @@ func (cic *ClusterInventoryClient) GetClusterObjs(localInv *resource.Info) ([]ob
 	if clusterInv == nil {
 		return []object.ObjMetadata{}, nil
 	}
-	wrapped := WrapInventoryObj(clusterInv)
+	wrapped := cic.InventoryFactoryFunc(clusterInv)
 	return wrapped.Load()
 }
 
@@ -254,7 +259,7 @@ func (cic *ClusterInventoryClient) mergeClusterInventory(invInfos []*resource.In
 	// choosing the first inventory object as the one to retain.
 	sort.Sort(ordering.SortableInfos(invInfos))
 	retained := invInfos[0]
-	wrapRetained := WrapInventoryObj(retained)
+	wrapRetained := cic.InventoryFactoryFunc(retained)
 	retainedObjs, err := wrapRetained.Load()
 	if err != nil {
 		return nil, err
@@ -263,7 +268,7 @@ func (cic *ClusterInventoryClient) mergeClusterInventory(invInfos []*resource.In
 	// the retained objects.
 	for i := 1; i < len(invInfos); i++ {
 		merge := invInfos[i]
-		wrapMerge := WrapInventoryObj(merge)
+		wrapMerge := cic.InventoryFactoryFunc(merge)
 		mergeObjs, err := wrapMerge.Load()
 		if err != nil {
 			return nil, err
@@ -382,6 +387,22 @@ func (cic *ClusterInventoryClient) DeleteInventoryObj(info *resource.Info) error
 	return err
 }
 
+// ClearInventoryObj sets an empty inventory, which is used in destroy. Returns the
+// cleared inventory or an error if one occurred.
+func (cic *ClusterInventoryClient) ClearInventoryObj(invInfo *resource.Info) (*resource.Info, error) {
+	if invInfo == nil {
+		return nil, fmt.Errorf("clearing nil inventory object")
+	}
+	if !IsInventoryObject(invInfo) {
+		return nil, fmt.Errorf("attempting to clear non-inventory object")
+	}
+	wrapped := cic.InventoryFactoryFunc(invInfo)
+	if err := wrapped.Store([]object.ObjMetadata{}); err != nil {
+		return nil, err
+	}
+	return wrapped.GetObject()
+}
+
 // SetDryRun sets whether the inventory client will mutate the inventory
 // object in the cluster.
 func (cic *ClusterInventoryClient) SetDryRunStrategy(drs common.DryRunStrategy) {
diff --git a/pkg/inventory/inventory-client_test.go b/pkg/inventory/inventory-client_test.go
@@ -472,6 +472,64 @@ func TestDeleteInventoryObj(t *testing.T) {
 	}
 }
 
+func TestClearInventoryObject(t *testing.T) {
+	pod1 := ignoreErrInfoToObjMeta(pod1Info)
+	pod3 := ignoreErrInfoToObjMeta(pod3Info)
+	inv := storeObjsInInventory(invInfo, []object.ObjMetadata{pod1, pod3})
+	tests := map[string]struct {
+		invInfo *resource.Info
+		isError bool
+	}{
+		"Nil info should error": {
+			invInfo: nil,
+			isError: true,
+		},
+		"Info with nil Object should error": {
+			invInfo: nilInfo,
+			isError: true,
+		},
+		"Single non-inventory object should error": {
+			invInfo: pod1Info,
+			isError: true,
+		},
+		"Single inventory object without data should stay cleared": {
+			invInfo: invInfo,
+			isError: false,
+		},
+		"Single inventory object with data should be cleared": {
+			invInfo: inv,
+			isError: false,
+		},
+	}
+	tf := cmdtesting.NewTestFactory().WithNamespace(testNamespace)
+	defer tf.Cleanup()
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			invClient, _ := NewInventoryClient(tf)
+			invInfo, err := invClient.ClearInventoryObj(tc.invInfo)
+			if tc.isError {
+				if err == nil {
+					t.Errorf("Should have produced an error, but returned none.")
+				}
+			}
+			if !tc.isError {
+				if err != nil {
+					t.Fatalf("Received unexpected error: %s", err)
+				}
+				wrapped := WrapInventoryObj(invInfo)
+				objs, err := wrapped.Load()
+				if err != nil {
+					t.Fatalf("Received unexpected error: %s", err)
+				}
+				if len(objs) > 0 {
+					t.Errorf("Inventory object inventory not cleared: %#v\n", objs)
+				}
+			}
+		})
+	}
+}
+
 type invAndObjs struct {
 	inv     *resource.Info
 	invObjs []object.ObjMetadata
diff --git a/pkg/inventory/inventory.go b/pkg/inventory/inventory.go
@@ -38,6 +38,10 @@ type Inventory interface {
 	GetObject() (*resource.Info, error)
 }
 
+// InventoryFactoryFunc creates the object which implements the Inventory
+// interface from the passed info object.
+type InventoryFactoryFunc func(*resource.Info) Inventory
+
 // FindInventoryObj returns the "Inventory" object (ConfigMap with
 // inventory label) if it exists, or nil if it does not exist.
 func FindInventoryObj(infos []*resource.Info) *resource.Info {
@@ -108,22 +112,6 @@ func SplitInfos(infos []*resource.Info) (*resource.Info, []*resource.Info, error
 	return invs[0], resources, nil
 }
 
-// ClearInventoryObj finds the inventory object in the list of objects,
-// and sets an empty inventory. Returns an error if once occurred.
-func ClearInventoryObj(invInfo *resource.Info) (*resource.Info, error) {
-	if invInfo == nil {
-		return nil, fmt.Errorf("clearing nil inventory object")
-	}
-	if !IsInventoryObject(invInfo) {
-		return nil, fmt.Errorf("attempting to clear non-inventory object")
-	}
-	wrapped := WrapInventoryObj(invInfo)
-	if err := wrapped.Store([]object.ObjMetadata{}); err != nil {
-		return nil, err
-	}
-	return wrapped.GetObject()
-}
-
 // addSuffixToName adds the passed suffix (usually a hash) as a suffix
 // to the name of the passed object stored in the Info struct. Returns
 // an error if name stored in the object differs from the name in
diff --git a/pkg/inventory/inventory_test.go b/pkg/inventory/inventory_test.go
@@ -354,61 +354,6 @@ func TestSplitInfos(t *testing.T) {
 	}
 }
 
-func TestClearInventoryObject(t *testing.T) {
-	pod1 := ignoreErrInfoToObjMeta(pod1Info)
-	pod3 := ignoreErrInfoToObjMeta(pod3Info)
-	inv := storeObjsInInventory(invInfo, []object.ObjMetadata{pod1, pod3})
-	tests := map[string]struct {
-		invInfo *resource.Info
-		isError bool
-	}{
-		"Nil info should error": {
-			invInfo: nil,
-			isError: true,
-		},
-		"Info with nil Object should error": {
-			invInfo: nilInfo,
-			isError: true,
-		},
-		"Single non-inventory object should error": {
-			invInfo: pod1Info,
-			isError: true,
-		},
-		"Single inventory object without data should stay cleared": {
-			invInfo: invInfo,
-			isError: false,
-		},
-		"Single inventory object with data should be cleared": {
-			invInfo: inv,
-			isError: false,
-		},
-	}
-
-	for name, tc := range tests {
-		t.Run(name, func(t *testing.T) {
-			invInfo, err := ClearInventoryObj(tc.invInfo)
-			if tc.isError {
-				if err == nil {
-					t.Errorf("Should have produced an error, but returned none.")
-				}
-			}
-			if !tc.isError {
-				if err != nil {
-					t.Fatalf("Received unexpected error: %s", err)
-				}
-				wrapped := WrapInventoryObj(invInfo)
-				objs, err := wrapped.Load()
-				if err != nil {
-					t.Fatalf("Received unexpected error: %s", err)
-				}
-				if len(objs) > 0 {
-					t.Errorf("Inventory object inventory not cleared: %#v\n", objs)
-				}
-			}
-		})
-	}
-}
-
 func TestAddSuffixToName(t *testing.T) {
 	tests := []struct {
 		info     *resource.Info
