use reduced deployment struct

Signed-off-by: r2k1 <yokree@gmail.com>

pkg/clustercache/clustercache.go

@@ -150,6 +150,28 @@ func transformDaemonSet(input *appsv1.DaemonSet) *DaemonSet {
 	}
 }
 
+type Deployment struct {
+	Name                    string
+	Namespace               string
+	Labels                  map[string]string
+	MatchLabels             map[string]string
+	SpecSelector            *metav1.LabelSelector
+	SpecReplicas            *int32
+	StatusAvailableReplicas int32
+}
+
+func transformDeployment(input *appsv1.Deployment) *Deployment {
+	return &Deployment{
+		Name:                    input.Name,
+		Namespace:               input.Namespace,
+		Labels:                  input.Labels,
+		MatchLabels:             input.Spec.Selector.MatchLabels,
+		SpecReplicas:            input.Spec.Replicas,
+		SpecSelector:            input.Spec.Selector,
+		StatusAvailableReplicas: input.Status.AvailableReplicas,
+	}
+}
+
 // ClusterCache defines an contract for an object which caches components within a cluster, ensuring
 // up to date resources using watchers
 type ClusterCache interface {
@@ -175,7 +197,7 @@ type ClusterCache interface {
 	GetAllDaemonSets() []*DaemonSet
 
 	// GetAllDeployments returns all the cached deployments
-	GetAllDeployments() []*appsv1.Deployment
+	GetAllDeployments() []*Deployment
 
 	// GetAllStatfulSets returns all the cached StatefulSets
 	GetAllStatefulSets() []*appsv1.StatefulSet
@@ -367,16 +389,16 @@ func (kcc *KubernetesClusterCache) GetAllDaemonSets() []*DaemonSet {
 	var daemonsets []*DaemonSet
 	items := kcc.daemonsetsWatch.GetAll()
 	for _, daemonset := range items {
-		daemonsets = append(daemonsets, daemonset.(*DaemonSet))
+		daemonsets = append(daemonsets, transformDaemonSet(daemonset.(*appsv1.DaemonSet)))
 	}
 	return daemonsets
 }
 
-func (kcc *KubernetesClusterCache) GetAllDeployments() []*appsv1.Deployment {
-	var deployments []*appsv1.Deployment
+func (kcc *KubernetesClusterCache) GetAllDeployments() []*Deployment {
+	var deployments []*Deployment
 	items := kcc.deploymentsWatch.GetAll()
 	for _, deployment := range items {
-		deployments = append(deployments, deployment.(*appsv1.Deployment))
+		deployments = append(deployments, transformDeployment(deployment.(*appsv1.Deployment)))
 	}
 	return deployments
 }

pkg/costmodel/costmodel.go

@@ -1468,14 +1468,14 @@ func getPodDeployments(cache clustercache.ClusterCache, podList []*clustercache.
 	deploymentsList := cache.GetAllDeployments()
 	podDeploymentsMapping := make(map[string]map[string][]string) // namespace: podName: [deploymentNames]
 	for _, deployment := range deploymentsList {
-		namespace := deployment.GetObjectMeta().GetNamespace()
-		name := deployment.GetObjectMeta().GetName()
+		namespace := deployment.Namespace
+		name := deployment.Name
 
 		key := namespace + "," + clusterID
 		if _, ok := podDeploymentsMapping[key]; !ok {
 			podDeploymentsMapping[key] = make(map[string][]string)
 		}
-		s, err := metav1.LabelSelectorAsSelector(deployment.Spec.Selector)
+		s, err := metav1.LabelSelectorAsSelector(deployment.SpecSelector)
 		if err != nil {
 			log.Errorf("Error doing deployment label conversion: " + err.Error())
 		}

pkg/costmodel/router.go

@@ -962,11 +962,11 @@ func (a *Accesses) GetAllDeployments(w http.ResponseWriter, r *http.Request, ps
 	deploymentsList := a.ClusterCache.GetAllDeployments()
 
 	// filter for provided namespace
-	var deployments []*appsv1.Deployment
+	var deployments []*clustercache.Deployment
 	if namespace == "" {
 		deployments = deploymentsList
 	} else {
-		deployments = []*appsv1.Deployment{}
+		deployments = []*clustercache.Deployment{}
 
 		for _, d := range deploymentsList {
 			if d.Namespace == namespace {

pkg/metrics/deploymentmetrics.go

@@ -39,10 +39,10 @@ func (kdc KubecostDeploymentCollector) Collect(ch chan<- prometheus.Metric) {
 
 	ds := kdc.KubeClusterCache.GetAllDeployments()
 	for _, deployment := range ds {
-		deploymentName := deployment.GetName()
-		deploymentNS := deployment.GetNamespace()
+		deploymentName := deployment.Name
+		deploymentNS := deployment.Namespace
 
-		labels, values := promutil.KubeLabelsToLabels(promutil.SanitizeLabels(deployment.Spec.Selector.MatchLabels))
+		labels, values := promutil.KubeLabelsToLabels(promutil.SanitizeLabels(deployment.MatchLabels))
 		if len(labels) > 0 {
 			m := newDeploymentMatchLabelsMetric(deploymentName, deploymentNS, "deployment_match_labels", labels, values)
 			ch <- m
@@ -143,15 +143,15 @@ func (kdc KubeDeploymentCollector) Collect(ch chan<- prometheus.Metric) {
 	disabledMetrics := kdc.metricsConfig.GetDisabledMetricsMap()
 
 	for _, deployment := range deployments {
-		deploymentName := deployment.GetName()
-		deploymentNS := deployment.GetNamespace()
+		deploymentName := deployment.Name
+		deploymentNS := deployment.Namespace
 
 		// Replicas Defined
 		var replicas int32
-		if deployment.Spec.Replicas == nil {
+		if deployment.SpecReplicas == nil {
 			replicas = 1 // defaults to 1, documented on the 'Replicas' field
 		} else {
-			replicas = *deployment.Spec.Replicas
+			replicas = *deployment.SpecReplicas
 		}
 
 		if _, disabled := disabledMetrics["kube_deployment_spec_replicas"]; !disabled {
@@ -163,7 +163,7 @@ func (kdc KubeDeploymentCollector) Collect(ch chan<- prometheus.Metric) {
 				"kube_deployment_status_replicas_available",
 				deploymentName,
 				deploymentNS,
-				deployment.Status.AvailableReplicas)
+				deployment.StatusAvailableReplicas)
 		}
 	}
 }