Split up server.go into diff files

cmd/clusters-service/pkg/server/common_test.go

@@ -0,0 +1,151 @@
+package server
+
+import (
+	"testing"
+	"time"
+
+	sourcev1beta1 "github.com/fluxcd/source-controller/api/v1beta1"
+	"github.com/go-logr/logr"
+	"gorm.io/gorm"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/discovery"
+	fakeclientset "k8s.io/client-go/kubernetes/fake"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"sigs.k8s.io/yaml"
+
+	capiv1 "github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/api/v1alpha1"
+	"github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/git"
+	capiv1_protos "github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/protos"
+	"github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/templates"
+	"github.com/weaveworks/weave-gitops/pkg/kube/kubefakes"
+)
+
+func createClient(t *testing.T, clusterState ...runtime.Object) client.Client {
+	scheme := runtime.NewScheme()
+	schemeBuilder := runtime.SchemeBuilder{
+		corev1.AddToScheme,
+		capiv1.AddToScheme,
+		sourcev1beta1.AddToScheme,
+	}
+	err := schemeBuilder.AddToScheme(scheme)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	c := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithRuntimeObjects(clusterState...).
+		Build()
+
+	return c
+}
+
+func createServer(t *testing.T, clusterState []runtime.Object, configMapName, namespace string, provider git.Provider, db *gorm.DB, ns string, hr *sourcev1beta1.HelmRepository) capiv1_protos.ClustersServiceServer {
+
+	c := createClient(t, clusterState...)
+
+	dc := discovery.NewDiscoveryClient(fakeclientset.NewSimpleClientset().Discovery().RESTClient())
+
+	s := NewClusterServer(logr.Discard(),
+		&templates.ConfigMapLibrary{
+			Log:           logr.Discard(),
+			Client:        c,
+			ConfigMapName: configMapName,
+			Namespace:     namespace,
+		}, provider, kubefakes.NewFakeClientGetter(c), dc, db, ns, "weaveworks-charts", "")
+
+	return s
+}
+
+func makeTestHelmRepository(base string, opts ...func(*sourcev1beta1.HelmRepository)) *sourcev1beta1.HelmRepository {
+	hr := &sourcev1beta1.HelmRepository{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       sourcev1beta1.HelmRepositoryKind,
+			APIVersion: sourcev1beta1.GroupVersion.Identifier(),
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "testing",
+			Namespace: "test-ns",
+		},
+		Spec: sourcev1beta1.HelmRepositorySpec{
+			URL:      base + "/charts",
+			Interval: metav1.Duration{Duration: time.Minute * 10},
+		},
+		Status: sourcev1beta1.HelmRepositoryStatus{
+			URL: base + "/index.yaml",
+		},
+	}
+	for _, o := range opts {
+		o(hr)
+	}
+	return hr
+}
+
+func makeTemplateConfigMap(s ...string) *corev1.ConfigMap {
+	data := make(map[string]string)
+	for i := 0; i < len(s); i += 2 {
+		data[s[i]] = s[i+1]
+	}
+	return &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "capi-templates",
+			Namespace: "default",
+		},
+		Data: data,
+	}
+}
+
+func makeTemplate(t *testing.T, opts ...func(*capiv1.CAPITemplate)) string {
+	t.Helper()
+	basicRaw := `
+	{
+		"apiVersion":"fooversion",
+		"kind":"fookind",
+		"metadata":{
+		   "name":"${CLUSTER_NAME}",
+		   "annotations":{
+			  "capi.weave.works/display-name":"ClusterName"
+		   }
+		}
+	 }`
+	ct := &capiv1.CAPITemplate{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "CAPITemplate",
+			APIVersion: "capi.weave.works/v1alpha1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "cluster-template-1",
+		},
+		Spec: capiv1.CAPITemplateSpec{
+			Description: "this is test template 1",
+			Params: []capiv1.TemplateParam{
+				{
+					Name:        "CLUSTER_NAME",
+					Description: "This is used for the cluster naming.",
+				},
+			},
+			ResourceTemplates: []capiv1.CAPIResourceTemplate{
+				{
+					RawExtension: rawExtension(basicRaw),
+				},
+			},
+		},
+	}
+	for _, o := range opts {
+		o(ct)
+	}
+	b, err := yaml.Marshal(ct)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(b)
+}
+
+func rawExtension(s string) runtime.RawExtension {
+	return runtime.RawExtension{
+		Raw: []byte(s),
+	}
+}

cmd/clusters-service/pkg/server/config.go

@@ -0,0 +1,15 @@
+package server
+
+import (
+	"context"
+	"os"
+
+	capiv1_proto "github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/protos"
+)
+
+func (s *server) GetConfig(ctx context.Context, msg *capiv1_proto.GetConfigRequest) (*capiv1_proto.GetConfigResponse, error) {
+
+	repositoryURL := os.Getenv("CAPI_TEMPLATES_REPOSITORY_URL")
+
+	return &capiv1_proto.GetConfigResponse{RepositoryURL: repositoryURL}, nil
+}

cmd/clusters-service/pkg/server/config_test.go

@@ -0,0 +1,43 @@
+package server
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/testing/protocmp"
+
+	capiv1_protos "github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/protos"
+)
+
+func TestGetConfig(t *testing.T) {
+	testCases := []struct {
+		name  string
+		value string
+	}{
+		{
+			name:  "value set",
+			value: "https://github.com/user/blog",
+		},
+		{
+			name:  "value not set",
+			value: "",
+		},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			os.Setenv("CAPI_TEMPLATES_REPOSITORY_URL", tt.value)
+			defer os.Unsetenv("CAPI_TEMPLATES_REPOSITORY_URL")
+
+			s := createServer(t, nil, "", "", nil, nil, "", nil)
+
+			res, _ := s.GetConfig(context.Background(), &capiv1_protos.GetConfigRequest{})
+
+			if diff := cmp.Diff(tt.value, res.RepositoryURL, protocmp.Transform()); diff != "" {
+				t.Fatalf("repository URL didn't match expected:\n%s", diff)
+			}
+		})
+	}
+}

cmd/clusters-service/pkg/server/credentials.go

@@ -0,0 +1,34 @@
+package server
+
+import (
+	"context"
+
+	"github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/credentials"
+	capiv1_proto "github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/protos"
+)
+
+// ListCredentials searches the management cluster and lists any objects that match specific given types
+func (s *server) ListCredentials(ctx context.Context, msg *capiv1_proto.ListCredentialsRequest) (*capiv1_proto.ListCredentialsResponse, error) {
+	client, err := s.clientGetter.Client(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	creds := []*capiv1_proto.Credential{}
+	foundCredentials, err := credentials.FindCredentials(ctx, client, s.discoveryClient)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, identity := range foundCredentials {
+		creds = append(creds, &capiv1_proto.Credential{
+			Group:     identity.GroupVersionKind().Group,
+			Version:   identity.GroupVersionKind().Version,
+			Kind:      identity.GetKind(),
+			Name:      identity.GetName(),
+			Namespace: identity.GetNamespace(),
+		})
+	}
+
+	return &capiv1_proto.ListCredentialsResponse{Credentials: creds, Total: int32(len(creds))}, nil
+}

cmd/clusters-service/pkg/server/helpers.go

@@ -0,0 +1,56 @@
+package server
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	capiv1 "github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/api/v1alpha1"
+	"github.com/weaveworks/weave-gitops-enterprise/cmd/clusters-service/pkg/capi"
+)
+
+func renderTemplateWithValues(t *capiv1.CAPITemplate, name string, values map[string]string) ([][]byte, error) {
+	opts := []capi.RenderOptFunc{
+		capi.InNamespace(os.Getenv("CAPI_CLUSTERS_NAMESPACE")),
+	}
+	if os.Getenv("INJECT_PRUNE_ANNOTATION") != "disabled" {
+		opts = append(opts, capi.InjectPruneAnnotation)
+	}
+
+	templateBits, err := capi.Render(t.Spec, values, opts...)
+	if err != nil {
+		if missing, ok := isMissingVariableError(err); ok {
+			return nil, fmt.Errorf("error rendering template %v due to missing variables: %s", name, missing)
+		}
+		return nil, fmt.Errorf("error rendering template %v, %v", name, err)
+	}
+
+	return templateBits, nil
+}
+
+func getProvider(t *capiv1.CAPITemplate) string {
+	meta, err := capi.ParseTemplateMeta(t)
+
+	if err != nil {
+		return ""
+	}
+
+	for _, obj := range meta.Objects {
+		if p, ok := providers[obj.Kind]; ok {
+			return p
+		}
+	}
+
+	return ""
+}
+
+func isMissingVariableError(err error) (string, bool) {
+	errStr := err.Error()
+	prefix := "processing template: value for variables"
+	suffix := "is not set. Please set the value using os environment variables or the clusterctl config file"
+	if strings.HasPrefix(errStr, prefix) && strings.HasSuffix(errStr, suffix) {
+		missing := strings.TrimSpace(errStr[len(prefix):strings.Index(errStr, suffix)])
+		return missing, true
+	}
+	return "", false
+}