add validators to individual types

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

core/pkg/model/kubemodel/cluster.go

@@ -18,15 +18,23 @@ type Cluster struct {
 	End      time.Time       `json:"end"`      // @bingen:field[version=1]
 }
 
-func (kms *KubeModelSet) RegisterCluster(cluster *Cluster) error {
-	if cluster.UID == "" {
-		err := fmt.Errorf("UID is missing for Cluster with name '%s'", cluster.Name)
-		kms.Error(err)
+func (c *Cluster) ValidateCluster(window Window) error {
+	if c.UID == "" {
+		err := fmt.Errorf("UID is missing for Cluster with name '%s'", c.Name)
+		return err
+	}
+
+	if err := checkWindow(window, c.Start, c.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, cluster.Start, cluster.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterCluster(cluster *Cluster) error {
+	err := cluster.ValidateCluster(kms.Window)
+	if err != nil {
+		kms.Errorf("RegisterCluster: invalid cluster: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/container.go

@@ -23,22 +23,25 @@ func (c *Container) GetKey() string {
 	return fmt.Sprintf("%s/%s", c.PodUID, c.Name)
 }
 
-func (kms *KubeModelSet) RegisterContainer(container *Container) error {
-	// Check required fields
-	if container.PodUID == "" {
-		err := fmt.Errorf("PodUID is missing for Container with name '%s'", container.Name)
-		kms.Error(err)
-		return err
+func (c *Container) ValidateContainer(window Window) error {
+	if c.PodUID == "" {
+		return fmt.Errorf("PodUID is missing for Container with name '%s'", c.Name)
+	}
+
+	if c.Name == "" {
+		return fmt.Errorf("Name is missing for Container on pod '%s'", c.PodUID)
 	}
 
-	if container.Name == "" {
-		err := fmt.Errorf("Name is missing for Container on pod '%s'", container.PodUID)
-		kms.Error(err)
+	if err := checkWindow(window, c.Start, c.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, container.Start, container.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterContainer(container *Container) error {
+	if err := container.ValidateContainer(kms.Window); err != nil {
+		kms.Errorf("RegisterContainer: invalid container: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/cronjob.go

@@ -17,28 +17,29 @@ type CronJob struct {
 	End          time.Time         `json:"end,omitempty"`
 }
 
-func (kms *KubeModelSet) RegisterCronJob(cronJob *CronJob) error {
-	// Check required fields
-	if cronJob.UID == "" {
-		err := fmt.Errorf("UID is missing for CronJob with name '%s'", cronJob.Name)
-		kms.Error(err)
-		return err
+func (c *CronJob) ValidateCronJob(window Window) error {
+	if c.UID == "" {
+		return fmt.Errorf("UID is missing for CronJob with name '%s'", c.Name)
 	}
 
-	if cronJob.Name == "" {
-		err := fmt.Errorf("Name is missing for CronJob '%s'", cronJob.UID)
-		kms.Error(err)
-		return err
+	if c.Name == "" {
+		return fmt.Errorf("Name is missing for CronJob '%s'", c.UID)
+	}
+
+	if c.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for CronJob '%s'", c.UID)
 	}
 
-	if cronJob.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for CronJob '%s'", cronJob.UID)
-		kms.Error(err)
+	if err := checkWindow(window, c.Start, c.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, cronJob.Start, cronJob.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterCronJob(cronJob *CronJob) error {
+	if err := cronJob.ValidateCronJob(kms.Window); err != nil {
+		kms.Errorf("RegisterCronJob: invalid cronjob: %w", err)
 		return err
 	}
 
@@ -53,4 +54,4 @@ func (kms *KubeModelSet) RegisterCronJob(cronJob *CronJob) error {
 	}
 
 	return nil
-}
+}

core/pkg/model/kubemodel/daemonset.go

@@ -17,28 +17,29 @@ type DaemonSet struct {
 	End          time.Time         `json:"end,omitempty"`
 }
 
-func (kms *KubeModelSet) RegisterDaemonSet(daemonSet *DaemonSet) error {
-	// Check required fields
-	if daemonSet.UID == "" {
-		err := fmt.Errorf("UID is missing for DaemonSet with name '%s'", daemonSet.Name)
-		kms.Error(err)
-		return err
+func (d *DaemonSet) ValidateDaemonSet(window Window) error {
+	if d.UID == "" {
+		return fmt.Errorf("UID is missing for DaemonSet with name '%s'", d.Name)
 	}
 
-	if daemonSet.Name == "" {
-		err := fmt.Errorf("Name is missing for DaemonSet '%s'", daemonSet.UID)
-		kms.Error(err)
-		return err
+	if d.Name == "" {
+		return fmt.Errorf("Name is missing for DaemonSet '%s'", d.UID)
+	}
+
+	if d.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for DaemonSet '%s'", d.UID)
 	}
 
-	if daemonSet.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for DaemonSet '%s'", daemonSet.UID)
-		kms.Error(err)
+	if err := checkWindow(window, d.Start, d.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, daemonSet.Start, daemonSet.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterDaemonSet(daemonSet *DaemonSet) error {
+	if err := daemonSet.ValidateDaemonSet(kms.Window); err != nil {
+		kms.Errorf("RegisterDaemonSet: invalid daemonset: %w", err)
 		return err
 	}
 
@@ -53,4 +54,4 @@ func (kms *KubeModelSet) RegisterDaemonSet(daemonSet *DaemonSet) error {
 	}
 
 	return nil
-}
+}

core/pkg/model/kubemodel/dcgm.go

@@ -32,16 +32,22 @@ type DCGMContainer struct {
 	UsageMax float64
 }
 
-// RegisterDCGMDevice validates and adds a DCGMDevice to the set, keyed by UUID.
-func (kms *KubeModelSet) RegisterDCGMDevice(device *DCGMDevice) error {
-	if device.UUID == "" {
-		err := fmt.Errorf("UUID is missing for DCGMDevice with device '%s'", device.Device)
-		kms.Error(err)
+func (d *DCGMDevice) ValidateDCGMDevice(window Window) error {
+	if d.UUID == "" {
+		return fmt.Errorf("UUID is missing for DCGMDevice with device '%s'", d.Device)
+	}
+
+	if err := checkWindow(window, d.Start, d.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, device.Start, device.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+// RegisterDCGMDevice validates and adds a DCGMDevice to the set, keyed by UUID.
+func (kms *KubeModelSet) RegisterDCGMDevice(device *DCGMDevice) error {
+	if err := device.ValidateDCGMDevice(kms.Window); err != nil {
+		kms.Errorf("RegisterDCGMDevice: invalid dcgm device: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/deployment.go

@@ -18,28 +18,29 @@ type Deployment struct {
 	End          time.Time         `json:"end"`
 }
 
-func (kms *KubeModelSet) RegisterDeployment(deployment *Deployment) error {
-	// Check required fields
-	if deployment.UID == "" {
-		err := fmt.Errorf("UID is missing for Deployment with name '%s'", deployment.Name)
-		kms.Error(err)
-		return err
+func (d *Deployment) ValidateDeployment(window Window) error {
+	if d.UID == "" {
+		return fmt.Errorf("UID is missing for Deployment with name '%s'", d.Name)
 	}
 
-	if deployment.Name == "" {
-		err := fmt.Errorf("Name is missing for Deployment '%s'", deployment.UID)
-		kms.Error(err)
-		return err
+	if d.Name == "" {
+		return fmt.Errorf("Name is missing for Deployment '%s'", d.UID)
+	}
+
+	if d.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for Deployment '%s'", d.UID)
 	}
 
-	if deployment.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for Deployment '%s'", deployment.UID)
-		kms.Error(err)
+	if err := checkWindow(window, d.Start, d.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, deployment.Start, deployment.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterDeployment(deployment *Deployment) error {
+	if err := deployment.ValidateDeployment(kms.Window); err != nil {
+		kms.Errorf("RegisterDeployment: invalid deployment: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/job.go

@@ -17,28 +17,29 @@ type Job struct {
 	End          time.Time         `json:"end,omitempty"`
 }
 
-func (kms *KubeModelSet) RegisterJob(job *Job) error {
-	// Check required fields
-	if job.UID == "" {
-		err := fmt.Errorf("UID is missing for Job with name '%s'", job.Name)
-		kms.Error(err)
-		return err
+func (j *Job) ValidateJob(window Window) error {
+	if j.UID == "" {
+		return fmt.Errorf("UID is missing for Job with name '%s'", j.Name)
 	}
 
-	if job.Name == "" {
-		err := fmt.Errorf("Name is missing for Job '%s'", job.UID)
-		kms.Error(err)
-		return err
+	if j.Name == "" {
+		return fmt.Errorf("Name is missing for Job '%s'", j.UID)
+	}
+
+	if j.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for Job '%s'", j.UID)
 	}
 
-	if job.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for Job '%s'", job.UID)
-		kms.Error(err)
+	if err := checkWindow(window, j.Start, j.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, job.Start, job.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterJob(job *Job) error {
+	if err := job.ValidateJob(kms.Window); err != nil {
+		kms.Errorf("RegisterJob: invalid job: %w", err)
 		return err
 	}
 
@@ -53,4 +54,4 @@ func (kms *KubeModelSet) RegisterJob(job *Job) error {
 	}
 
 	return nil
-}
+}

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, "UID is missing for Cluster with name ''", kms.GetErrors()[0].Message)
+			require.Equal(t, "RegisterCluster: invalid cluster: UID is missing for Cluster with name ''", kms.GetErrors()[0].Message)
 			require.Nil(t, kms.Cluster)
 		})
 
@@ -97,7 +97,7 @@ func TestKubeModel(t *testing.T) {
 			require.NotNil(t, err)
 
 			require.Len(t, kms.GetErrors(), 1)
-			require.Equal(t, "UID is missing for Namespace with name ''", kms.GetErrors()[0].Message)
+			require.Equal(t, "RegisterNamespace: invalid namespace: UID is missing for Namespace with name ''", kms.GetErrors()[0].Message)
 			require.Len(t, kms.Namespaces, 0)
 		})
 
@@ -169,7 +169,7 @@ func TestKubeModel(t *testing.T) {
 			err = kms.RegisterResourceQuota(&ResourceQuota{UID: "", Name: "test"})
 			require.NotNil(t, err)
 			require.Len(t, kms.GetErrors(), 1)
-			require.Equal(t, "UID is missing for ResourceQuota with name 'test'", kms.GetErrors()[0].Message)
+			require.Equal(t, "RegisterResourceQuota: invalid resource quota: UID is missing for ResourceQuota with name 'test'", kms.GetErrors()[0].Message)
 			require.Len(t, kms.ResourceQuotas, 0)
 		})
 
@@ -181,7 +181,7 @@ 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, "NamespaceUID is missing for ResourceQuota 'uid'", kms.GetErrors()[0].Message)
+			require.Equal(t, "RegisterResourceQuota: invalid resource quota: NamespaceUID is missing for ResourceQuota 'uid'", kms.GetErrors()[0].Message)
 			require.Len(t, kms.ResourceQuotas, 0)
 		})
 
@@ -259,7 +259,7 @@ 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, "NamespaceUID is missing for ResourceQuota 'uid-3'", kms.GetErrors()[0].Message)
+			require.Equal(t, "RegisterResourceQuota: invalid resource quota: 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

@@ -18,22 +18,25 @@ type Namespace struct {
 	End               time.Time         `json:"end,omitempty"`   // @bingen:field[version=1]
 }
 
-func (kms *KubeModelSet) RegisterNamespace(namespace *Namespace) error {
-	// Check required fields
-	if namespace.UID == "" {
-		err := fmt.Errorf("UID is missing for Namespace with name '%s'", namespace.Name)
-		kms.Error(err)
-		return err
+func (n *Namespace) ValidateNamespace(window Window) error {
+	if n.UID == "" {
+		return fmt.Errorf("UID is missing for Namespace with name '%s'", n.Name)
+	}
+
+	if n.Name == "" {
+		return fmt.Errorf("Name is missing for Namespace '%s'", n.UID)
 	}
 
-	if namespace.Name == "" {
-		err := fmt.Errorf("Name is missing for Namespace '%s'", namespace.UID)
-		kms.Error(err)
+	if err := checkWindow(window, n.Start, n.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, namespace.Start, namespace.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterNamespace(namespace *Namespace) error {
+	if err := namespace.ValidateNamespace(kms.Window); err != nil {
+		kms.Errorf("RegisterNamespace: invalid namespace: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/node.go

@@ -31,23 +31,26 @@ type FileSystem struct {
 	UsageByteMax  float64 `json:"usageByteMax"`
 }
 
-// RegisterNode validates and adds a node to the set
-func (kms *KubeModelSet) RegisterNode(node *Node) error {
-	// Check required fields
-	if node.UID == "" {
-		err := fmt.Errorf("UID is missing for Node with name '%s'", node.Name)
-		kms.Error(err)
-		return err
+func (n *Node) ValidateNode(window Window) error {
+	if n.UID == "" {
+		return fmt.Errorf("UID is missing for Node with name '%s'", n.Name)
+	}
+
+	if n.Name == "" {
+		return fmt.Errorf("Name is missing for Node '%s'", n.UID)
 	}
 
-	if node.Name == "" {
-		err := fmt.Errorf("Name is missing for Node '%s'", node.UID)
-		kms.Error(err)
+	if err := checkWindow(window, n.Start, n.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, node.Start, node.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+// RegisterNode validates and adds a node to the set
+func (kms *KubeModelSet) RegisterNode(node *Node) error {
+	if err := node.ValidateNode(kms.Window); err != nil {
+		kms.Errorf("RegisterNode: invalid node: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/pod.go

@@ -26,28 +26,29 @@ type Pod struct {
 	End                   time.Time              `json:"end"`
 }
 
-func (kms *KubeModelSet) RegisterPod(pod *Pod) error {
-	// Check required fields
-	if pod.UID == "" {
-		err := fmt.Errorf("UID is missing for Pod with name '%s'", pod.Name)
-		kms.Error(err)
-		return err
+func (p *Pod) ValidatePod(window Window) error {
+	if p.UID == "" {
+		return fmt.Errorf("UID is missing for Pod with name '%s'", p.Name)
 	}
 
-	if pod.Name == "" {
-		err := fmt.Errorf("Name is missing for Pod '%s'", pod.UID)
-		kms.Error(err)
-		return err
+	if p.Name == "" {
+		return fmt.Errorf("Name is missing for Pod '%s'", p.UID)
+	}
+
+	if p.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for Pod '%s'", p.UID)
 	}
 
-	if pod.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for Pod '%s'", pod.UID)
-		kms.Error(err)
+	if err := checkWindow(window, p.Start, p.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, pod.Start, pod.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterPod(pod *Pod) error {
+	if err := pod.ValidatePod(kms.Window); err != nil {
+		kms.Errorf("RegisterPod: invalid pod: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/pv.go

@@ -16,21 +16,25 @@ type PersistentVolume struct {
 	End             time.Time `json:"end"`
 }
 
-func (kms *KubeModelSet) RegisterPersistentVolume(pv *PersistentVolume) error {
-	if pv.UID == "" {
-		err := fmt.Errorf("UID is missing for PersistentVolume with name '%s'", pv.Name)
-		kms.Error(err)
-		return err
+func (p *PersistentVolume) ValidatePersistentVolume(window Window) error {
+	if p.UID == "" {
+		return fmt.Errorf("UID is missing for PersistentVolume with name '%s'", p.Name)
+	}
+
+	if p.Name == "" {
+		return fmt.Errorf("Name is missing for PersistentVolume '%s'", p.UID)
 	}
 
-	if pv.Name == "" {
-		err := fmt.Errorf("Name is missing for PersistentVolume '%s'", pv.UID)
-		kms.Error(err)
+	if err := checkWindow(window, p.Start, p.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, pv.Start, pv.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterPersistentVolume(pv *PersistentVolume) error {
+	if err := pv.ValidatePersistentVolume(kms.Window); err != nil {
+		kms.Errorf("RegisterPersistentVolume: invalid persistent volume: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/pvc.go

@@ -19,27 +19,29 @@ type PersistentVolumeClaim struct {
 	UsageBytesMax       float64   `json:"usageBytesMax"`
 }
 
-func (kms *KubeModelSet) RegisterPVC(pvc *PersistentVolumeClaim) error {
-	if pvc.UID == "" {
-		err := fmt.Errorf("UID is missing for PVC with name '%s'", pvc.Name)
-		kms.Error(err)
-		return err
+func (p *PersistentVolumeClaim) ValidatePVC(window Window) error {
+	if p.UID == "" {
+		return fmt.Errorf("UID is missing for PVC with name '%s'", p.Name)
 	}
 
-	if pvc.Name == "" {
-		err := fmt.Errorf("Name is missing for PVC '%s'", pvc.UID)
-		kms.Error(err)
-		return err
+	if p.Name == "" {
+		return fmt.Errorf("Name is missing for PVC '%s'", p.UID)
+	}
+
+	if p.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for PVC '%s'", p.UID)
 	}
 
-	if pvc.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for PVC '%s'", pvc.UID)
-		kms.Error(err)
+	if err := checkWindow(window, p.Start, p.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, pvc.Start, pvc.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterPVC(pvc *PersistentVolumeClaim) error {
+	if err := pvc.ValidatePVC(kms.Window); err != nil {
+		kms.Errorf("RegisterPVC: invalid pvc: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/replicaset.go

@@ -18,28 +18,29 @@ type ReplicaSet struct {
 	End          time.Time         `json:"end,omitempty"`
 }
 
-func (kms *KubeModelSet) RegisterReplicaSet(replicaSet *ReplicaSet) error {
-	// Check required fields
-	if replicaSet.UID == "" {
-		err := fmt.Errorf("UID is missing for ReplicaSet with name '%s'", replicaSet.Name)
-		kms.Error(err)
-		return err
+func (r *ReplicaSet) ValidateReplicaSet(window Window) error {
+	if r.UID == "" {
+		return fmt.Errorf("UID is missing for ReplicaSet with name '%s'", r.Name)
 	}
 
-	if replicaSet.Name == "" {
-		err := fmt.Errorf("Name is missing for ReplicaSet '%s'", replicaSet.UID)
-		kms.Error(err)
-		return err
+	if r.Name == "" {
+		return fmt.Errorf("Name is missing for ReplicaSet '%s'", r.UID)
+	}
+
+	if r.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for ReplicaSet '%s'", r.UID)
 	}
 
-	if replicaSet.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for ReplicaSet '%s'", replicaSet.UID)
-		kms.Error(err)
+	if err := checkWindow(window, r.Start, r.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, replicaSet.Start, replicaSet.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterReplicaSet(replicaSet *ReplicaSet) error {
+	if err := replicaSet.ValidateReplicaSet(kms.Window); err != nil {
+		kms.Errorf("RegisterReplicaSet: invalid replicaset: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/resourcequota.go

@@ -70,28 +70,29 @@ func (stat *ResourceQuotaStatusUsed) SetLimit(resource Resource, unit Unit, stat
 	stat.Limits.Set(resource, unit, statType, value)
 }
 
-func (kms *KubeModelSet) RegisterResourceQuota(resourceQuota *ResourceQuota) error {
-	// Check required fields
-	if resourceQuota.UID == "" {
-		err := fmt.Errorf("UID is missing for ResourceQuota with name '%s'", resourceQuota.Name)
-		kms.Error(err)
-		return err
+func (rq *ResourceQuota) ValidateResourceQuota(window Window) error {
+	if rq.UID == "" {
+		return fmt.Errorf("UID is missing for ResourceQuota with name '%s'", rq.Name)
 	}
 
-	if resourceQuota.Name == "" {
-		err := fmt.Errorf("Name is missing for ResourceQuota '%s'", resourceQuota.UID)
-		kms.Error(err)
-		return err
+	if rq.Name == "" {
+		return fmt.Errorf("Name is missing for ResourceQuota '%s'", rq.UID)
+	}
+
+	if rq.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for ResourceQuota '%s'", rq.UID)
 	}
 
-	if resourceQuota.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for ResourceQuota '%s'", resourceQuota.UID)
-		kms.Error(err)
+	if err := checkWindow(window, rq.Start, rq.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, resourceQuota.Start, resourceQuota.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterResourceQuota(resourceQuota *ResourceQuota) error {
+	if err := resourceQuota.ValidateResourceQuota(kms.Window); err != nil {
+		kms.Errorf("RegisterResourceQuota: invalid resource quota: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/service.go

@@ -47,28 +47,29 @@ type Service struct {
 	Selector map[string]string `json:"selector,omitempty"`
 }
 
-func (kms *KubeModelSet) RegisterService(service *Service) error {
-	// Check required fields
-	if service.UID == "" {
-		err := fmt.Errorf("UID is missing for Service with name '%s'", service.Name)
-		kms.Error(err)
-		return err
+func (s *Service) ValidateService(window Window) error {
+	if s.UID == "" {
+		return fmt.Errorf("UID is missing for Service with name '%s'", s.Name)
 	}
 
-	if service.Name == "" {
-		err := fmt.Errorf("Name is missing for Service '%s'", service.UID)
-		kms.Error(err)
-		return err
+	if s.Name == "" {
+		return fmt.Errorf("Name is missing for Service '%s'", s.UID)
+	}
+
+	if s.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for Service '%s'", s.UID)
 	}
 
-	if service.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for Service '%s'", service.UID)
-		kms.Error(err)
+	if err := checkWindow(window, s.Start, s.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, service.Start, service.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterService(service *Service) error {
+	if err := service.ValidateService(kms.Window); err != nil {
+		kms.Errorf("RegisterService: invalid service: %w", err)
 		return err
 	}
 

core/pkg/model/kubemodel/statefulset.go

@@ -18,28 +18,29 @@ type StatefulSet struct {
 	End          time.Time         `json:"end,omitempty"`
 }
 
-func (kms *KubeModelSet) RegisterStatefulSet(statefulSet *StatefulSet) error {
-	// Check required fields
-	if statefulSet.UID == "" {
-		err := fmt.Errorf("UID is missing for StatefulSet with name '%s'", statefulSet.Name)
-		kms.Error(err)
-		return err
+func (s *StatefulSet) ValidateStatefulSet(window Window) error {
+	if s.UID == "" {
+		return fmt.Errorf("UID is missing for StatefulSet with name '%s'", s.Name)
 	}
 
-	if statefulSet.Name == "" {
-		err := fmt.Errorf("Name is missing for StatefulSet '%s'", statefulSet.UID)
-		kms.Error(err)
-		return err
+	if s.Name == "" {
+		return fmt.Errorf("Name is missing for StatefulSet '%s'", s.UID)
+	}
+
+	if s.NamespaceUID == "" {
+		return fmt.Errorf("NamespaceUID is missing for StatefulSet '%s'", s.UID)
 	}
 
-	if statefulSet.NamespaceUID == "" {
-		err := fmt.Errorf("NamespaceUID is missing for StatefulSet '%s'", statefulSet.UID)
-		kms.Error(err)
+	if err := checkWindow(window, s.Start, s.End); err != nil {
 		return err
 	}
 
-	if err := checkWindow(kms.Window, statefulSet.Start, statefulSet.End); err != nil {
-		kms.Error(err)
+	return nil
+}
+
+func (kms *KubeModelSet) RegisterStatefulSet(statefulSet *StatefulSet) error {
+	if err := statefulSet.ValidateStatefulSet(kms.Window); err != nil {
+		kms.Errorf("RegisterStatefulSet: invalid statefulset: %w", err)
 		return err
 	}
 
@@ -54,4 +55,4 @@ func (kms *KubeModelSet) RegisterStatefulSet(statefulSet *StatefulSet) error {
 	}
 
 	return nil
-}
+}