Uplift cli-utils and cluster-api

Change-Id: I9b46421812dd15c01a250e6102f9c132ce82dd42

pkg/k8s/applier/applier.go

@@ -23,13 +23,12 @@ import (
 	v1 "k8s.io/api/core/v1"
 	apierror "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/cli-runtime/pkg/resource"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	cliapply "sigs.k8s.io/cli-utils/pkg/apply"
 	applyevent "sigs.k8s.io/cli-utils/pkg/apply/event"
 	"sigs.k8s.io/cli-utils/pkg/apply/poller"
 	clicommon "sigs.k8s.io/cli-utils/pkg/common"
-	"sigs.k8s.io/cli-utils/pkg/inventory"
 	"sigs.k8s.io/cli-utils/pkg/manifestreader"
 	"sigs.k8s.io/cli-utils/pkg/provider"
 	"sigs.k8s.io/yaml"
@@ -59,7 +58,7 @@ type ReaderFactory func(validate bool, bundle document.Bundle, factory cmdutil.F
 
 // NewApplier returns instance of Applier
 func NewApplier(eventCh chan events.Event, f cmdutil.Factory) *Applier {
-	cf := provider.NewProvider(f, inventory.WrapInventoryObj)
+	cf := provider.NewProvider(f)
 	return &Applier{
 		Factory:               f,
 		ManifestReaderFactory: utils.DefaultManifestReaderFactory,
@@ -74,14 +73,14 @@ func NewApplier(eventCh chan events.Event, f cmdutil.Factory) *Applier {
 func (a *Applier) ApplyBundle(bundle document.Bundle, ao ApplyOptions) {
 	defer close(a.eventChannel)
 	log.Debugf("Getting infos for bundle, inventory id is %s", ao.BundleName)
-	infos, err := a.getInfos(ao.BundleName, bundle, ao.DryRunStrategy)
+	objects, err := a.getObjects(ao.BundleName, bundle, ao.DryRunStrategy)
 	if err != nil {
 		handleError(a.eventChannel, err)
 		return
 	}
 
 	ctx := context.Background()
-	ch := a.Driver.Run(ctx, infos, cliApplyOptions(ao))
+	ch := a.Driver.Run(ctx, objects, cliApplyOptions(ao))
 	for e := range ch {
 		a.eventChannel <- events.Event{
 			Type:         events.ApplierType,
@@ -90,10 +89,10 @@ func (a *Applier) ApplyBundle(bundle document.Bundle, ao ApplyOptions) {
 	}
 }
 
-func (a *Applier) getInfos(
+func (a *Applier) getObjects(
 	bundleName string,
 	bundle document.Bundle,
-	dryRun clicommon.DryRunStrategy) ([]*resource.Info, error) {
+	dryRun clicommon.DryRunStrategy) ([]*unstructured.Unstructured, error) {
 	if bundle == nil {
 		return nil, ErrNilBundle{}
 	}
@@ -130,7 +129,11 @@ func (a *Applier) getInfos(
 	if err = a.Driver.Initialize(a.Poller); err != nil {
 		return nil, err
 	}
-	return a.ManifestReaderFactory(false, bundle, a.Factory).Read()
+	restMapper, err := a.Factory.ToRESTMapper()
+	if err != nil {
+		return nil, err
+	}
+	return a.ManifestReaderFactory(false, bundle, restMapper).Read()
 }
 
 func (a *Applier) ensureNamespaceExists(name string, dryRun clicommon.DryRunStrategy) error {
@@ -177,7 +180,7 @@ func cliApplyOptions(ao ApplyOptions) cliapply.Options {
 // Driver to cli-utils apply
 type Driver interface {
 	Initialize(p poller.Poller) error
-	Run(ctx context.Context, infos []*resource.Info, options cliapply.Options) <-chan applyevent.Event
+	Run(ctx context.Context, infos []*unstructured.Unstructured, options cliapply.Options) <-chan applyevent.Event
 }
 
 // Adaptor is implementation of driver interface
@@ -200,8 +203,9 @@ func (a *Adaptor) Initialize(p poller.Poller) error {
 }
 
 // Run perform apply operation
-func (a *Adaptor) Run(ctx context.Context, infos []*resource.Info, options cliapply.Options) <-chan applyevent.Event {
-	return a.CliUtilsApplier.Run(ctx, infos, options)
+func (a *Adaptor) Run(ctx context.Context, objects []*unstructured.Unstructured,
+	options cliapply.Options) <-chan applyevent.Event {
+	return a.CliUtilsApplier.Run(ctx, objects, options)
 }
 
 // NewInventoryDocument returns default config map with inventory Id to group up the objects

pkg/k8s/applier/fake.go

@@ -17,8 +17,8 @@ package applier
 import (
 	"context"
 
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/cli-runtime/pkg/resource"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	cliapply "sigs.k8s.io/cli-utils/pkg/apply"
 	applyevent "sigs.k8s.io/cli-utils/pkg/apply/event"
@@ -52,7 +52,7 @@ func (fa FakeAdaptor) Initialize(p poller.Poller) error {
 // Run implements driver
 func (fa FakeAdaptor) Run(
 	ctx context.Context,
-	infos []*resource.Info,
+	objects []*unstructured.Unstructured,
 	options cliapply.Options) <-chan applyevent.Event {
 	ch := make(chan applyevent.Event, len(fa.events))
 	defer close(ch)
@@ -96,7 +96,7 @@ type FakePoller struct {
 func (fp *FakePoller) Poll(ctx context.Context, ids []object.ObjMetadata, opts polling.Options) <-chan pollevent.Event {
 	events := []pollevent.Event{
 		{
-			EventType: pollevent.CompletedEvent,
+			EventType: pollevent.ResourceUpdateEvent,
 			Resource: &pollevent.ResourceStatus{
 				Identifier: object.ObjMetadata{
 					Name:      "test-rc",
@@ -109,7 +109,7 @@ func (fp *FakePoller) Poll(ctx context.Context, ids []object.ObjMetadata, opts p
 			},
 		},
 		{
-			EventType: pollevent.CompletedEvent,
+			EventType: pollevent.ResourceUpdateEvent,
 			Resource: &pollevent.ResourceStatus{
 				Identifier: object.ObjMetadata{
 					Name:      "airshipit-test-bundle-4bf1e4a",

pkg/k8s/utils/utils.go

@@ -19,9 +19,10 @@ import (
 	"io"
 	"os"
 
+	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
-	"k8s.io/cli-runtime/pkg/resource"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"sigs.k8s.io/cli-utils/pkg/manifestreader"
 
@@ -50,25 +51,25 @@ func Streams() genericclioptions.IOStreams {
 type ManifestReaderFactory func(
 	validate bool,
 	bundle document.Bundle,
-	factory cmdutil.Factory) manifestreader.ManifestReader
+	mapper meta.RESTMapper) manifestreader.ManifestReader
 
 // DefaultManifestReaderFactory default factory function for manifestreader.ManifestReader
 var DefaultManifestReaderFactory ManifestReaderFactory = func(
 	validate bool,
 	bundle document.Bundle,
-	factory cmdutil.Factory) manifestreader.ManifestReader {
-	return NewManifestBundleReader(validate, bundle, factory)
+	mapper meta.RESTMapper) manifestreader.ManifestReader {
+	return NewManifestBundleReader(validate, bundle, mapper)
 }
 
 // NewManifestBundleReader returns implementation of manifestreader interface
 func NewManifestBundleReader(
 	validate bool,
 	bundle document.Bundle,
-	factory cmdutil.Factory) *ManifestBundleReader {
+	mapper meta.RESTMapper) *ManifestBundleReader {
 	opts := manifestreader.ReaderOptions{
+		Mapper:    mapper,
 		Validate:  validate,
 		Namespace: metav1.NamespaceDefault,
-		Factory:   factory,
 	}
 	buffer := bytes.NewBuffer([]byte{})
 	return &ManifestBundleReader{
@@ -90,10 +91,10 @@ type ManifestBundleReader struct {
 	writer       io.Writer
 }
 
-func (mbr *ManifestBundleReader) Read() ([]*resource.Info, error) {
+func (mbr *ManifestBundleReader) Read() ([]*unstructured.Unstructured, error) {
 	err := mbr.Bundle.Write(mbr.writer)
 	if err != nil {
-		return []*resource.Info{}, err
+		return nil, err
 	}
 	return mbr.StreamReader.Read()
 }

pkg/k8s/utils/utils_test.go

@@ -29,7 +29,9 @@ import (
 func TestDefaultManifestFactory(t *testing.T) {
 	bundle, err := document.NewBundleByPath("testdata/source_bundle")
 	require.NoError(t, err)
-	reader := DefaultManifestReaderFactory(false, bundle, FactoryFromKubeConfig("testdata/kubeconfig.yaml", ""))
+	mapper, err := FactoryFromKubeConfig("testdata/kubeconfig.yaml", "").ToRESTMapper()
+	require.NoError(t, err)
+	reader := DefaultManifestReaderFactory(false, bundle, mapper)
 	require.NotNil(t, reader)
 }
 
@@ -64,22 +66,23 @@ func TestManifestBundleReader(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			reader := NewManifestBundleReader(false, bundle, FactoryFromKubeConfig("testdata/kubeconfig.yaml", ""))
+			mapper, err := FactoryFromKubeConfig("testdata/kubeconfig.yaml", "").ToRESTMapper()
+			require.NoError(t, err)
+			reader := NewManifestBundleReader(false, bundle, mapper)
 			if tt.reader != nil {
 				reader.StreamReader.Reader = tt.reader
 			}
 			if tt.writer != nil {
 				reader.writer = tt.writer
 			}
-			infos, err := reader.Read()
+			objects, err := reader.Read()
 			if tt.errString != "" {
 				require.Error(t, err)
 				assert.Contains(t, err.Error(), tt.errString)
 			} else {
 				require.NoError(t, err)
-				require.Len(t, infos, 1)
-				obj := infos[0].Object
-				gvk := obj.GetObjectKind().GroupVersionKind()
+				require.Len(t, objects, 1)
+				gvk := objects[0].GetObjectKind().GroupVersionKind()
 				assert.Equal(t, gvk, schema.GroupVersionKind{
 					Kind:    "ReplicationController",
 					Group:   "",