Merge pull request #367 from anchore/fix-registration

fix: integration registration should reuse the integration registration name

Author: bradleyjones

pkg/integration/integration.go

@@ -106,7 +106,12 @@ func PerformRegistration(appConfig *config.Application, ch Channels) (*Integrati
 	name := os.Getenv("HOSTNAME")
 
 	k8sClient := getK8sClient(appConfig)
-	registrationInfo := getRegistrationInfo(appConfig, k8sClient, namespace, name, uuid.New, time.Now)
+	replicaCount, err := getReplicaCountFromK8s(k8sClient, namespace, name)
+	if err != nil {
+		log.Errorf("Failed to get replica count from K8s: %v", err)
+	}
+	log.Debugf("Determined replica count from K8s: %d", replicaCount)
+	registrationInfo := getRegistrationInfo(appConfig, k8sClient, namespace, name, replicaCount, uuid.New, time.Now)
 
 	// Register this agent with enterprise
 	registeredIntegration, err := register(registrationInfo, appConfig.AnchoreDetails, -1,
@@ -292,7 +297,7 @@ func doRegister(registrationInfo *Registration, anchoreDetails config.AnchoreInf
 }
 
 func getRegistrationInfo(appConfig *config.Application, k8sClient *client.Client,
-	namespace string, name string, newUUID _NewUUID, now _Now) *Registration {
+	namespace string, name string, replicaCount int32, newUUID _NewUUID, now _Now) *Registration {
 	var registrationID, registrationInstanceID, instanceName, appVersion, description string
 
 	log.Debugf("Attempting to determine values from K8s Deployment for Pod: %s in Namespace: %s",
@@ -309,10 +314,14 @@ func getRegistrationInfo(appConfig *config.Application, k8sClient *client.Client
 		registrationID = newUUID().String()
 	}
 
-	if name != "" {
-		log.Debugf("Using registration_instance_id: %s", name)
+	switch {
+	case replicaCount != 1:
+		log.Debugf("Could not find single replica, using registration_instance_id: %s", instanceName)
 		registrationInstanceID = name
-	} else {
+	case instanceName != "":
+		log.Debugf("Using registration_instance_id: %s", instanceName)
+		registrationInstanceID = instanceName
+	default:
 		log.Debugf("Generating UUIDv4 to use as registration_instance_id")
 		registrationInstanceID = newUUID().String()
 	}
@@ -385,6 +394,26 @@ func getInstanceDataFromK8s(k8sClient *client.Client, namespace string, podName
 	return registrationID, instanceName, appVersion
 }
 
+func getReplicaCountFromK8s(k8sClient *client.Client, namespace string, podName string) (int32, error) {
+	if k8sClient == nil {
+		log.Errorf("Kubernetes client not initialized. Unable to interact with K8s cluster.")
+		return 0, fmt.Errorf("kubernetes client not initialized")
+	}
+	opts := metav1.GetOptions{}
+	pod, err := k8sClient.Clientset.CoreV1().Pods(namespace).Get(context.Background(), podName, opts)
+	if err != nil {
+		log.Errorf("failed to get pod: %v", err)
+		return 0, err
+	}
+	replicaSetName := pod.ObjectMeta.OwnerReferences[0].Name
+	replicaSet, err := k8sClient.Clientset.AppsV1().ReplicaSets(namespace).Get(context.Background(), replicaSetName, opts)
+	if err != nil {
+		log.Errorf("failed to get replica set: %v", err)
+		return 0, err
+	}
+	return *replicaSet.Spec.Replicas, nil
+}
+
 func getAccountsAndNamespacesForAgent(appConfig *config.Application) ([]string, []string) {
 	accountSet := make(map[string]bool)
 	namespaceSet := make(map[string]bool)

pkg/integration/integration_test.go

@@ -2,6 +2,15 @@ package integration
 
 import (
 	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"slices"
+	"syscall"
+	"testing"
+	"time"
+
 	"github.com/anchore/k8s-inventory/internal/anchore"
 	"github.com/anchore/k8s-inventory/internal/config"
 	jstime "github.com/anchore/k8s-inventory/internal/time"
@@ -13,14 +22,6 @@ import (
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/fake"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"slices"
-	"syscall"
-	"testing"
-	"time"
 )
 
 var (
@@ -605,10 +606,11 @@ func TestGetRegistrationInfo(t *testing.T) {
 	timestamps := []time.Time{time.Now()}
 
 	type args struct {
-		config    *config.Application
-		c         *client.Client
-		namespace string
-		name      string
+		config       *config.Application
+		c            *client.Client
+		namespace    string
+		name         string
+		replicaCount int32
 	}
 	tests := []struct {
 		name string
@@ -632,9 +634,10 @@ func TestGetRegistrationInfo(t *testing.T) {
 					},
 					HealthReportIntervalSeconds: 60,
 				},
-				c:         nil,
-				namespace: "test-namespace",
-				name:      "",
+				c:            nil,
+				namespace:    "test-namespace",
+				name:         "",
+				replicaCount: 1,
 			},
 			want: &Registration{
 				RegistrationID:         uuids[0].String(),
@@ -676,9 +679,10 @@ func TestGetRegistrationInfo(t *testing.T) {
 					},
 					HealthReportIntervalSeconds: 60,
 				},
-				c:         nil,
-				namespace: "test-namespace",
-				name:      "1111223344",
+				c:            nil,
+				namespace:    "test-namespace",
+				name:         "1111223344",
+				replicaCount: 0,
 			},
 			want: &Registration{
 				RegistrationID:         "test-registration-id",
@@ -719,8 +723,9 @@ func TestGetRegistrationInfo(t *testing.T) {
 				c: &client.Client{
 					Clientset: fake.NewSimpleClientset(&pod, &replicaSet, &deployment),
 				},
-				namespace: "test-namespace",
-				name:      "test-pod",
+				namespace:    "test-namespace",
+				name:         "test-pod",
+				replicaCount: 2,
 			},
 			want: &Registration{
 				RegistrationID:         "test-deployment-uid",
@@ -740,6 +745,49 @@ func TestGetRegistrationInfo(t *testing.T) {
 				HealthReportInterval:   60,
 			},
 		},
+		{
+			name: "Values from k8s single replica",
+			args: args{
+				config: &config.Application{
+					AnchoreDetails: config.AnchoreInfo{
+						User: "admin",
+					},
+					AccountRoutes: config.AccountRoutes{
+						"account3": config.AccountRouteDetails{
+							Namespaces: []string{"ns3"},
+						},
+					},
+					KubeConfig: config.KubeConf{
+						Cluster: "k8s-cluster1",
+					},
+					Registration:                config.RegistrationOptions{},
+					HealthReportIntervalSeconds: 60,
+				},
+				c: &client.Client{
+					Clientset: fake.NewSimpleClientset(&pod, &replicaSet, &deployment),
+				},
+				namespace:    "test-namespace",
+				name:         "test-pod",
+				replicaCount: 1,
+			},
+			want: &Registration{
+				RegistrationID:         "test-deployment-uid",
+				RegistrationInstanceID: deployment.ObjectMeta.Name,
+				Type:                   Type,
+				Name:                   "test-deployment-k8s-inventory",
+				Description:            "",
+				Version:                "1.7.0",
+				StartedAt:              jstime.Datetime{Time: timestamps[0].UTC()},
+				Uptime:                 new(jstime.Duration),
+				Username:               "admin",
+				ExplicitlyAccountBound: []string{"account3"},
+				Namespaces:             []string{"ns3"},
+				Configuration:          nil,
+				ClusterName:            "k8s-cluster1",
+				Namespace:              "test-namespace",
+				HealthReportInterval:   60,
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -756,7 +804,7 @@ func TestGetRegistrationInfo(t *testing.T) {
 				return timestamp
 			}
 			result := getRegistrationInfo(tt.args.config, tt.args.c, tt.args.namespace,
-				tt.args.name, NewUUIDMock, nowMock)
+				tt.args.name, tt.args.replicaCount, NewUUIDMock, nowMock)
 			assert.NotNil(t, result)
 			assert.Equal(t, tt.want, result)
 		})