feat: use live state for application version

event_reporter/application/client.go

@@ -123,6 +123,9 @@ func (c *httpApplicationClient) GetManifests(ctx context.Context, in *appclient.
 	params := fmt.Sprintf("?appNamespace=%s&project=%s",
 		*in.AppNamespace,
 		*in.Project)
+	if in.Revision != nil {
+		params = fmt.Sprintf("%s&revision=%s", params, *in.Revision)
+	}
 	url := fmt.Sprintf("%s/api/v1/applications/%s/manifests%s", c.baseUrl, *in.Name, params)
 
 	manifest := &repoapiclient.ManifestResponse{}

event_reporter/reporter/application_event_reporter.go

@@ -87,13 +87,12 @@ func (s *applicationEventReporter) shouldSendResourceEvent(a *appv1.Application,
 	return true
 }
 
-func (r *applicationEventReporter) getDesiredManifests(ctx context.Context, a *appv1.Application, logCtx *log.Entry) (*apiclient.ManifestResponse, error, bool) {
+func (r *applicationEventReporter) getDesiredManifests(ctx context.Context, a *appv1.Application, logCtx *log.Entry) (*apiclient.ManifestResponse, bool) {
 	// get the desired state manifests of the application
 	project := a.Spec.GetProject()
 	desiredManifests, err := r.applicationServiceClient.GetManifests(ctx, &application.ApplicationManifestQuery{
 		Name:         &a.Name,
 		AppNamespace: &a.Namespace,
-		Revision:     &a.Status.Sync.Revision,
 		Project:      &project,
 	})
 	if err != nil {
@@ -102,9 +101,26 @@ func (r *applicationEventReporter) getDesiredManifests(ctx context.Context, a *a
 		// each resource with empty desired state
 		logCtx.WithError(err).Warn("failed to get application desired state manifests, reporting actual state only")
 		desiredManifests = &apiclient.ManifestResponse{Manifests: []*apiclient.Manifest{}}
-		return desiredManifests, nil, true // will ignore requiresPruning=true to not delete resources with actual state
+		return desiredManifests, true // will ignore requiresPruning=true to not delete resources with actual state
 	}
-	return desiredManifests, nil, false
+	return desiredManifests, false
+}
+
+func (r *applicationEventReporter) getLiveManifests(ctx context.Context, a *appv1.Application, logCtx *log.Entry) *apiclient.ManifestResponse {
+	// get the live state manifests of the application
+	project := a.Spec.GetProject()
+	liveManifests, err := r.applicationServiceClient.GetManifests(ctx, &application.ApplicationManifestQuery{
+		Name:         &a.Name,
+		AppNamespace: &a.Namespace,
+		Revision:     &a.Status.Sync.Revision,
+		Project:      &project,
+	})
+	if err != nil {
+		// if it's manifest generation error we need to return empty result
+		logCtx.WithError(err).Warn("failed to get application desired state manifests, reporting actual state only")
+		liveManifests = &apiclient.ManifestResponse{Manifests: []*apiclient.Manifest{}}
+	}
+	return liveManifests
 }
 
 func (s *applicationEventReporter) StreamApplicationEvents(
@@ -132,15 +148,18 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 		}
 
 		// we still need process app even without tree, it is in case of app yaml originally contain error,
-		// we still want to show it the erorrs that related to it on codefresh ui
+		// we still want to show it the errors that related to it on codefresh ui
 		logCtx.WithError(err).Warn("failed to get application tree, resuming")
 	}
 
 	logCtx.Info("getting desired manifests")
 
-	desiredManifests, err, manifestGenErr := s.getDesiredManifests(ctx, a, logCtx)
-	if err != nil {
-		return err
+	desiredManifests, manifestGenErr := s.getDesiredManifests(ctx, a, logCtx)
+
+	var applicationVersions *apiclient.ApplicationVersions = nil
+	liveManifests := s.getLiveManifests(ctx, a, logCtx)
+	if liveManifests.ApplicationVersions != nil {
+		applicationVersions = liveManifests.ApplicationVersions
 	}
 
 	logCtx.Info("getting parent application name")
@@ -159,10 +178,7 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 
 		rs := utils.GetAppAsResource(a)
 
-		parentDesiredManifests, err, manifestGenErr := s.getDesiredManifests(ctx, parentApplicationEntity, logCtx)
-		if err != nil {
-			logCtx.WithError(err).Warn("failed to get parent application's desired manifests, resuming")
-		}
+		parentDesiredManifests, manifestGenErr := s.getDesiredManifests(ctx, parentApplicationEntity, logCtx)
 
 		// helm app hasnt revision
 		// TODO: add check if it helm application
@@ -172,7 +188,7 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 		}
 
 		utils.SetHealthStatusIfMissing(rs)
-		err = s.processResource(ctx, *rs, parentApplicationEntity, logCtx, ts, parentDesiredManifests, appTree, manifestGenErr, a, parentAppSyncRevisionsMetadata, appInstanceLabelKey, trackingMethod, desiredManifests.ApplicationVersions)
+		err = s.processResource(ctx, *rs, parentApplicationEntity, logCtx, ts, parentDesiredManifests, appTree, manifestGenErr, a, parentAppSyncRevisionsMetadata, appInstanceLabelKey, trackingMethod, applicationVersions)
 		if err != nil {
 			s.metricsServer.IncErroredEventsCounter(metrics.MetricChildAppEventType, metrics.MetricEventUnknownErrorType, a.Name)
 			return err
@@ -182,7 +198,7 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 	} else {
 		logCtx.Info("processing as root application")
 		// will get here only for root applications (not managed as a resource by another application)
-		appEvent, err := s.getApplicationEventPayload(ctx, a, appTree, ts, appInstanceLabelKey, trackingMethod, desiredManifests.ApplicationVersions)
+		appEvent, err := s.getApplicationEventPayload(ctx, a, appTree, ts, appInstanceLabelKey, trackingMethod, applicationVersions)
 		if err != nil {
 			s.metricsServer.IncErroredEventsCounter(metrics.MetricParentAppEventType, metrics.MetricEventGetPayloadErrorType, a.Name)
 			return fmt.Errorf("failed to get application event: %w", err)

reposerver/repository/app_version.go

@@ -61,8 +61,16 @@ func getVersionFromFile(appPath, jsonPathExpression string) (*string, error) {
 	if err != nil {
 		return nil, err
 	}
-	appVersion, ok := versionValue.(string)
-	if !ok {
+
+	var appVersion string
+	var conversionSuccess bool
+	if versionArray, ok := versionValue.([]interface{}); ok && len(versionArray) > 0 {
+		appVersion, conversionSuccess = versionArray[0].(string)
+	} else {
+		appVersion, conversionSuccess = versionValue.(string)
+	}
+
+	if !conversionSuccess {
 		if versionValue == nil {
 			log.Info("Version value is not a string. Got: nil")
 		} else {