Standardize register functions

Signed-off-by: Sean Holcomb <seanholcomb@gmail.com>

core/pkg/model/kubemodel/cluster.go

@@ -1,7 +1,7 @@
 package kubemodel
 
 import (
-	"errors"
+	"fmt"
 	"time"
 
 	"github.com/opencost/opencost/core/pkg/model/shared"
@@ -20,7 +20,12 @@ type Cluster struct {
 
 func (kms *KubeModelSet) RegisterCluster(cluster *Cluster) error {
 	if cluster.UID == "" {
-		err := errors.New("RegisterCluster: uid is nil")
+		err := fmt.Errorf("UID is missing for Cluster with name '%s'", cluster.Name)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, cluster.Start, cluster.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/container.go

@@ -37,6 +37,11 @@ func (kms *KubeModelSet) RegisterContainer(container *Container) error {
 		return err
 	}
 
+	if err := checkWindow(kms.Window, container.Start, container.End); err != nil {
+		kms.Error(err)
+		return err
+	}
+
 	key := container.GetKey()
 	if _, ok := kms.Containers[key]; !ok {
 		kms.Containers[key] = container

core/pkg/model/kubemodel/cronjob.go

@@ -31,18 +31,13 @@ func (kms *KubeModelSet) RegisterCronJob(cronJob *CronJob) error {
 		return err
 	}
 
-	if kms.Window.Start.After(cronJob.Start) ||
-		kms.Window.Start.After(cronJob.End) ||
-		kms.Window.End.Before(cronJob.Start) ||
-		kms.Window.End.Before(cronJob.End) {
-		err := fmt.Errorf(
-			"CronJob '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			cronJob.Name,
-			cronJob.Start.Format(time.RFC3339),
-			cronJob.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if cronJob.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for CronJob '%s'", cronJob.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, cronJob.Start, cronJob.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/daemonset.go

@@ -31,18 +31,13 @@ func (kms *KubeModelSet) RegisterDaemonSet(daemonSet *DaemonSet) error {
 		return err
 	}
 
-	if kms.Window.Start.After(daemonSet.Start) ||
-		kms.Window.Start.After(daemonSet.End) ||
-		kms.Window.End.Before(daemonSet.Start) ||
-		kms.Window.End.Before(daemonSet.End) {
-		err := fmt.Errorf(
-			"DaemonSet '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			daemonSet.Name,
-			daemonSet.Start.Format(time.RFC3339),
-			daemonSet.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if daemonSet.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for DaemonSet '%s'", daemonSet.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, daemonSet.Start, daemonSet.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/dcgm.go

@@ -40,6 +40,11 @@ func (kms *KubeModelSet) RegisterDCGMDevice(device *DCGMDevice) error {
 		return err
 	}
 
+	if err := checkWindow(kms.Window, device.Start, device.End); err != nil {
+		kms.Error(err)
+		return err
+	}
+
 	if _, ok := kms.DCGMDevices[device.UUID]; !ok {
 		if kms.Cluster == nil {
 			kms.Warnf("RegisterDCGMDevice: Cluster is nil")

core/pkg/model/kubemodel/deployment.go

@@ -32,18 +32,13 @@ func (kms *KubeModelSet) RegisterDeployment(deployment *Deployment) error {
 		return err
 	}
 
-	if kms.Window.Start.After(deployment.Start) ||
-		kms.Window.Start.After(deployment.End) ||
-		kms.Window.End.Before(deployment.Start) ||
-		kms.Window.End.Before(deployment.End) {
-		err := fmt.Errorf(
-			"Deployment '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			deployment.Name,
-			deployment.Start.Format(time.RFC3339),
-			deployment.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if deployment.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for Deployment '%s'", deployment.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, deployment.Start, deployment.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/job.go

@@ -31,18 +31,13 @@ func (kms *KubeModelSet) RegisterJob(job *Job) error {
 		return err
 	}
 
-	if kms.Window.Start.After(job.Start) ||
-		kms.Window.Start.After(job.End) ||
-		kms.Window.End.Before(job.Start) ||
-		kms.Window.End.Before(job.End) {
-		err := fmt.Errorf(
-			"Job '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			job.Name,
-			job.Start.Format(time.RFC3339),
-			job.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if job.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for Job '%s'", job.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, job.Start, job.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/kubemodel.go

@@ -1,6 +1,7 @@
 package kubemodel
 
 import (
+	"fmt"
 	"time"
 )
 
@@ -100,6 +101,24 @@ func (kms *KubeModelSet) IsEmpty() bool {
 		len(kms.PersistentVolumes) == 0
 }
 
+// checkWindow validates that the given start/end times are fully contained within
+// the KubeModelSet window. It records and returns an error if they are not.
+func checkWindow(window Window, start, end time.Time) error {
+	if window.Start.After(start) ||
+		window.Start.After(end) ||
+		window.End.Before(start) ||
+		window.End.Before(end) {
+		return fmt.Errorf(
+			"start or end time (%s-%s) is outside of the window %s-%s",
+			start.Format(time.RFC3339),
+			end.Format(time.RFC3339),
+			window.Start.Format(time.RFC3339),
+			window.End.Format(time.RFC3339),
+		)
+	}
+	return nil
+}
+
 type kubeModelSetIndexes struct {
 	namespaceNameToID map[string]string
 	namespaceByName   map[string]*Namespace

core/pkg/model/kubemodel/kubemodel_codecs_test.go

@@ -35,25 +35,17 @@ func TestKubeModelMarshalBinary(t *testing.T) {
 
 	kms.Metadata.CreatedAt = time.Now().UTC()
 
-	kms.RegisterCluster(&Cluster{UID: "cluster"})
-	kms.Cluster.Start = s
-	kms.Cluster.End = e
+	kms.RegisterCluster(&Cluster{UID: "cluster", Start: s, End: e})
 
-	kms.RegisterNamespace(&Namespace{UID: "ns1", Name: "ns1"})
-	kms.Namespaces["ns1"].Start = s
-	kms.Namespaces["ns1"].End = e
+	kms.RegisterNamespace(&Namespace{UID: "ns1", Name: "ns1", Start: s, End: e})
 	kms.Namespaces["ns1"].Labels = map[string]string{"label1": "label1"}
 	kms.Namespaces["ns1"].Annotations = map[string]string{"anno1": "anno1"}
 
-	kms.RegisterNamespace(&Namespace{UID: "ns2", Name: "ns2"})
-	kms.Namespaces["ns2"].Start = s
-	kms.Namespaces["ns2"].End = e
+	kms.RegisterNamespace(&Namespace{UID: "ns2", Name: "ns2", Start: s, End: e})
 	kms.Namespaces["ns2"].Labels = map[string]string{"label2": "label2"}
 	kms.Namespaces["ns2"].Annotations = map[string]string{"anno2": "anno2"}
 
-	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq1", Name: "rq1", NamespaceUID: "ns1"})
-	kms.ResourceQuotas["rq1"].Start = s
-	kms.ResourceQuotas["rq1"].End = e
+	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq1", Name: "rq1", NamespaceUID: "ns1", Start: s, End: e})
 	kms.ResourceQuotas["rq1"].Spec = &ResourceQuotaSpec{
 		Hard: &ResourceQuotaSpecHard{
 			Requests: ResourceQuantities{
@@ -151,9 +143,7 @@ func TestKubeModelMarshalBinary(t *testing.T) {
 		},
 	}
 
-	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq2", Name: "rq2", NamespaceUID: "ns1"})
-	kms.ResourceQuotas["rq2"].Start = s
-	kms.ResourceQuotas["rq2"].End = e
+	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq2", Name: "rq2", NamespaceUID: "ns1", Start: s, End: e})
 	kms.ResourceQuotas["rq2"].Spec = &ResourceQuotaSpec{
 		Hard: &ResourceQuotaSpecHard{
 			Requests: ResourceQuantities{
@@ -251,9 +241,7 @@ func TestKubeModelMarshalBinary(t *testing.T) {
 		},
 	}
 
-	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq3", Name: "rq3", NamespaceUID: "ns2"})
-	kms.ResourceQuotas["rq3"].Start = s
-	kms.ResourceQuotas["rq3"].End = e
+	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq3", Name: "rq3", NamespaceUID: "ns2", Start: s, End: e})
 	kms.ResourceQuotas["rq3"].Spec = &ResourceQuotaSpec{
 		Hard: &ResourceQuotaSpecHard{
 			Requests: ResourceQuantities{
@@ -351,9 +339,7 @@ func TestKubeModelMarshalBinary(t *testing.T) {
 		},
 	}
 
-	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq4", Name: "rq4", NamespaceUID: "ns2"})
-	kms.ResourceQuotas["rq4"].Start = s
-	kms.ResourceQuotas["rq4"].End = e
+	kms.RegisterResourceQuota(&ResourceQuota{UID: "rq4", Name: "rq4", NamespaceUID: "ns2", Start: s, End: e})
 	kms.ResourceQuotas["rq4"].Spec = &ResourceQuotaSpec{
 		Hard: &ResourceQuotaSpecHard{
 			Requests: ResourceQuantities{

core/pkg/model/kubemodel/kubemodel_test.go

@@ -37,7 +37,7 @@ func TestKubeModel(t *testing.T) {
 			require.NotNil(t, err)
 
 			require.Len(t, kms.GetErrors(), 1)
-			require.Equal(t, "RegisterCluster: uid is nil", kms.GetErrors()[0].Message)
+			require.Equal(t, "UID is missing for Cluster with name ''", kms.GetErrors()[0].Message)
 			require.Nil(t, kms.Cluster)
 		})
 
@@ -47,7 +47,7 @@ func TestKubeModel(t *testing.T) {
 
 			kms := NewKubeModelSet(start, end)
 
-			err = kms.RegisterCluster(&Cluster{UID: clusterUID})
+			err = kms.RegisterCluster(&Cluster{UID: clusterUID, Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetErrors(), 0)
@@ -61,7 +61,7 @@ func TestKubeModel(t *testing.T) {
 
 			kms := NewKubeModelSet(start, end)
 
-			err = kms.RegisterCluster(&Cluster{UID: clusterUID})
+			err = kms.RegisterCluster(&Cluster{UID: clusterUID, Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetErrors(), 0)
@@ -69,7 +69,7 @@ func TestKubeModel(t *testing.T) {
 			require.Equal(t, clusterUID, kms.Cluster.UID)
 
 			// Register cluster with same UID, expect no-op on second try
-			err = kms.RegisterCluster(&Cluster{UID: clusterUID})
+			err = kms.RegisterCluster(&Cluster{UID: clusterUID, Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetErrors(), 0)
@@ -77,7 +77,7 @@ func TestKubeModel(t *testing.T) {
 			require.Equal(t, clusterUID, kms.Cluster.UID)
 
 			// Register cluster with another UID (should not happen), expect no-op
-			err = kms.RegisterCluster(&Cluster{UID: "another-uid"})
+			err = kms.RegisterCluster(&Cluster{UID: "another-uid", Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetWarnings(), 1)
@@ -109,13 +109,13 @@ func TestKubeModel(t *testing.T) {
 			testUID := "uid"
 			testName := "name"
 
-			err = kms.RegisterNamespace(&Namespace{UID: testUID, Name: testName})
+			err = kms.RegisterNamespace(&Namespace{UID: testUID, Name: testName, Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetWarnings(), 1)
 			require.Equal(t, "RegisterNamespace: Cluster is nil", kms.GetWarnings()[0].Message)
 
-			testNamespace := &Namespace{UID: testUID, Name: testName}
+			testNamespace := &Namespace{UID: testUID, Name: testName, Start: start, End: end}
 
 			require.NotNil(t, kms.Namespaces[testUID])
 			require.Equal(t, testNamespace, kms.Namespaces[testUID])
@@ -128,7 +128,7 @@ func TestKubeModel(t *testing.T) {
 			var err error
 
 			kms := NewKubeModelSet(start, end)
-			err = kms.RegisterCluster(&Cluster{UID: "cluster-uid"})
+			err = kms.RegisterCluster(&Cluster{UID: "cluster-uid", Start: start, End: end})
 			require.Nil(t, err)
 
 			// At this point we have a KMS with a cluster registered
@@ -136,20 +136,20 @@ func TestKubeModel(t *testing.T) {
 			testUID := "uid"
 			testName := "name"
 
-			err = kms.RegisterNamespace(&Namespace{UID: testUID, Name: testName})
+			err = kms.RegisterNamespace(&Namespace{UID: testUID, Name: testName, Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetErrors(), 0)
 			require.NotNil(t, kms.Namespaces[testUID])
 
-			testNamespace := &Namespace{UID: testUID, Name: testName}
+			testNamespace := &Namespace{UID: testUID, Name: testName, Start: start, End: end}
 
 			require.Equal(t, testNamespace, kms.Namespaces[testUID])
 			require.Equal(t, testNamespace, kms.idx.namespaceByName[testName])
 			require.Equal(t, 1, kms.Metadata.ObjectCount)
 
 			// Register same namespace again, expect no-op on second try
-			err = kms.RegisterNamespace(&Namespace{UID: testUID, Name: testName})
+			err = kms.RegisterNamespace(&Namespace{UID: testUID, Name: testName, Start: start, End: end})
 			require.Nil(t, err)
 
 			require.Len(t, kms.GetErrors(), 0)
@@ -181,25 +181,27 @@ func TestKubeModel(t *testing.T) {
 			err = kms.RegisterResourceQuota(&ResourceQuota{UID: "uid", Name: "name", NamespaceUID: ""})
 			require.NotNil(t, err)
 			require.Len(t, kms.GetErrors(), 1)
-			require.Equal(t, "Namespace is missing for ResourceQuota 'uid'", kms.GetErrors()[0].Message)
+			require.Equal(t, "NamespaceUID is missing for ResourceQuota 'uid'", kms.GetErrors()[0].Message)
 			require.Len(t, kms.ResourceQuotas, 0)
 		})
 
 		t.Run("register resource quota on KMS w/ namespace", func(t *testing.T) {
 			kms := NewKubeModelSet(start, end)
-			kms.RegisterCluster(&Cluster{UID: "cluster-uid"})
-			kms.RegisterNamespace(&Namespace{UID: "namespace-uid", Name: "namespace"})
+			kms.RegisterCluster(&Cluster{UID: "cluster-uid", Start: start, End: end})
+			kms.RegisterNamespace(&Namespace{UID: "namespace-uid", Name: "namespace", Start: start, End: end})
 			// At this point we have a KMS with a cluster and namespace registered
 
 			testUID := "uid"
 			testName := "name"
 
-			kms.RegisterResourceQuota(&ResourceQuota{UID: testUID, Name: testName, NamespaceUID: "namespace-uid"})
+			kms.RegisterResourceQuota(&ResourceQuota{UID: testUID, Name: testName, NamespaceUID: "namespace-uid", Start: start, End: end})
 
 			testRQ := &ResourceQuota{
 				UID:          "uid",
 				NamespaceUID: "namespace-uid",
 				Name:         "name",
+				Start:        start,
+				End:          end,
 				Spec:         &ResourceQuotaSpec{Hard: &ResourceQuotaSpecHard{}},
 				Status:       &ResourceQuotaStatus{Used: &ResourceQuotaStatusUsed{}},
 			}
@@ -210,7 +212,7 @@ func TestKubeModel(t *testing.T) {
 			require.Equal(t, 2, kms.Metadata.ObjectCount) // 1 namespace and 1 RQ
 
 			// Register same RQ again, expect no-op on second try
-			kms.RegisterResourceQuota(&ResourceQuota{UID: testUID, Name: testName, NamespaceUID: "namespace-uid"})
+			kms.RegisterResourceQuota(&ResourceQuota{UID: testUID, Name: testName, NamespaceUID: "namespace-uid", Start: start, End: end})
 			require.Len(t, kms.GetErrors(), 0)
 			require.NotNil(t, kms.ResourceQuotas[testUID])
 			require.Equal(t, testRQ, kms.ResourceQuotas[testUID])
@@ -219,12 +221,12 @@ func TestKubeModel(t *testing.T) {
 
 		t.Run("register multiple RQs in multiple namespaces", func(t *testing.T) {
 			kms := NewKubeModelSet(start, end)
-			kms.RegisterCluster(&Cluster{UID: "cluster-uid"})
-			kms.RegisterNamespace(&Namespace{UID: "namespace-1-uid", Name: "namespace-1"})
-			kms.RegisterNamespace(&Namespace{UID: "namespace-2-uid", Name: "namespace-2"})
+			kms.RegisterCluster(&Cluster{UID: "cluster-uid", Start: start, End: end})
+			kms.RegisterNamespace(&Namespace{UID: "namespace-1-uid", Name: "namespace-1", Start: start, End: end})
+			kms.RegisterNamespace(&Namespace{UID: "namespace-2-uid", Name: "namespace-2", Start: start, End: end})
 
-			kms.RegisterResourceQuota(&ResourceQuota{UID: "uid-1", Name: "name-1", NamespaceUID: "namespace-1-uid"})
-			kms.RegisterResourceQuota(&ResourceQuota{UID: "uid-2", Name: "name-2", NamespaceUID: "namespace-2-uid"})
+			kms.RegisterResourceQuota(&ResourceQuota{UID: "uid-1", Name: "name-1", NamespaceUID: "namespace-1-uid", Start: start, End: end})
+			kms.RegisterResourceQuota(&ResourceQuota{UID: "uid-2", Name: "name-2", NamespaceUID: "namespace-2-uid", Start: start, End: end})
 
 			require.Len(t, kms.GetErrors(), 0)
 			require.NotNil(t, kms.ResourceQuotas)
@@ -234,6 +236,8 @@ func TestKubeModel(t *testing.T) {
 				UID:          "uid-1",
 				NamespaceUID: "namespace-1-uid",
 				Name:         "name-1",
+				Start:        start,
+				End:          end,
 				Spec:         &ResourceQuotaSpec{Hard: &ResourceQuotaSpecHard{}},
 				Status:       &ResourceQuotaStatus{Used: &ResourceQuotaStatusUsed{}},
 			}
@@ -241,6 +245,8 @@ func TestKubeModel(t *testing.T) {
 				UID:          "uid-2",
 				NamespaceUID: "namespace-2-uid",
 				Name:         "name-2",
+				Start:        start,
+				End:          end,
 				Spec:         &ResourceQuotaSpec{Hard: &ResourceQuotaSpecHard{}},
 				Status:       &ResourceQuotaStatus{Used: &ResourceQuotaStatusUsed{}},
 			}
@@ -253,9 +259,9 @@ func TestKubeModel(t *testing.T) {
 			err := kms.RegisterResourceQuota(&ResourceQuota{UID: "uid-3", Name: "name-3", NamespaceUID: ""})
 			require.NotNil(t, err)
 			require.Len(t, kms.GetErrors(), 1)
-			require.Equal(t, "Namespace is missing for ResourceQuota 'uid-3'", kms.GetErrors()[0].Message)
-			require.Len(t, kms.ResourceQuotas, 2)          // still 2
-			require.Equal(t, 4, kms.Metadata.ObjectCount)  // unchanged
+			require.Equal(t, "NamespaceUID is missing for ResourceQuota 'uid-3'", kms.GetErrors()[0].Message)
+			require.Len(t, kms.ResourceQuotas, 2)         // still 2
+			require.Equal(t, 4, kms.Metadata.ObjectCount) // unchanged
 		})
 	})
 }

core/pkg/model/kubemodel/namespace.go

@@ -32,6 +32,11 @@ func (kms *KubeModelSet) RegisterNamespace(namespace *Namespace) error {
 		return err
 	}
 
+	if err := checkWindow(kms.Window, namespace.Start, namespace.End); err != nil {
+		kms.Error(err)
+		return err
+	}
+
 	if _, ok := kms.Namespaces[namespace.UID]; !ok {
 		if kms.Cluster == nil {
 			kms.Warnf("RegisterNamespace: Cluster is nil")

core/pkg/model/kubemodel/node.go

@@ -46,18 +46,7 @@ func (kms *KubeModelSet) RegisterNode(node *Node) error {
 		return err
 	}
 
-	if kms.Window.Start.After(node.Start) ||
-		kms.Window.Start.After(node.End) ||
-		kms.Window.End.Before(node.Start) ||
-		kms.Window.End.Before(node.End) {
-		err := fmt.Errorf(
-			"Node '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			node.UID,
-			node.Start.Format(time.RFC3339),
-			node.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if err := checkWindow(kms.Window, node.Start, node.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/pod.go

@@ -40,18 +40,13 @@ func (kms *KubeModelSet) RegisterPod(pod *Pod) error {
 		return err
 	}
 
-	if kms.Window.Start.After(pod.Start) ||
-		kms.Window.Start.After(pod.End) ||
-		kms.Window.End.Before(pod.Start) ||
-		kms.Window.End.Before(pod.End) {
-		err := fmt.Errorf(
-			"Pod '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			pod.UID,
-			pod.Start.Format(time.RFC3339),
-			pod.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if pod.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for Pod '%s'", pod.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, pod.Start, pod.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/pv.go

@@ -18,7 +18,18 @@ type PersistentVolume struct {
 
 func (kms *KubeModelSet) RegisterPersistentVolume(pv *PersistentVolume) error {
 	if pv.UID == "" {
-		err := fmt.Errorf("UID is nil for PersistentVolume '%s'", pv.Name)
+		err := fmt.Errorf("UID is missing for PersistentVolume with name '%s'", pv.Name)
+		kms.Error(err)
+		return err
+	}
+
+	if pv.Name == "" {
+		err := fmt.Errorf("Name is missing for PersistentVolume '%s'", pv.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, pv.Start, pv.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/pvc.go

@@ -21,7 +21,24 @@ type PersistentVolumeClaim struct {
 
 func (kms *KubeModelSet) RegisterPVC(pvc *PersistentVolumeClaim) error {
 	if pvc.UID == "" {
-		err := fmt.Errorf("UID is nil for PVC '%s'", pvc.Name)
+		err := fmt.Errorf("UID is missing for PVC with name '%s'", pvc.Name)
+		kms.Error(err)
+		return err
+	}
+
+	if pvc.Name == "" {
+		err := fmt.Errorf("Name is missing for PVC '%s'", pvc.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if pvc.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for PVC '%s'", pvc.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, pvc.Start, pvc.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/replicaset.go

@@ -32,18 +32,13 @@ func (kms *KubeModelSet) RegisterReplicaSet(replicaSet *ReplicaSet) error {
 		return err
 	}
 
-	if kms.Window.Start.After(replicaSet.Start) ||
-		kms.Window.Start.After(replicaSet.End) ||
-		kms.Window.End.Before(replicaSet.Start) ||
-		kms.Window.End.Before(replicaSet.End) {
-		err := fmt.Errorf(
-			"ReplicaSet '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			replicaSet.Name,
-			replicaSet.Start.Format(time.RFC3339),
-			replicaSet.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if replicaSet.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for ReplicaSet '%s'", replicaSet.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, replicaSet.Start, replicaSet.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/resourcequota.go

@@ -85,7 +85,12 @@ func (kms *KubeModelSet) RegisterResourceQuota(resourceQuota *ResourceQuota) err
 	}
 
 	if resourceQuota.NamespaceUID == "" {
-		err := fmt.Errorf("Namespace is missing for ResourceQuota '%s'", resourceQuota.UID)
+		err := fmt.Errorf("NamespaceUID is missing for ResourceQuota '%s'", resourceQuota.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, resourceQuota.Start, resourceQuota.End); err != nil {
 		kms.Error(err)
 		return err
 	}

core/pkg/model/kubemodel/service.go

@@ -67,6 +67,11 @@ func (kms *KubeModelSet) RegisterService(service *Service) error {
 		return err
 	}
 
+	if err := checkWindow(kms.Window, service.Start, service.End); err != nil {
+		kms.Error(err)
+		return err
+	}
+
 	if _, ok := kms.Services[service.UID]; !ok {
 		kms.Services[service.UID] = service
 		kms.Metadata.ObjectCount++

core/pkg/model/kubemodel/statefulset.go

@@ -32,18 +32,13 @@ func (kms *KubeModelSet) RegisterStatefulSet(statefulSet *StatefulSet) error {
 		return err
 	}
 
-	if kms.Window.Start.After(statefulSet.Start) ||
-		kms.Window.Start.After(statefulSet.End) ||
-		kms.Window.End.Before(statefulSet.Start) ||
-		kms.Window.End.Before(statefulSet.End) {
-		err := fmt.Errorf(
-			"StatefulSet '%s' has a start or end time (%s-%s) outside of the window %s-%s",
-			statefulSet.Name,
-			statefulSet.Start.Format(time.RFC3339),
-			statefulSet.End.Format(time.RFC3339),
-			kms.Window.Start.Format(time.RFC3339),
-			kms.Window.End.Format(time.RFC3339),
-		)
+	if statefulSet.NamespaceUID == "" {
+		err := fmt.Errorf("NamespaceUID is missing for StatefulSet '%s'", statefulSet.UID)
+		kms.Error(err)
+		return err
+	}
+
+	if err := checkWindow(kms.Window, statefulSet.Start, statefulSet.End); err != nil {
 		kms.Error(err)
 		return err
 	}