KubeModel improvements: safety, registration, etc

core/pkg/model/kubemodel/cluster.go

@@ -1,6 +1,10 @@
 package kubemodel
 
-import "time"
+import (
+	"time"
+)
+
+// TODO: do we need (start, end) for Cluster?
 
 // @bingen:generate:Cluster
 type Cluster struct {
@@ -11,3 +15,14 @@ type Cluster struct {
 	Start    time.Time `json:"start"`    // @bingen:field[version=1]
 	End      time.Time `json:"end"`      // @bingen:field[version=1]
 }
+
+func (kms *KubeModelSet) RegisterCluster(uid string) {
+	if uid == "" {
+		kms.RegisterError("RegisterCluster: uid is nil for Cluster")
+		return
+	}
+
+	if kms.Cluster == nil {
+		kms.Cluster = &Cluster{UID: uid}
+	}
+}

core/pkg/model/kubemodel/kubemodel.go

@@ -1,11 +1,11 @@
 package kubemodel
 
 import (
-	"errors"
-	"fmt"
 	"time"
 )
 
+// TODO: should we add a lock so that we can safely modify KubeModelSet in parallel?
+
 // @bingen:generate[stringtable]:KubeModelSet
 type KubeModelSet struct {
 	Metadata       *Metadata                 `json:"meta"`           // @bingen:field[version=1]
@@ -35,44 +35,8 @@ func NewKubeModelSet(start, end time.Time) *KubeModelSet {
 	}
 }
 
-func (kms *KubeModelSet) RegisterNamespace(uid, name string) error {
-	if _, ok := kms.Namespaces[uid]; !ok {
-		if kms.Cluster == nil {
-			return errors.New("KubeModelSet missing Cluster")
-		}
-
-		kms.Namespaces[uid] = &Namespace{
-			UID:        uid,
-			ClusterUID: kms.Cluster.UID,
-			Name:       name,
-		}
-
-		kms.idx.namespaceByName[name] = kms.Namespaces[uid]
-
-		kms.Metadata.ObjectCount++
-	}
-
-	return nil
-}
-
-func (kms *KubeModelSet) RegisterResourceQuota(uid, name, namespace string) error {
-	if _, ok := kms.ResourceQuotas[uid]; !ok {
-		if _, ok := kms.idx.namespaceByName[namespace]; !ok {
-			return fmt.Errorf("KubeModelSet missing namespace '%s'", namespace)
-		}
-
-		kms.ResourceQuotas[uid] = &ResourceQuota{
-			UID:          uid,
-			Name:         name,
-			NamespaceUID: kms.idx.namespaceByName[namespace].UID,
-			Spec:         &ResourceQuotaSpec{Hard: &ResourceQuotaSpecHard{}},
-			Status:       &ResourceQuotaStatus{Used: &ResourceQuotaStatusUsed{}},
-		}
-
-		kms.Metadata.ObjectCount++
-	}
-
-	return nil
+func (kms *KubeModelSet) RegisterError(str string) {
+	kms.Metadata.Errors = append(kms.Metadata.Errors, str)
 }
 
 func (kms *KubeModelSet) IsEmpty() bool {

core/pkg/model/kubemodel/kubemodel_test.go

@@ -1,3 +1,45 @@
 package kubemodel
 
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+)
+
 // TODO: what tests, specifically, do we need here? Register funcs? Constructor?
+
+func TestKubeModel(t *testing.T) {
+	start := time.Now().UTC().Truncate(time.Hour)
+	end := start.Add(time.Hour)
+
+	kms := NewKubeModelSet(start, end)
+
+	// Test adding a Cluster
+	// 1. Invalid Cluster
+	kms.RegisterCluster("")
+	if kms.Cluster != nil {
+		t.Errorf("Cluster should be nil")
+	}
+	// 2. Valid Cluster
+	kms.RegisterCluster(uuid.New().String())
+	if kms.Cluster == nil {
+		t.Errorf("Cluster should not be nil")
+	}
+	if kms.Cluster.UID == "" {
+		t.Errorf("Cluster should not have empty UID")
+	}
+
+	t.Run("RegisterNamespace", func(t *testing.T) {
+		// Test registering Namespaces
+		// 1. Invalid Namespace
+		// 2. Valid Namespace
+	})
+
+	t.Run("RegisterResourceQuota", func(t *testing.T) {
+		// Test registering ResourceQuotas
+		// 1. Invalid ResourceQuota
+		// 2. Valid ResourceQuota in a valid Namespace
+		// 3. Valid ResourceQuota in an invalid Namespace
+	})
+}

core/pkg/model/kubemodel/namespace.go

@@ -1,6 +1,9 @@
 package kubemodel
 
-import "time"
+import (
+	"fmt"
+	"time"
+)
 
 // @bingen:generate:Namespace
 type Namespace struct {
@@ -12,3 +15,30 @@ type Namespace struct {
 	Start       time.Time         `json:"start"`       // @bingen:field[version=1]
 	End         time.Time         `json:"end"`         // @bingen:field[version=1]
 }
+
+func (kms *KubeModelSet) RegisterNamespace(uid, name string) {
+	if uid == "" {
+		kms.RegisterError(fmt.Sprintf("RegisterNamespace: uid is nil for Namespace '%s'", name))
+		return
+	}
+
+	if _, ok := kms.Namespaces[uid]; !ok {
+		clusterUID := ""
+
+		if kms.Cluster == nil {
+			kms.RegisterError(fmt.Sprintf("RegisterNamespace(%s, %s): Cluster is nil", uid, name))
+		} else {
+			clusterUID = kms.Cluster.UID
+		}
+
+		kms.Namespaces[uid] = &Namespace{
+			UID:        uid,
+			ClusterUID: clusterUID,
+			Name:       name,
+		}
+
+		kms.idx.namespaceByName[name] = kms.Namespaces[uid]
+
+		kms.Metadata.ObjectCount++
+	}
+}

core/pkg/model/kubemodel/resourcequota.go

@@ -1,5 +1,7 @@
 package kubemodel
 
+import "fmt"
+
 // @bingen:generate:ResourceQuota
 type ResourceQuota struct {
 	UID          string               `json:"uid"`          // @bingen:field[version=1]
@@ -30,3 +32,30 @@ type ResourceQuotaStatusUsed struct {
 	Requests ResourceQuantities `json:"requests"` // @bingen:field[version=1]
 	Limits   ResourceQuantities `json:"limits"`   // @bingen:field[version=1]
 }
+
+func (kms *KubeModelSet) RegisterResourceQuota(uid, name, namespace string) {
+	if uid == "" {
+		kms.RegisterError(fmt.Sprintf("RegisterResourceQuota: uid is nil for ResourceQuota '%s'", name))
+		return
+	}
+
+	if _, ok := kms.ResourceQuotas[uid]; !ok {
+		namespaceUID := ""
+
+		if _, ok := kms.idx.namespaceByName[namespace]; !ok {
+			kms.RegisterError(fmt.Sprintf("RegisterResourceQuota(%s, %s, %s): missing namespace", uid, name, namespace))
+		} else {
+			namespaceUID = kms.idx.namespaceByName[namespace].UID
+		}
+
+		kms.ResourceQuotas[uid] = &ResourceQuota{
+			UID:          uid,
+			Name:         name,
+			NamespaceUID: namespaceUID,
+			Spec:         &ResourceQuotaSpec{Hard: &ResourceQuotaSpecHard{}},
+			Status:       &ResourceQuotaStatus{Used: &ResourceQuotaStatusUsed{}},
+		}
+
+		kms.Metadata.ObjectCount++
+	}
+}