fix: Port number fix in helm app

api/restHandler/AppListingRestHandler.go

@@ -1624,117 +1624,16 @@ func (handler AppListingRestHandlerImpl) fetchResourceTree(w http.ResponseWriter
 	clusterIdString := strconv.Itoa(cdPipeline.Environment.ClusterId)
 	validRequest := handler.k8sCommonService.FilterK8sResources(r.Context(), resourceTree, validRequests, k8sAppDetail, clusterIdString, []string{k8s.ServiceKind, k8s.EndpointsKind, k8s.IngressKind})
 	resp, err := handler.k8sCommonService.GetManifestsByBatch(r.Context(), validRequest)
-	newResourceTree, err := handler.PortNumberExtraction(resp, resourceTree, err)
-	return newResourceTree, nil
-}
-
-func (handler AppListingRestHandlerImpl) PortNumberExtraction(resp []k8s.BatchResourceResponse, resourceTree map[string]interface{}, err error) (map[string]interface{}, error) {
-	portsService := make([]int64, 0)
-	portsEndpoint := make([]int64, 0)
-	portEndpointSlice := make([]int64, 0)
-	for _, portHolder := range resp {
-		if portHolder.ManifestResponse == nil {
-			continue
-		}
-		kind, ok := portHolder.ManifestResponse.Manifest.Object["kind"]
-		if !ok {
-			handler.logger.Errorw("kind not found in resource tree, unable to extract port no")
-			return resourceTree, nil
-		}
-		if kind == k8s.ServiceKind {
-			specField, ok := portHolder.ManifestResponse.Manifest.Object["spec"]
-			if !ok {
-				handler.logger.Errorw("spec not found in resource tree, unable to extract port no")
-				return resourceTree, nil
-			}
-			spec := specField.(map[string]interface{})
-			if spec != nil {
-				ports, ok := spec["ports"]
-				if !ok {
-					handler.logger.Errorw("ports not found in resource tree, unable to extract port no")
-					return resourceTree, nil
-				}
-				portList := ports.([]interface{})
-				for _, portItem := range portList {
-					if portItem.(map[string]interface{}) != nil {
-						portNumbers := portItem.(map[string]interface{})["port"]
-						portNumber := portNumbers.(int64)
-						if portNumber != 0 {
-							portsService = append(portsService, portNumber)
-						}
-					}
-				}
-			} else {
-				handler.logger.Errorw("spec doest not contain data", "err", spec)
-			}
-		}
-		if kind == k8s.EndpointsKind {
-			subsetsField, ok := portHolder.ManifestResponse.Manifest.Object["subsets"]
-			if !ok {
-				handler.logger.Errorw("spec not found in resource tree, unable to extract port no")
-				return resourceTree, nil
-			}
-			if subsetsField != nil {
-				subsets := subsetsField.([]interface{})
-				for _, subset := range subsets {
-					subsetObj := subset.(map[string]interface{})
-					if subsetObj != nil {
-						ports, ok := subsetObj["ports"]
-						if !ok {
-							handler.logger.Errorw("ports not found in resource tree endpoints, unable to extract port no")
-							return resourceTree, nil
-						}
-						portsIfs := ports.([]interface{})
-						for _, portsIf := range portsIfs {
-							portsIfObj := portsIf.(map[string]interface{})
-							if portsIfObj != nil {
-								port := portsIfObj["port"].(int64)
-								portsEndpoint = append(portsEndpoint, port)
-							}
-						}
-					}
-				}
-			}
-		}
-		if kind == "EndpointSlice" {
-			portsField, ok := portHolder.ManifestResponse.Manifest.Object["ports"]
-			if !ok {
-				handler.logger.Errorw("ports not found in resource tree endpoint, unable to extract port no")
-				return resourceTree, nil
-			}
-			if portsField != nil {
-				endPointsSlicePorts := portsField.([]interface{})
-				for _, val := range endPointsSlicePorts {
-					portNumbers := val.(map[string]interface{})["port"]
-					portNumber := portNumbers.(int64)
-					if portNumber != 0 {
-						portEndpointSlice = append(portEndpointSlice, portNumber)
-					}
-				}
-			}
-		}
-	}
 	if err != nil {
-		handler.logger.Errorw("error in fetching manifest", "err", err)
+		handler.logger.Errorw("error in getting manifest by batch", "err", err, "clusterId", clusterIdString)
+		return nil, err
 	}
-	if val, ok := resourceTree["nodes"]; ok {
-		resourceTreeVal := val.([]interface{})
-		for _, val := range resourceTreeVal {
-			value := val.(map[string]interface{})
-			for key, _type := range value {
-				if key == "kind" && _type == k8s.EndpointsKind {
-					value["port"] = portsEndpoint
-				}
-				if key == "kind" && _type == k8s.ServiceKind {
-					value["port"] = portsService
-				}
-				if key == "kind" && _type == "EndpointSlice" {
-					value["port"] = portEndpointSlice
-				}
-			}
-		}
+	newResourceTree, err := handler.k8sCommonService.PortNumberExtraction(resp, resourceTree, err)
+	if err != nil {
+		handler.logger.Errorw("error in port number in new Resource Tree", "err", err, "clusterId", clusterIdString)
+		return nil, err
 	}
-	return resourceTree, nil
+	return newResourceTree, nil
 }
 
 func (handler AppListingRestHandlerImpl) ManualSyncAcdPipelineDeploymentStatus(w http.ResponseWriter, r *http.Request) {

pkg/appStore/deployment/service/InstalledAppService.go

@@ -1371,7 +1371,26 @@ func (impl InstalledAppServiceImpl) fetchResourceTreeForACD(rctx context.Context
 		}
 	}()
 	impl.logger.Debugf("application %s in environment %s had status %+v\n", appId, envId, resp)
-	return resourceTree, err
+	validRequests := make([]k8s.ResourceRequestBean, 0)
+	k8sAppDetail := bean2.AppDetailContainer{
+		DeploymentDetailContainer: bean2.DeploymentDetailContainer{
+			ClusterId: clusterId,
+			Namespace: namespace,
+		},
+	}
+	clusterIdString := strconv.Itoa(clusterId)
+	validRequest := impl.k8sCommonService.FilterK8sResources(rctx, resourceTree, validRequests, k8sAppDetail, clusterIdString, []string{k8s.ServiceKind, k8s.EndpointsKind, k8s.IngressKind})
+	response, err := impl.k8sCommonService.GetManifestsByBatch(rctx, validRequest)
+	if err != nil {
+		impl.logger.Errorw("error in getting manifest by batch", "err", err, "clusterId", clusterIdString)
+		return nil, err
+	}
+	newResourceTree, err := impl.k8sCommonService.PortNumberExtraction(response, resourceTree, err)
+	if err != nil {
+		impl.logger.Errorw("error in port number in new Resource Tree", "err", err, "clusterId", clusterIdString)
+		return nil, err
+	}
+	return newResourceTree, err
 }
 
 func (impl InstalledAppServiceImpl) filterOutReplicaNodes(responseTreeNodes interface{}) []interface{} {

pkg/k8s/K8sCommonService.go

@@ -35,6 +35,7 @@ type K8sCommonService interface {
 	RotatePods(ctx context.Context, request *RotatePodRequest) (*RotatePodResponse, error)
 	GetCoreClientByClusterId(clusterId int) (*kubernetes.Clientset, *v1.CoreV1Client, error)
 	GetK8sServerVersion(clusterId int) (*version.Info, error)
+	PortNumberExtraction(resp []BatchResourceResponse, resourceTree map[string]interface{}, err error) (map[string]interface{}, error)
 }
 type K8sCommonServiceImpl struct {
 	logger                      *zap.SugaredLogger
@@ -342,3 +343,112 @@ func (impl *K8sCommonServiceImpl) GetCoreClientByClusterId(clusterId int) (*kube
 	}
 	return clientSet, v1Client, nil
 }
+
+func (impl K8sCommonServiceImpl) PortNumberExtraction(resp []BatchResourceResponse, resourceTree map[string]interface{}, err error) (map[string]interface{}, error) {
+	portsService := make([]int64, 0)
+	portsEndpoint := make([]int64, 0)
+	portEndpointSlice := make([]int64, 0)
+	for _, portHolder := range resp {
+		if portHolder.ManifestResponse == nil {
+			continue
+		}
+		kind, ok := portHolder.ManifestResponse.Manifest.Object["kind"]
+		if !ok {
+			impl.logger.Errorw("kind not found in resource tree, unable to extract port no")
+			return resourceTree, nil
+		}
+		if kind == ServiceKind {
+			specField, ok := portHolder.ManifestResponse.Manifest.Object["spec"]
+			if !ok {
+				impl.logger.Errorw("spec not found in resource tree, unable to extract port no")
+				return resourceTree, nil
+			}
+			spec := specField.(map[string]interface{})
+			if spec != nil {
+				ports, ok := spec["ports"]
+				if !ok {
+					impl.logger.Errorw("ports not found in resource tree, unable to extract port no")
+					return resourceTree, nil
+				}
+				portList := ports.([]interface{})
+				for _, portItem := range portList {
+					if portItem.(map[string]interface{}) != nil {
+						portNumbers := portItem.(map[string]interface{})["port"]
+						portNumber := portNumbers.(int64)
+						if portNumber != 0 {
+							portsService = append(portsService, portNumber)
+						}
+					}
+				}
+			} else {
+				impl.logger.Errorw("spec doest not contain data", "err", spec)
+			}
+		}
+		if kind == EndpointsKind {
+			subsetsField, ok := portHolder.ManifestResponse.Manifest.Object["subsets"]
+			if !ok {
+				impl.logger.Errorw("spec not found in resource tree, unable to extract port no")
+				return resourceTree, nil
+			}
+			if subsetsField != nil {
+				subsets := subsetsField.([]interface{})
+				for _, subset := range subsets {
+					subsetObj := subset.(map[string]interface{})
+					if subsetObj != nil {
+						ports, ok := subsetObj["ports"]
+						if !ok {
+							impl.logger.Errorw("ports not found in resource tree endpoints, unable to extract port no")
+							return resourceTree, nil
+						}
+						portsIfs := ports.([]interface{})
+						for _, portsIf := range portsIfs {
+							portsIfObj := portsIf.(map[string]interface{})
+							if portsIfObj != nil {
+								port := portsIfObj["port"].(int64)
+								portsEndpoint = append(portsEndpoint, port)
+							}
+						}
+					}
+				}
+			}
+		}
+		if kind == "EndpointSlice" {
+			portsField, ok := portHolder.ManifestResponse.Manifest.Object["ports"]
+			if !ok {
+				impl.logger.Errorw("ports not found in resource tree endpoint, unable to extract port no")
+				return resourceTree, nil
+			}
+			if portsField != nil {
+				endPointsSlicePorts := portsField.([]interface{})
+				for _, val := range endPointsSlicePorts {
+					portNumbers := val.(map[string]interface{})["port"]
+					portNumber := portNumbers.(int64)
+					if portNumber != 0 {
+						portEndpointSlice = append(portEndpointSlice, portNumber)
+					}
+				}
+			}
+		}
+	}
+	if err != nil {
+		impl.logger.Errorw("error in fetching manifest", "err", err)
+	}
+	if val, ok := resourceTree["nodes"]; ok {
+		resourceTreeVal := val.([]interface{})
+		for _, val := range resourceTreeVal {
+			value := val.(map[string]interface{})
+			for key, _type := range value {
+				if key == "kind" && _type == EndpointsKind {
+					value["port"] = portsEndpoint
+				}
+				if key == "kind" && _type == ServiceKind {
+					value["port"] = portsService
+				}
+				if key == "kind" && _type == EndPointsSlice {
+					value["port"] = portEndpointSlice
+				}
+			}
+		}
+	}
+	return resourceTree, nil
+}

pkg/k8s/bean.go

@@ -11,6 +11,7 @@ const (
 	ServiceKind                  = "Service"
 	ServiceAccountKind           = "ServiceAccount"
 	EndpointsKind                = "Endpoints"
+	EndPointsSlice               = "EndpointSlice"
 	DeploymentKind               = "Deployment"
 	ReplicaSetKind               = "ReplicaSet"
 	StatefulSetKind              = "StatefulSet"