feat: add namespace inference to the runtime service fetch process (#363)

zreigz · web-flow · commit 0a0cb7cfe580 · 2025-02-07T09:06:32.000+01:00
* add namespace inference to the runtime service fetch process

* gen mocks

* refactor
diff --git a/go.mod b/go.mod
@@ -34,7 +34,7 @@ require (
 	github.com/opencost/opencost/core v0.0.0-20241216191657-30e5d9a27f41
 	github.com/orcaman/concurrent-map/v2 v2.0.1
 	github.com/pkg/errors v0.9.1
-	github.com/pluralsh/console/go/client v1.28.0
+	github.com/pluralsh/console/go/client v1.28.2
 	github.com/pluralsh/controller-reconcile-helper v0.1.0
 	github.com/pluralsh/gophoenix v0.1.3-0.20231201014135-dff1b4309e34
 	github.com/pluralsh/polly v0.1.10
diff --git a/go.sum b/go.sum
@@ -1199,8 +1199,8 @@ github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjL
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pluralsh/console/go/client v1.28.0 h1:UlXVT68KfpE5jc0XAfRV355DX/5np6zOu9KVyJcNr6I=
-github.com/pluralsh/console/go/client v1.28.0/go.mod h1:lpoWASYsM9keNePS3dpFiEisUHEfObIVlSL3tzpKn8k=
+github.com/pluralsh/console/go/client v1.28.2 h1:fNK0xPuGtbGKK1RTbGyRXP9HN5nCHoZUddRxYIdoWUE=
+github.com/pluralsh/console/go/client v1.28.2/go.mod h1:lpoWASYsM9keNePS3dpFiEisUHEfObIVlSL3tzpKn8k=
 github.com/pluralsh/controller-reconcile-helper v0.1.0 h1:BV3dYZFH5rn8ZvZjtpkACSv/GmLEtRftNQj/Y4ddHEo=
 github.com/pluralsh/controller-reconcile-helper v0.1.0/go.mod h1:RxAbvSB4/jkvx616krCdNQXPbpGJXW3J1L3rASxeFOA=
 github.com/pluralsh/gophoenix v0.1.3-0.20231201014135-dff1b4309e34 h1:ab2PN+6if/Aq3/sJM0AVdy1SYuMAnq4g20VaKhTm/Bw=
diff --git a/pkg/client/cluster.go b/pkg/client/cluster.go
@@ -2,10 +2,19 @@ package client
 
 import (
 	console "github.com/pluralsh/console/go/client"
+	internalerrors "github.com/pluralsh/deployment-operator/internal/errors"
+	"github.com/pluralsh/polly/containers"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+)
 
-	internalerrors "github.com/pluralsh/deployment-operator/internal/errors"
+const (
+	certManagerServiceName  = "cert-manager"
+	ebsCsiDriverServiceName = "aws-ebs-csi-driver"
+	externalDNSServiceName  = "external-dns"
+	linkerdServiceName      = "Linkerd"
+	istioServiceName        = "istio"
+	ciliumServiceName       = "cilium"
 )
 
 func (c *client) PingCluster(attributes console.ClusterPing) error {
@@ -18,15 +27,59 @@ func (c *client) Ping(vsn string) error {
 	return err
 }
 
-func (c *client) RegisterRuntimeServices(svcs map[string]string, serviceId *string) error {
+func initLayouts(layouts *console.OperationalLayoutAttributes) *console.OperationalLayoutAttributes {
+	if layouts == nil {
+		return &console.OperationalLayoutAttributes{
+			Namespaces: &console.ClusterNamespacesAttributes{},
+		}
+	}
+	return layouts
+}
+
+func appendUniqueExternalDNSNamespace(slice []*string, newValue *string) []*string {
+	if slice == nil {
+		slice = make([]*string, 0)
+	}
+	sliceSet := containers.ToSet[*string](slice)
+	sliceSet.Add(newValue)
+	return sliceSet.List()
+}
+
+func (c *client) RegisterRuntimeServices(svcs map[string]*NamespaceVersion, serviceId *string) error {
 	inputs := make([]*console.RuntimeServiceAttributes, 0)
-	for name, version := range svcs {
+	var layouts *console.OperationalLayoutAttributes
+	for name, nv := range svcs {
 		inputs = append(inputs, &console.RuntimeServiceAttributes{
 			Name:    name,
-			Version: version,
+			Version: nv.Version,
 		})
+		switch name {
+		case certManagerServiceName:
+			layouts = initLayouts(layouts)
+			layouts.Namespaces.CertManager = &nv.Namespace
+		case ebsCsiDriverServiceName:
+			layouts = initLayouts(layouts)
+			layouts.Namespaces.EbsCsiDriver = &nv.Namespace
+		case externalDNSServiceName:
+			layouts = initLayouts(layouts)
+			layouts.Namespaces.ExternalDNS = appendUniqueExternalDNSNamespace(layouts.Namespaces.ExternalDNS, &nv.Namespace)
+		}
+		if nv.PartOf != "" {
+			switch nv.PartOf {
+			case linkerdServiceName:
+				layouts = initLayouts(layouts)
+				layouts.Namespaces.Linkerd = &nv.Namespace
+			case istioServiceName:
+				layouts = initLayouts(layouts)
+				layouts.Namespaces.Istio = &nv.Namespace
+			case ciliumServiceName:
+				layouts = initLayouts(layouts)
+				layouts.Namespaces.Cilium = &nv.Namespace
+			}
+		}
 	}
-	_, err := c.consoleClient.RegisterRuntimeServices(c.ctx, inputs, serviceId)
+
+	_, err := c.consoleClient.RegisterRuntimeServices(c.ctx, inputs, layouts, serviceId)
 	return err
 }
 
diff --git a/pkg/client/console.go b/pkg/client/console.go
@@ -5,12 +5,17 @@ import (
 	"net/http"
 
 	console "github.com/pluralsh/console/go/client"
-
 	"github.com/pluralsh/deployment-operator/api/v1alpha1"
 	"github.com/pluralsh/deployment-operator/internal/helpers"
 	v1 "github.com/pluralsh/deployment-operator/pkg/harness/stackrun/v1"
 )
 
+type NamespaceVersion struct {
+	Namespace string
+	Version   string
+	PartOf    string
+}
+
 type client struct {
 	ctx           context.Context
 	consoleClient console.ConsoleClient
@@ -37,7 +42,7 @@ type Client interface {
 	GetCredentials() (url, token string)
 	PingCluster(attributes console.ClusterPing) error
 	Ping(vsn string) error
-	RegisterRuntimeServices(svcs map[string]string, serviceId *string) error
+	RegisterRuntimeServices(svcs map[string]*NamespaceVersion, serviceId *string) error
 	UpsertVirtualCluster(parentID string, attributes console.ClusterAttributes) (*console.GetClusterWithToken_Cluster, error)
 	IsClusterExists(id string) (bool, error)
 	GetCluster(id string) (*console.TinyClusterFragment, error)
diff --git a/pkg/controller/service/reconciler_scraper.go b/pkg/controller/service/reconciler_scraper.go
@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"github.com/pluralsh/deployment-operator/pkg/client"
 	"strings"
 
 	"github.com/Masterminds/semver/v3"
@@ -12,72 +13,80 @@ import (
 func (s *ServiceReconciler) ScrapeKube(ctx context.Context) {
 	logger := log.FromContext(ctx)
 	logger.Info("attempting to collect all runtime services for the cluster")
-	runtimeServices := map[string]string{}
+	runtimeServices := map[string]*client.NamespaceVersion{}
 	deployments, err := s.clientset.AppsV1().Deployments("").List(ctx, metav1.ListOptions{})
 	if err == nil {
 		logger.Info("aggregating from deployments")
 		for _, deployment := range deployments.Items {
-			AddRuntimeServiceInfo(deployment.GetLabels(), runtimeServices)
+			AddRuntimeServiceInfo(deployment.Namespace, deployment.GetLabels(), runtimeServices)
 		}
 	}
 
 	statefulSets, err := s.clientset.AppsV1().StatefulSets("").List(ctx, metav1.ListOptions{})
 	if err == nil {
 		logger.Info("aggregating from statefulsets")
 		for _, ss := range statefulSets.Items {
-			AddRuntimeServiceInfo(ss.GetLabels(), runtimeServices)
+			AddRuntimeServiceInfo(ss.Namespace, ss.GetLabels(), runtimeServices)
 		}
 	}
 
 	daemonSets, err := s.clientset.AppsV1().DaemonSets("").List(ctx, metav1.ListOptions{})
 	if err == nil {
 		logger.Info("aggregating from daemonsets")
-		for _, ss := range daemonSets.Items {
-			AddRuntimeServiceInfo(ss.GetLabels(), runtimeServices)
+		for _, ds := range daemonSets.Items {
+			AddRuntimeServiceInfo(ds.Namespace, ds.GetLabels(), runtimeServices)
 		}
 	}
 	if err := s.consoleClient.RegisterRuntimeServices(runtimeServices, nil); err != nil {
 		logger.Error(err, "failed to register runtime services, this is an ignorable error but could mean your console needs to be upgraded")
 	}
 }
 
-func AddRuntimeServiceInfo(labels map[string]string, acc map[string]string) {
+func AddRuntimeServiceInfo(namespace string, labels map[string]string, acc map[string]*client.NamespaceVersion) {
 	if labels == nil {
 		return
 	}
 
 	if vsn, ok := labels["app.kubernetes.io/version"]; ok {
 		if name, ok := labels["app.kubernetes.io/name"]; ok {
 			addVersion(acc, name, vsn)
+			acc[name].Namespace = namespace
+			if partOf, ok := labels["app.kubernetes.io/part-of"]; ok {
+				acc[name].PartOf = partOf
+			}
 			return
 		}
 
 		if name, ok := labels["app.kubernetes.io/part-of"]; ok {
 			addVersion(acc, name, vsn)
+			acc[name].Namespace = namespace
 		}
 	}
+
 }
 
-func addVersion(services map[string]string, name, vsn string) {
+func addVersion(services map[string]*client.NamespaceVersion, name, vsn string) {
 	old, ok := services[name]
 	if !ok {
-		services[name] = vsn
+		services[name] = &client.NamespaceVersion{
+			Version: vsn,
+		}
 		return
 	}
 
-	parsedOld, err := semver.NewVersion(strings.TrimPrefix(old, "v"))
+	parsedOld, err := semver.NewVersion(strings.TrimPrefix(old.Version, "v"))
 	if err != nil {
-		services[name] = vsn
+		services[name].Version = vsn
 		return
 	}
 
 	parsedNew, err := semver.NewVersion(strings.TrimPrefix(vsn, "v"))
 	if err != nil {
-		services[name] = vsn
+		services[name].Version = vsn
 		return
 	}
 
 	if parsedNew.LessThan(parsedOld) {
-		services[name] = vsn
+		services[name].Version = vsn
 	}
 }
diff --git a/pkg/test/mocks/Client_mock.go b/pkg/test/mocks/Client_mock.go

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ package service`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"context"`
	`5`	`+ "github.com/pluralsh/deployment-operator/pkg/client"`
`5`	`6`	`"strings"`
`6`	`7`
`7`	`8`	`"github.com/Masterminds/semver/v3"`
`@@ -12,72 +13,80 @@ import (`
`12`	`13`	`func (s *ServiceReconciler) ScrapeKube(ctx context.Context) {`
`13`	`14`	`logger := log.FromContext(ctx)`
`14`	`15`	`logger.Info("attempting to collect all runtime services for the cluster")`
`15`		`- runtimeServices := map[string]string{}`
	`16`	`+ runtimeServices := map[string]*client.NamespaceVersion{}`
`16`	`17`	`deployments, err := s.clientset.AppsV1().Deployments("").List(ctx, metav1.ListOptions{})`
`17`	`18`	`if err == nil {`
`18`	`19`	`logger.Info("aggregating from deployments")`
`19`	`20`	`for _, deployment := range deployments.Items {`
`20`		`- AddRuntimeServiceInfo(deployment.GetLabels(), runtimeServices)`
	`21`	`+ AddRuntimeServiceInfo(deployment.Namespace, deployment.GetLabels(), runtimeServices)`
`21`	`22`	`}`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`statefulSets, err := s.clientset.AppsV1().StatefulSets("").List(ctx, metav1.ListOptions{})`
`25`	`26`	`if err == nil {`
`26`	`27`	`logger.Info("aggregating from statefulsets")`
`27`	`28`	`for _, ss := range statefulSets.Items {`
`28`		`- AddRuntimeServiceInfo(ss.GetLabels(), runtimeServices)`
	`29`	`+ AddRuntimeServiceInfo(ss.Namespace, ss.GetLabels(), runtimeServices)`
`29`	`30`	`}`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`daemonSets, err := s.clientset.AppsV1().DaemonSets("").List(ctx, metav1.ListOptions{})`
`33`	`34`	`if err == nil {`
`34`	`35`	`logger.Info("aggregating from daemonsets")`
`35`		`- for _, ss := range daemonSets.Items {`
`36`		`- AddRuntimeServiceInfo(ss.GetLabels(), runtimeServices)`
	`36`	`+ for _, ds := range daemonSets.Items {`
	`37`	`+ AddRuntimeServiceInfo(ds.Namespace, ds.GetLabels(), runtimeServices)`
`37`	`38`	`}`
`38`	`39`	`}`
`39`	`40`	`if err := s.consoleClient.RegisterRuntimeServices(runtimeServices, nil); err != nil {`
`40`	`41`	`logger.Error(err, "failed to register runtime services, this is an ignorable error but could mean your console needs to be upgraded")`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`
`44`		`-func AddRuntimeServiceInfo(labels map[string]string, acc map[string]string) {`
	`45`	`+func AddRuntimeServiceInfo(namespace string, labels map[string]string, acc map[string]*client.NamespaceVersion) {`
`45`	`46`	`if labels == nil {`
`46`	`47`	`return`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`if vsn, ok := labels["app.kubernetes.io/version"]; ok {`
`50`	`51`	`if name, ok := labels["app.kubernetes.io/name"]; ok {`
`51`	`52`	`addVersion(acc, name, vsn)`
	`53`	`+ acc[name].Namespace = namespace`
	`54`	`+ if partOf, ok := labels["app.kubernetes.io/part-of"]; ok {`
	`55`	`+ acc[name].PartOf = partOf`
	`56`	`+ }`
`52`	`57`	`return`
`53`	`58`	`}`
`54`	`59`
`55`	`60`	`if name, ok := labels["app.kubernetes.io/part-of"]; ok {`
`56`	`61`	`addVersion(acc, name, vsn)`
	`62`	`+ acc[name].Namespace = namespace`
`57`	`63`	`}`
`58`	`64`	`}`
	`65`	`+`
`59`	`66`	`}`
`60`	`67`
`61`		`-func addVersion(services map[string]string, name, vsn string) {`
	`68`	`+func addVersion(services map[string]*client.NamespaceVersion, name, vsn string) {`
`62`	`69`	`old, ok := services[name]`
`63`	`70`	`if !ok {`
`64`		`- services[name] = vsn`
	`71`	`+ services[name] = &client.NamespaceVersion{`
	`72`	`+ Version: vsn,`
	`73`	`+ }`
`65`	`74`	`return`
`66`	`75`	`}`
`67`	`76`
`68`		`- parsedOld, err := semver.NewVersion(strings.TrimPrefix(old, "v"))`
	`77`	`+ parsedOld, err := semver.NewVersion(strings.TrimPrefix(old.Version, "v"))`
`69`	`78`	`if err != nil {`
`70`		`- services[name] = vsn`
	`79`	`+ services[name].Version = vsn`
`71`	`80`	`return`
`72`	`81`	`}`
`73`	`82`
`74`	`83`	`parsedNew, err := semver.NewVersion(strings.TrimPrefix(vsn, "v"))`
`75`	`84`	`if err != nil {`
`76`		`- services[name] = vsn`
	`85`	`+ services[name].Version = vsn`
`77`	`86`	`return`
`78`	`87`	`}`
`79`	`88`
`80`	`89`	`if parsedNew.LessThan(parsedOld) {`
`81`		`- services[name] = vsn`
	`90`	`+ services[name].Version = vsn`
`82`	`91`	`}`
`83`	`92`	`}`