feat: Implement the GetHelmRelease endpoint

api/core/core.proto

@@ -39,6 +39,7 @@ service Core {
             get : "/v1/kustomizations/{name}"
         };
     }
+
     /*
      * ListHelmReleases lists helm releases from a cluster.
      */
@@ -48,6 +49,17 @@ service Core {
         };
     }
 
+
+    /*
+     * GetHelmRelease gets data about a single HelmRelease from the cluster.
+     */
+    rpc GetHelmRelease(GetHelmReleaseRequest) returns (GetHelmReleaseResponse) {
+        option (google.api.http) = {
+            get : "/v1/helmrelease/{name}"
+        };
+    }
+
+
     // Sources
 
     /*
@@ -143,6 +155,15 @@ message ListHelmReleasesResponse {
     repeated HelmRelease helm_releases = 1;
 }
 
+message GetHelmReleaseRequest {
+    string name      = 1;
+    string namespace = 2;
+}
+
+message GetHelmReleaseResponse {
+    HelmRelease helm_release = 1;
+}
+
 message ListGitRepositoriesRequest {
     string namespace = 1;
 }

api/core/core.swagger.json

@@ -174,6 +174,43 @@
         ]
       }
     },
+    "/v1/helmrelease/{name}": {
+      "get": {
+        "summary": "GetHelmRelease gets data about a single HelmRelease from the cluster.",
+        "operationId": "Core_GetHelmRelease",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/v1GetHelmReleaseResponse"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "name",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "namespace",
+            "in": "query",
+            "required": false,
+            "type": "string"
+          }
+        ],
+        "tags": [
+          "Core"
+        ]
+      }
+    },
     "/v1/helmreleases": {
       "get": {
         "summary": "ListHelmReleases lists helm releases from a cluster.",
@@ -545,6 +582,14 @@
         }
       }
     },
+    "v1GetHelmReleaseResponse": {
+      "type": "object",
+      "properties": {
+        "helmRelease": {
+          "$ref": "#/definitions/v1HelmRelease"
+        }
+      }
+    },
     "v1GetKustomizationResponse": {
       "type": "object",
       "properties": {

core/server/helm_release.go

@@ -0,0 +1,148 @@
+package server
+
+import (
+	"bytes"
+	"compress/gzip"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/fluxcd/helm-controller/api/v2beta1"
+	helmv2 "github.com/fluxcd/helm-controller/api/v2beta1"
+	"github.com/fluxcd/pkg/ssa"
+	"github.com/weaveworks/weave-gitops/core/server/types"
+	pb "github.com/weaveworks/weave-gitops/pkg/api/core"
+	v1 "k8s.io/api/core/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+func (cs *coreServer) ListHelmReleases(ctx context.Context, msg *pb.ListHelmReleasesRequest) (*pb.ListHelmReleasesResponse, error) {
+	k8s, err := cs.k8s.Client(ctx)
+	if err != nil {
+		return nil, doClientError(err)
+	}
+
+	l := &helmv2.HelmReleaseList{}
+
+	if err := list(ctx, k8s, temporarilyEmptyAppName, msg.Namespace, l); err != nil {
+		return nil, err
+	}
+
+	var results []*pb.HelmRelease
+	for _, helmRelease := range l.Items {
+		results = append(results, types.HelmReleaseToProto(&helmRelease, []*pb.GroupVersionKind{}))
+	}
+
+	return &pb.ListHelmReleasesResponse{
+		HelmReleases: results,
+	}, nil
+}
+
+func (cs *coreServer) GetHelmRelease(ctx context.Context, msg *pb.GetHelmReleaseRequest) (*pb.GetHelmReleaseResponse, error) {
+	k8s, err := cs.k8s.Client(ctx)
+	if err != nil {
+		return nil, doClientError(err)
+	}
+
+	helmRelease := helmv2.HelmRelease{}
+
+	if err = get(ctx, k8s, msg.Name, msg.Namespace, &helmRelease); err != nil {
+		return nil, err
+	}
+
+	inventory, err := getHelmReleaseInventory(ctx, helmRelease, k8s)
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.GetHelmReleaseResponse{
+		HelmRelease: types.HelmReleaseToProto(&helmRelease, inventory),
+	}, err
+}
+
+func getHelmReleaseInventory(ctx context.Context, helmRelease v2beta1.HelmRelease, k8s client.Client) ([]*pb.GroupVersionKind, error) {
+	storageNamespace := helmRelease.GetNamespace()
+	if helmRelease.Spec.StorageNamespace != "" {
+		storageNamespace = helmRelease.Spec.StorageNamespace
+	}
+
+	storageName := helmRelease.GetName()
+	if helmRelease.Spec.ReleaseName != "" {
+		storageName = helmRelease.Spec.ReleaseName
+	}
+
+	storageVersion := helmRelease.Status.LastReleaseRevision
+	if storageVersion < 1 {
+		// skip release if it failed to install
+		return nil, nil
+	}
+
+	storageSecret := v1.Secret{}
+	secretName := fmt.Sprintf("sh.helm.release.v1.%s.v%v", storageName, storageVersion)
+
+	if err := get(ctx, k8s, secretName, storageNamespace, &storageSecret); err != nil {
+		return nil, err
+	}
+
+	releaseData, releaseFound := storageSecret.Data["release"]
+	if !releaseFound {
+		return nil, fmt.Errorf("failed to decode the Helm storage object for HelmRelease '%s'", helmRelease.Name)
+	}
+
+	byteData, err := base64.StdEncoding.DecodeString(string(releaseData))
+	if err != nil {
+		return nil, err
+	}
+
+	var magicGzip = []byte{0x1f, 0x8b, 0x08}
+	if bytes.Equal(byteData[0:3], magicGzip) {
+		r, err := gzip.NewReader(bytes.NewReader(byteData))
+		if err != nil {
+			return nil, err
+		}
+
+		defer r.Close()
+
+		uncompressedByteData, err := io.ReadAll(r)
+		if err != nil {
+			return nil, err
+		}
+
+		byteData = uncompressedByteData
+	}
+
+	storage := types.HelmReleaseStorage{}
+	if err := json.Unmarshal(byteData, &storage); err != nil {
+		return nil, fmt.Errorf("failed to decode the Helm storage object for HelmRelease '%s': %w", helmRelease.Name, err)
+	}
+
+	objects, err := ssa.ReadObjects(strings.NewReader(storage.Manifest))
+	if err != nil {
+		return nil, fmt.Errorf("failed to read the Helm storage object for HelmRelease '%s': %w", helmRelease.Name, err)
+	}
+
+	var gvk []*pb.GroupVersionKind
+
+	found := map[string]bool{}
+
+	for _, entry := range objects {
+		entry.GetAPIVersion()
+
+		idstr := strings.Join([]string{entry.GetAPIVersion(), entry.GetKind()}, "_")
+
+		if !found[idstr] {
+			found[idstr] = true
+
+			gvk = append(gvk, &pb.GroupVersionKind{
+				Group:   entry.GroupVersionKind().Group,
+				Version: entry.GroupVersionKind().Version,
+				Kind:    entry.GroupVersionKind().Kind,
+			})
+		}
+	}
+
+	return gvk, nil
+}

core/server/helm_release_test.go

@@ -0,0 +1,109 @@
+package server
+
+import (
+	"context"
+	"testing"
+
+	helmv2 "github.com/fluxcd/helm-controller/api/v2beta1"
+	. "github.com/onsi/gomega"
+	pb "github.com/weaveworks/weave-gitops/pkg/api/core"
+	"github.com/weaveworks/weave-gitops/pkg/kube"
+	"k8s.io/apimachinery/pkg/util/rand"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+func TestListHelmReleases(t *testing.T) {
+	g := NewGomegaWithT(t)
+	ctx := context.Background()
+
+	c, cleanup := makeGRPCServer(k8sEnv.Rest, t)
+	defer cleanup()
+
+	_, k, err := kube.NewKubeHTTPClientWithConfig(k8sEnv.Rest, "")
+	g.Expect(err).NotTo(HaveOccurred())
+
+	appName := "myapp"
+	ns := newNamespace(ctx, k, g)
+
+	newHelmRelease(ctx, appName, ns.Name, k, g)
+
+	res, err := c.ListHelmReleases(ctx, &pb.ListHelmReleasesRequest{
+		Namespace: ns.Name,
+	})
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(res.HelmReleases).To(HaveLen(1))
+	g.Expect(res.HelmReleases[0].Name).To(Equal(appName))
+}
+
+func TestGetHelmRelease(t *testing.T) {
+	g := NewGomegaWithT(t)
+	ctx := context.Background()
+
+	c, cleanup := makeGRPCServer(k8sEnv.Rest, t)
+	defer cleanup()
+
+	_, k, err := kube.NewKubeHTTPClientWithConfig(k8sEnv.Rest, "")
+	g.Expect(err).NotTo(HaveOccurred())
+
+	appName := "myapp" + rand.String(5)
+	ns1 := newNamespace(ctx, k, g)
+	ns2 := newNamespace(ctx, k, g)
+	ns3 := newNamespace(ctx, k, g)
+
+	newHelmRelease(ctx, appName, ns1.Name, k, g)
+	newHelmRelease(ctx, appName, ns2.Name, k, g)
+
+	// Get app from ns1.
+	response, err := c.GetHelmRelease(ctx, &pb.GetHelmReleaseRequest{
+		Name:      appName,
+		Namespace: ns1.Name,
+	})
+
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(response.HelmRelease.Name).To(Equal(appName))
+	g.Expect(response.HelmRelease.Namespace).To(Equal(ns1.Name))
+
+	// Get app from ns2.
+	response, err = c.GetHelmRelease(ctx, &pb.GetHelmReleaseRequest{
+		Name:      appName,
+		Namespace: ns2.Name,
+	})
+
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(response.HelmRelease.Name).To(Equal(appName))
+	g.Expect(response.HelmRelease.Namespace).To(Equal(ns2.Name))
+
+	// Get app from ns3, should fail.
+	_, err = c.GetHelmRelease(ctx, &pb.GetHelmReleaseRequest{
+		Name:      appName,
+		Namespace: ns3.Name,
+	})
+
+	g.Expect(err).To(HaveOccurred())
+}
+
+func newHelmRelease(
+	ctx context.Context,
+	appName, nsName string,
+	k client.Client,
+	g *GomegaWithT,
+) helmv2.HelmRelease {
+	release := helmv2.HelmRelease{
+		Spec: helmv2.HelmReleaseSpec{
+			Chart: helmv2.HelmChartTemplate{
+				Spec: helmv2.HelmChartTemplateSpec{
+					SourceRef: helmv2.CrossNamespaceObjectReference{
+						Kind: "GitRepository",
+						Name: "somesource",
+					},
+				},
+			},
+		},
+	}
+	release.Name = appName
+	release.Namespace = nsName
+
+	g.Expect(k.Create(ctx, &release)).To(Succeed())
+
+	return release
+}

core/server/automations.go → core/server/kustomization.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	helmv2 "github.com/fluxcd/helm-controller/api/v2beta1"
 	kustomizev1 "github.com/fluxcd/kustomize-controller/api/v1beta2"
 	"github.com/weaveworks/weave-gitops/core/server/types"
 	pb "github.com/weaveworks/weave-gitops/pkg/api/core"
@@ -57,25 +56,3 @@ func (cs *coreServer) GetKustomization(ctx context.Context, msg *pb.GetKustomiza
 
 	return &pb.GetKustomizationResponse{Kustomization: res}, nil
 }
-
-func (cs *coreServer) ListHelmReleases(ctx context.Context, msg *pb.ListHelmReleasesRequest) (*pb.ListHelmReleasesResponse, error) {
-	k8s, err := cs.k8s.Client(ctx)
-	if err != nil {
-		return nil, doClientError(err)
-	}
-
-	l := &helmv2.HelmReleaseList{}
-
-	if err := list(ctx, k8s, temporarilyEmptyAppName, msg.Namespace, l); err != nil {
-		return nil, err
-	}
-
-	var results []*pb.HelmRelease
-	for _, repository := range l.Items {
-		results = append(results, types.HelmReleaseToProto(&repository))
-	}
-
-	return &pb.ListHelmReleasesResponse{
-		HelmReleases: results,
-	}, nil
-}