mane namespaces names hash based

Author: mjudeikis

backend/kubernetes/resources/namespace.go

@@ -18,8 +18,11 @@ package resources
 
 import (
 	"context"
+	"crypto/sha256"
+	"fmt"
 	"strings"
 
+	"github.com/martinlindhe/base36"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -54,15 +57,13 @@ func handleLegacyAnnotations(ctx context.Context, cl client.Client, namespace *c
 	return nil
 }
 
-func CreateNamespace(ctx context.Context, client client.Client, generateName, id, author string) (*corev1.Namespace, error) {
-	if !strings.HasSuffix(generateName, "-") {
-		generateName += "-"
-	}
+func CreateNamespace(ctx context.Context, client client.Client, generateNamePrefix, identity, author string) (*corev1.Namespace, error) {
+	name := identityHash(identity)
 	namespace := &corev1.Namespace{
 		ObjectMeta: metav1.ObjectMeta{
-			GenerateName: generateName,
+			Name: fmt.Sprintf("%s-%s", generateNamePrefix, name),
 			Annotations: map[string]string{
-				IdentityAnnotationKey: id,
+				IdentityAnnotationKey: identity,
 				AuthorAnnotationKey:   author,
 			},
 		},
@@ -77,14 +78,19 @@ func CreateNamespace(ctx context.Context, client client.Client, generateName, id
 			return nil, err
 		}
 
-		if namespace.Annotations[IdentityAnnotationKey] != id && namespace.Annotations[legacyIdentityAnnotationKey] != id {
+		if namespace.Annotations[IdentityAnnotationKey] != identity && namespace.Annotations[legacyIdentityAnnotationKey] != identity {
 			return nil, errors.NewAlreadyExists(corev1.Resource("namespace"), namespace.Name)
 		}
 
-		if err := handleLegacyAnnotations(ctx, client, namespace, id); err != nil {
+		if err := handleLegacyAnnotations(ctx, client, namespace, identity); err != nil {
 			return nil, err
 		}
 	}
 
 	return namespace, nil
 }
+
+func identityHash(userName string) string {
+	hash := sha256.Sum224([]byte(userName))
+	return strings.ToLower(base36.EncodeBytes(hash[:8]))
+}

backend/kubernetes/resources/namespace_test.go

@@ -18,47 +18,52 @@ package resources
 
 import (
 	"context"
+	"crypto/sha256"
+	"fmt"
 	"strings"
 	"testing"
 
+	"github.com/martinlindhe/base36"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 )
 
+func expectedIdentityHash(identity string) string {
+	hash := sha256.Sum224([]byte(identity))
+	return strings.ToLower(base36.EncodeBytes(hash[:8]))
+}
+
 func TestCreateNamespace(t *testing.T) {
 	scheme := runtime.NewScheme()
 	_ = corev1.AddToScheme(scheme)
 
 	tests := []struct {
-		name              string
-		generateName      string
-		identity          string
-		author            string
-		wantErr           bool
-		wantNameGenerated bool
-		wantAnnotations   map[string]string
+		name            string
+		generateName    string
+		identity        string
+		author          string
+		wantErr         bool
+		wantAnnotations map[string]string
 	}{
 		{
-			name:              "create new namespace with generateName",
-			generateName:      "test-ns",
-			identity:          "test-id-123",
-			author:            "bob",
-			wantErr:           false,
-			wantNameGenerated: true,
+			name:         "create new namespace with generateName",
+			generateName: "test-ns",
+			identity:     "test-id-123",
+			author:       "bob",
+			wantErr:      false,
 			wantAnnotations: map[string]string{
 				IdentityAnnotationKey: "test-id-123",
 				AuthorAnnotationKey:   "bob",
 			},
 		},
 		{
-			name:              "create new namespace with generateName already ending with dash",
-			generateName:      "test-ns-",
-			identity:          "test-id-456",
-			author:            "alice",
-			wantErr:           false,
-			wantNameGenerated: true,
+			name:         "create new namespace with generateName already ending with dash",
+			generateName: "test-ns-",
+			identity:     "test-id-456",
+			author:       "alice",
+			wantErr:      false,
 			wantAnnotations: map[string]string{
 				IdentityAnnotationKey: "test-id-456",
 				AuthorAnnotationKey:   "alice",
@@ -91,18 +96,16 @@ func TestCreateNamespace(t *testing.T) {
 				return
 			}
 
-			expectedGenerateNamePrefix := tt.generateName
-			if !strings.HasSuffix(expectedGenerateNamePrefix, "-") {
-				expectedGenerateNamePrefix += "-"
+			expectedPrefix := tt.generateName
+			expectedHash := expectedIdentityHash(tt.identity)
+			expectedName := fmt.Sprintf("%s-%s", expectedPrefix, expectedHash)
+
+			if result.Name != expectedName {
+				t.Errorf("CreateNamespace() name = %v, expected %v", result.Name, expectedName)
 			}
 
-			if tt.wantNameGenerated {
-				if !strings.HasPrefix(result.Name, expectedGenerateNamePrefix) {
-					t.Errorf("CreateNamespace() name = %v, expected to start with %v", result.Name, expectedGenerateNamePrefix)
-				}
-				if result.GenerateName != expectedGenerateNamePrefix {
-					t.Errorf("CreateNamespace() generateName = %v, expected %v", result.GenerateName, expectedGenerateNamePrefix)
-				}
+			if result.GenerateName != "" {
+				t.Errorf("CreateNamespace() generateName = %v, expected empty string", result.GenerateName)
 			}
 
 			for key, expectedValue := range tt.wantAnnotations {