Add centralized method to fetch Bundles for a particular Cluster (#363)

controllers/controllers/resource/fetcher.go

@@ -203,9 +203,9 @@ func (r *capiResourceFetcher) VSphereMachineTemplate(ctx context.Context, cs *an
 	return vsphereMachineTemplate, nil
 }
 
-func (r *capiResourceFetcher) clusterBundle(ctx context.Context, cs *anywherev1.Cluster) (*releasev1alpha1.Bundles, error) {
+func (r *capiResourceFetcher) bundles(ctx context.Context, name, namespace string) (*releasev1alpha1.Bundles, error) {
 	clusterBundle := &releasev1alpha1.Bundles{}
-	err := r.FetchObjectByName(ctx, cs.Name, cs.Namespace, clusterBundle)
+	err := r.FetchObjectByName(ctx, name, namespace, clusterBundle)
 	if err != nil {
 		return nil, err
 	}
@@ -229,15 +229,7 @@ func (r *capiResourceFetcher) ControlPlane(ctx context.Context, cs *anywherev1.C
 }
 
 func (r *capiResourceFetcher) FetchAppliedSpec(ctx context.Context, cs *anywherev1.Cluster) (*cluster.Spec, error) {
-	bundle, err := r.clusterBundle(ctx, cs)
-	if err != nil {
-		return nil, err
-	}
-	spec, err := cluster.BuildSpecFromBundles(cs, bundle)
-	if err != nil {
-		return nil, err
-	}
-	return spec, nil
+	return cluster.BuildSpecForCluster(ctx, cs, r.bundles)
 }
 
 func (r *capiResourceFetcher) ExistingVSphereDatacenterConfig(ctx context.Context, cs *anywherev1.Cluster) (*anywherev1.VSphereDatacenterConfig, error) {

internal/test/cluster.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/yaml"
 
 	"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
 	"github.com/aws/eks-anywhere/pkg/cluster"
@@ -56,6 +57,20 @@ func NewFullClusterSpec(t *testing.T, clusterConfigFile string) *cluster.Spec {
 	return s
 }
 
+func Bundles(t *testing.T) *releasev1alpha1.Bundles {
+	content, err := configFS.ReadFile("testdata/bundles.yaml")
+	if err != nil {
+		t.Fatalf("Failed to read embed bundles manifest: %s", err)
+	}
+
+	bundles := &releasev1alpha1.Bundles{}
+	if err = yaml.Unmarshal(content, bundles); err != nil {
+		t.Fatalf("Failed to unmarshal bundles manifest: %s", err)
+	}
+
+	return bundles
+}
+
 func SetTag(image *releasev1alpha1.Image, tag string) {
 	image.URI = fmt.Sprintf("%s:%s", image.Image(), tag)
 }

pkg/cluster/fetch.go

@@ -0,0 +1,29 @@
+package cluster
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
+	v1alpha1release "github.com/aws/eks-anywhere/release/api/v1alpha1"
+)
+
+type BundlesFetch func(ctx context.Context, name, namespace string) (*v1alpha1release.Bundles, error)
+
+func BuildSpecForCluster(ctx context.Context, cluster *v1alpha1.Cluster, fetch BundlesFetch) (*Spec, error) {
+	bundles, err := GetBundlesForCluster(ctx, cluster, fetch)
+	if err != nil {
+		return nil, err
+	}
+
+	return BuildSpecFromBundles(cluster, bundles)
+}
+
+func GetBundlesForCluster(ctx context.Context, cluster *v1alpha1.Cluster, fetch BundlesFetch) (*v1alpha1release.Bundles, error) {
+	bundles, err := fetch(ctx, cluster.Name, cluster.Namespace)
+	if err != nil {
+		return nil, fmt.Errorf("failed fetching Bundles for cluster: %v", err)
+	}
+
+	return bundles, nil
+}

pkg/cluster/fetch_test.go

@@ -0,0 +1,34 @@
+package cluster_test
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/onsi/gomega"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
+	"github.com/aws/eks-anywhere/pkg/cluster"
+	v1alpha1release "github.com/aws/eks-anywhere/release/api/v1alpha1"
+)
+
+func TestGetBundlesForCluster(t *testing.T) {
+	g := NewWithT(t)
+	c := &v1alpha1.Cluster{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "eksa-cluster",
+			Namespace: "eksa",
+		},
+	}
+	wantBundles := &v1alpha1release.Bundles{}
+	mockFetch := func(ctx context.Context, name, namespace string) (*v1alpha1release.Bundles, error) {
+		g.Expect(name).To(Equal(c.Name))
+		g.Expect(namespace).To(Equal(c.Namespace))
+
+		return wantBundles, nil
+	}
+
+	gotBundles, err := cluster.GetBundlesForCluster(context.Background(), c, mockFetch)
+	g.Expect(err).To(BeNil())
+	g.Expect(gotBundles).To(Equal(wantBundles))
+}

pkg/executables/kubectl.go

@@ -23,6 +23,7 @@ import (
 	"github.com/aws/eks-anywhere/pkg/filewriter"
 	"github.com/aws/eks-anywhere/pkg/logger"
 	"github.com/aws/eks-anywhere/pkg/types"
+	releasev1alpha1 "github.com/aws/eks-anywhere/release/api/v1alpha1"
 )
 
 const (
@@ -37,6 +38,7 @@ var (
 	eksaGitOpsResourceType            = fmt.Sprintf("gitopsconfigs.%s", v1alpha1.GroupVersion.Group)
 	eksaOIDCResourceType              = fmt.Sprintf("oidcconfigs.%s", v1alpha1.GroupVersion.Group)
 	etcdadmClustersResourceType       = fmt.Sprintf("etcdadmclusters.%s", etcdv1alpha3.GroupVersion.Group)
+	bundlesResourceType               = fmt.Sprintf("bundles.%s", releasev1alpha1.GroupVersion.Group)
 )
 
 type Kubectl struct {
@@ -735,3 +737,19 @@ func (k *Kubectl) ValidateNodesVersion(ctx context.Context, kubeconfig string, k
 	}
 	return nil
 }
+
+func (k *Kubectl) GetBundles(ctx context.Context, kubeconfigFile, name, namespace string) (*releasev1alpha1.Bundles, error) {
+	params := []string{"get", bundlesResourceType, name, "-o", "json", "--kubeconfig", kubeconfigFile, "--namespace", namespace}
+	stdOut, err := k.executable.Execute(ctx, params...)
+	if err != nil {
+		return nil, fmt.Errorf("error getting Bundles with kubectl: %v", err)
+	}
+
+	response := &releasev1alpha1.Bundles{}
+	err = json.Unmarshal(stdOut.Bytes(), response)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing Bundles response: %v", err)
+	}
+
+	return response, nil
+}

pkg/executables/kubectl_test.go

@@ -3,12 +3,14 @@ package executables_test
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
 	"testing"
 
 	"github.com/golang/mock/gomock"
+	. "github.com/onsi/gomega"
 	"k8s.io/apimachinery/pkg/version"
 	"sigs.k8s.io/cluster-api/api/v1alpha3"
 
@@ -27,6 +29,41 @@ const (
 
 var capiClustersResourceType = fmt.Sprintf("clusters.%s", v1alpha3.GroupVersion.Group)
 
+func newKubectl(t *testing.T) (*executables.Kubectl, context.Context, *types.Cluster, *mockexecutables.MockExecutable) {
+	kubeconfigFile := "c.kubeconfig"
+	cluster := &types.Cluster{
+		KubeconfigFile: kubeconfigFile,
+		Name:           "test-cluster",
+	}
+
+	ctx := context.Background()
+	ctrl := gomock.NewController(t)
+	executable := mockexecutables.NewMockExecutable(ctrl)
+
+	return executables.NewKubectl(executable), ctx, cluster, executable
+}
+
+type kubectlTest struct {
+	*WithT
+	k         *executables.Kubectl
+	ctx       context.Context
+	cluster   *types.Cluster
+	e         *mockexecutables.MockExecutable
+	namespace string
+}
+
+func newKubectlTest(t *testing.T) *kubectlTest {
+	k, ctx, cluster, e := newKubectl(t)
+	return &kubectlTest{
+		k:         k,
+		ctx:       ctx,
+		cluster:   cluster,
+		e:         e,
+		WithT:     NewWithT(t),
+		namespace: "namespace",
+	}
+}
+
 func TestKubectlApplyKubeSpecSuccess(t *testing.T) {
 	spec := "specfile"
 
@@ -662,20 +699,6 @@ func TestKubectlGetEKSAClusters(t *testing.T) {
 	}
 }
 
-func newKubectl(t *testing.T) (*executables.Kubectl, context.Context, *types.Cluster, *mockexecutables.MockExecutable) {
-	kubeconfigFile := "c.kubeconfig"
-	cluster := &types.Cluster{
-		KubeconfigFile: kubeconfigFile,
-		Name:           "test-cluster",
-	}
-
-	ctx := context.Background()
-	ctrl := gomock.NewController(t)
-	executable := mockexecutables.NewMockExecutable(ctrl)
-
-	return executables.NewKubectl(executable), ctx, cluster, executable
-}
-
 func TestKubectlGetGetApiServerUrlSuccess(t *testing.T) {
 	wantUrl := "https://127.0.0.1:37479"
 	k, ctx, cluster, e := newKubectl(t)
@@ -1129,3 +1152,22 @@ func TestKubectlRemoveAnnotationInNamespace(t *testing.T) {
 		t.Fatalf("Kubectl.RemoveAnnotationInNamespace() error = %v, want nil", err)
 	}
 }
+
+func TestKubectlGetBundles(t *testing.T) {
+	tt := newKubectlTest(t)
+	wantBundles := test.Bundles(t)
+	bundleName := "Bundle-name"
+	bundlesJson, err := json.Marshal(wantBundles)
+	if err != nil {
+		t.Fatalf("Failed marshalling Bundles: %s", err)
+	}
+
+	tt.e.EXPECT().Execute(
+		tt.ctx,
+		"get", "bundles.anywhere.eks.amazonaws.com", bundleName, "-o", "json", "--kubeconfig", tt.cluster.KubeconfigFile, "--namespace", tt.namespace,
+	).Return(*bytes.NewBuffer(bundlesJson), nil)
+
+	gotBundles, err := tt.k.GetBundles(tt.ctx, tt.cluster.KubeconfigFile, bundleName, tt.namespace)
+	tt.Expect(err).To(BeNil())
+	tt.Expect(gotBundles).To(Equal(wantBundles))
+}