feat: support for monorepo-controller compatible annotations

dudinea · dudinea · commit db1b6f60f88e · 2025-09-25T16:58:45.000+03:00
Signed-off-by: Eugene Doudine &lt;eugene.doudine@octopus.com&gt;
diff --git a/acr_controller/controller/controller.go b/acr_controller/controller/controller.go
@@ -24,9 +24,10 @@ type ACRController interface {
 type applicationChangeRevisionController struct {
 	appBroadcaster Broadcaster
 	acrService     service.ACRService
+	useAnnotations bool
 }
 
-func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInformer, applicationServiceClient appclient.ApplicationClient, applicationClientset appclientset.Interface) ACRController {
+func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInformer, applicationServiceClient appclient.ApplicationClient, applicationClientset appclientset.Interface, useAnnotations bool) ACRController {
 	appBroadcaster := NewBroadcaster()
 	_, err := appInformer.AddEventHandler(appBroadcaster)
 	if err != nil {
@@ -35,6 +36,7 @@ func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInforme
 	return &applicationChangeRevisionController{
 		appBroadcaster: appBroadcaster,
 		acrService:     service.NewACRService(applicationClientset, applicationServiceClient),
+		useAnnotations: useAnnotations,
 	}
 }
 
@@ -46,7 +48,7 @@ func (c *applicationChangeRevisionController) Run(ctx context.Context) {
 			return nil // ignore this event
 		}
 
-		return c.acrService.ChangeRevision(ctx, &a)
+		return c.acrService.ChangeRevision(ctx, &a, c.useAnnotations)
 	}
 
 	// TODO: move to abstraction
diff --git a/acr_controller/server.go b/acr_controller/server.go
@@ -54,6 +54,7 @@ type ACRServerOpts struct {
 	ApplicationNamespaces    []string
 	BaseHRef                 string
 	RootPath                 string
+	DisableAnnotations       bool
 }
 
 type handlerSwitcher struct {
@@ -96,7 +97,7 @@ func (a *ACRServer) Init(ctx context.Context) {
 }
 
 func (a *ACRServer) RunController(ctx context.Context) {
-	controller := acr_controller.NewApplicationChangeRevisionController(a.appInformer, a.ApplicationServiceClient, a.applicationClientset)
+	controller := acr_controller.NewApplicationChangeRevisionController(a.appInformer, a.ApplicationServiceClient, a.applicationClientset, !a.DisableAnnotations)
 	go controller.Run(ctx)
 }
 
diff --git a/acr_controller/service/acr_service.go b/acr_controller/service/acr_service.go
@@ -3,6 +3,7 @@ package service
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"sync"
 
 	log "github.com/sirupsen/logrus"
@@ -16,8 +17,15 @@ import (
 	appclientset "github.com/argoproj/argo-cd/v3/pkg/client/clientset/versioned"
 )
 
+const (
+	CHANGE_REVISION_ANN  = "mrp-controller.argoproj.io/change-revision"
+	CHANGE_REVISIONS_ANN = "mrp-controller.argoproj.io/change-revisions"
+	GIT_REVISION_ANN     = "mrp-controller.argoproj.io/git-revision"
+	GIT_REVISIONS_ANN    = "mrp-controller.argoproj.io/git-revisions"
+)
+
 type ACRService interface {
-	ChangeRevision(ctx context.Context, application *application.Application) error
+	ChangeRevision(ctx context.Context, application *application.Application, useAnnotations bool) error
 }
 
 type acrService struct {
@@ -55,7 +63,7 @@ func getChangeRevision(app *application.Application) string {
 	return ""
 }
 
-func (c *acrService) ChangeRevision(ctx context.Context, a *application.Application) error {
+func (c *acrService) ChangeRevision(ctx context.Context, a *application.Application, useAnnotations bool) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
@@ -73,36 +81,96 @@ func (c *acrService) ChangeRevision(ctx context.Context, a *application.Applicat
 		return nil
 	}
 
-	revision, err := c.calculateRevision(ctx, app)
+	currentRevision, previousRevision := c.getRevisions(ctx, a)
+	revision, err := c.calculateRevision(ctx, app, currentRevision, previousRevision)
 	if err != nil {
 		return err
 	}
 
+	var revisions []string
 	if revision == nil || *revision == "" {
 		c.logger.Infof("Revision for application %s is empty", app.Name)
-		return nil
+	} else {
+		c.logger.Infof("Change revision for application %s is %s", app.Name, *revision)
+		revisions = []string{*revision}
 	}
 
-	c.logger.Infof("Change revision for application %s is %s", app.Name, *revision)
-
 	app, err = c.applicationClientset.ArgoprojV1alpha1().Applications(app.Namespace).Get(ctx, app.Name, metav1.GetOptions{})
 	if err != nil {
 		return err
 	}
 
-	revisions := []string{*revision}
+	patchMap := make(map[string]any, 2)
 
-	if app.Status.OperationState != nil && app.Status.OperationState.Operation.Sync != nil {
-		c.logger.Infof("Patch operation status for application %s", app.Name)
-		return c.patchOperationSyncResultWithChangeRevision(ctx, app, revisions)
+	if len(revisions) > 0 {
+		if app.Status.OperationState != nil && app.Status.OperationState.Operation.Sync != nil {
+			c.logger.Infof("Patch operation status for application %s", app.Name)
+			patchMap = c.patchOperationSyncResultWithChangeRevision(ctx, app, revisions)
+		} else {
+			c.logger.Infof("Patch operation for application %s", app.Name)
+			patchMap = c.patchOperationWithChangeRevision(ctx, app, revisions)
+		}
+	}
+	if useAnnotations {
+		err = c.addAnnotationPatch(patchMap, app, *revision, revisions, currentRevision, []string{currentRevision})
+		if err != nil {
+			return err
+		}
 	}
+	if len(patchMap) > 0 {
+		c.logger.Infof("patching resource: %v", patchMap)
+		patch, err := json.Marshal(patchMap)
+		if err != nil {
+			return err
+		}
+		_, err = c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
+		return err
+	} else {
+		c.logger.Infof("no patch needed")
+		return nil
+	}
+}
 
-	c.logger.Infof("Patch operation for application %s", app.Name)
-	return c.patchOperationWithChangeRevision(ctx, app, revisions)
+func addPatchIfNeeded(annotations map[string]string, currentAnnotations map[string]string, key string, val string) {
+	currentVal, ok := currentAnnotations[key]
+	if !ok || currentVal != val {
+		annotations[key] = val
+	}
 }
 
-func (c *acrService) calculateRevision(ctx context.Context, a *application.Application) (*string, error) {
-	currentRevision, previousRevision := c.getRevisions(ctx, a)
+func (c *acrService) addAnnotationPatch(m map[string]any,
+	a *application.Application,
+	changeRevision string,
+	changeRevisions []string,
+	gitRevision string,
+	gitRevisions []string) error {
+	c.logger.Infof("annotating application '%s', changeRevision=%s, changeRevisions=%v, gitRevision=%s, gitRevisions=%v", a.Name, changeRevision, changeRevisions, gitRevision, gitRevisions)
+	annotations := map[string]string{}
+	currentAnnotations := a.Annotations
+
+	changeRevisionsJson, err := json.Marshal(changeRevisions)
+	if err != nil {
+		return fmt.Errorf("Failed to marshall changeRevisions %v: %v", changeRevisions, err)
+	}
+	gitRevisionsJson, err := json.Marshal(gitRevisions)
+	if err != nil {
+		return fmt.Errorf("Failed to marshall gitRevisions %v: %v", gitRevisions, err)
+	}
+
+	addPatchIfNeeded(annotations, currentAnnotations, CHANGE_REVISION_ANN, changeRevision)
+	addPatchIfNeeded(annotations, currentAnnotations, CHANGE_REVISIONS_ANN, string(changeRevisionsJson))
+	addPatchIfNeeded(annotations, currentAnnotations, GIT_REVISION_ANN, gitRevision)
+	addPatchIfNeeded(annotations, currentAnnotations, GIT_REVISIONS_ANN, string(gitRevisionsJson))
+
+	if len(annotations) == 0 {
+		c.logger.Info("no need to add annotations")
+	}
+	c.logger.Infof("added annotations to application %s patch: %v", a.Name, annotations)
+	m["metadata"] = map[string]any{"annotations": annotations}
+	return nil
+}
+
+func (c *acrService) calculateRevision(ctx context.Context, a *application.Application, currentRevision string, previousRevision string) (*string, error) {
 	c.logger.Infof("Calculate revision for application '%s', current revision '%s', previous revision '%s'", a.Name, currentRevision, previousRevision)
 	changeRevisionResult, err := c.applicationServiceClient.GetChangeRevision(ctx, &appclient.ChangeRevisionRequest{
 		AppName:          ptr.To(a.GetName()),
@@ -116,33 +184,28 @@ func (c *acrService) calculateRevision(ctx context.Context, a *application.Appli
 	return changeRevisionResult.Revision, nil
 }
 
-func (c *acrService) patchOperationWithChangeRevision(ctx context.Context, a *application.Application, revisions []string) error {
+func (c *acrService) patchOperationWithChangeRevision(ctx context.Context, a *application.Application, revisions []string) map[string]any {
 	if len(revisions) == 1 {
-		patch, _ := json.Marshal(map[string]any{
+		return map[string]any{
 			"operation": map[string]any{
 				"sync": map[string]any{
 					"changeRevision": revisions[0],
 				},
 			},
-		})
-		_, err := c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
-		return err
+		}
 	}
-
-	patch, _ := json.Marshal(map[string]any{
+	return map[string]any{
 		"operation": map[string]any{
 			"sync": map[string]any{
 				"changeRevisions": revisions,
 			},
 		},
-	})
-	_, err := c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
-	return err
+	}
 }
 
-func (c *acrService) patchOperationSyncResultWithChangeRevision(ctx context.Context, a *application.Application, revisions []string) error {
+func (c *acrService) patchOperationSyncResultWithChangeRevision(ctx context.Context, a *application.Application, revisions []string) map[string]any {
 	if len(revisions) == 1 {
-		patch, _ := json.Marshal(map[string]any{
+		return map[string]any{
 			"status": map[string]any{
 				"operationState": map[string]any{
 					"operation": map[string]any{
@@ -152,12 +215,9 @@ func (c *acrService) patchOperationSyncResultWithChangeRevision(ctx context.Cont
 					},
 				},
 			},
-		})
-		_, err := c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
-		return err
+		}
 	}
-
-	patch, _ := json.Marshal(map[string]any{
+	return map[string]any{
 		"status": map[string]any{
 			"operationState": map[string]any{
 				"operation": map[string]any{
@@ -167,9 +227,7 @@ func (c *acrService) patchOperationSyncResultWithChangeRevision(ctx context.Cont
 				},
 			},
 		},
-	})
-	_, err := c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
-	return err
+	}
 }
 
 func getCurrentRevisionFromOperation(a *application.Application) string {
diff --git a/acr_controller/service/acr_service_test.go b/acr_controller/service/acr_service_test.go
@@ -274,7 +274,7 @@ func Test_ChangeRevision(r *testing.T) {
 		acrService := newTestACRService(client)
 		app := createTestApp(syncedAppWithHistory)
 
-		err := acrService.ChangeRevision(r.Context(), app)
+		err := acrService.ChangeRevision(r.Context(), app, false)
 		require.NoError(t, err)
 
 		app, err = acrService.applicationClientset.ArgoprojV1alpha1().Applications(app.Namespace).Get(r.Context(), app.Name, metav1.GetOptions{})
@@ -296,15 +296,15 @@ func Test_ChangeRevision(r *testing.T) {
 
 		app := createTestApp(syncedAppWithHistory)
 
-		err := acrService.ChangeRevision(r.Context(), app)
+		err := acrService.ChangeRevision(r.Context(), app, false)
 		require.NoError(t, err)
 
 		app, err = acrService.applicationClientset.ArgoprojV1alpha1().Applications(app.Namespace).Get(r.Context(), app.Name, metav1.GetOptions{})
 		require.NoError(t, err)
 
 		assert.Equal(t, "new-revision", app.Status.OperationState.Operation.Sync.ChangeRevision)
 
-		err = acrService.ChangeRevision(r.Context(), app)
+		err = acrService.ChangeRevision(r.Context(), app, false)
 
 		require.NoError(t, err)
 
diff --git a/cmd/application-change-revision-controller/commands/application_change_revision_controller.go b/cmd/application-change-revision-controller/commands/application_change_revision_controller.go
@@ -61,6 +61,7 @@ func NewCommand() *cobra.Command {
 		applicationNamespaces    []string
 		argocdToken              string
 		rootpath                 string
+		disableAnnotations       bool
 	)
 	command := &cobra.Command{
 		Use:               cliName,
@@ -114,6 +115,7 @@ func NewCommand() *cobra.Command {
 				RedisClient:              redisClient,
 				ApplicationNamespaces:    applicationNamespaces,
 				ApplicationServiceClient: getApplicationClient(applicationServerAddress, argocdToken, rootpath),
+				DisableAnnotations:       disableAnnotations,
 			}
 
 			log.Info("Starting change revision controller server")
@@ -145,6 +147,7 @@ func NewCommand() *cobra.Command {
 	command.Flags().IntVar(&listenPort, "port", common.DefaultPortACRServer, "Listen on given port")
 	command.Flags().StringVar(&contentSecurityPolicy, "content-security-policy", env.StringFromEnv("ACR_CONTROLLER_CONTENT_SECURITY_POLICY", "frame-ancestors 'self';"), "Set Content-Security-Policy header in HTTP responses to `value`. To disable, set to \"\".")
 	command.Flags().StringSliceVar(&applicationNamespaces, "application-namespaces", env.StringsFromEnv("ARGOCD_APPLICATION_NAMESPACES", []string{}, ","), "List of additional namespaces where application resources can be managed in")
+	command.Flags().BoolVar(&disableAnnotations, "disable-annotations", env.ParseBoolFromEnv("ACR_CONTROLLER_DISABLE_AMMOTATIONS", false), "Disable generating the monorepo-controller compatible annotations")
 	cacheSrc = servercache.AddCacheFlagsToCmd(command, cacheutil.Options{
 		OnClientCreated: func(client *redis.Client) {
 			redisClient = client

Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,10 @@ type ACRController interface {`
`24`	`24`	`type applicationChangeRevisionController struct {`
`25`	`25`	`appBroadcaster Broadcaster`
`26`	`26`	`acrService service.ACRService`
	`27`	`+ useAnnotations bool`
`27`	`28`	`}`
`28`	`29`
`29`		`-func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInformer, applicationServiceClient appclient.ApplicationClient, applicationClientset appclientset.Interface) ACRController {`
	`30`	`+func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInformer, applicationServiceClient appclient.ApplicationClient, applicationClientset appclientset.Interface, useAnnotations bool) ACRController {`
`30`	`31`	`appBroadcaster := NewBroadcaster()`
`31`	`32`	`_, err := appInformer.AddEventHandler(appBroadcaster)`
`32`	`33`	`if err != nil {`
`@@ -35,6 +36,7 @@ func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInforme`
`35`	`36`	`return &applicationChangeRevisionController{`
`36`	`37`	`appBroadcaster: appBroadcaster,`
`37`	`38`	`acrService: service.NewACRService(applicationClientset, applicationServiceClient),`
	`39`	`+ useAnnotations: useAnnotations,`
`38`	`40`	`}`
`39`	`41`	`}`
`40`	`42`
`@@ -46,7 +48,7 @@ func (c *applicationChangeRevisionController) Run(ctx context.Context) {`
`46`	`48`	`return nil // ignore this event`
`47`	`49`	`}`
`48`	`50`
`49`		`- return c.acrService.ChangeRevision(ctx, &a)`
	`51`	`+ return c.acrService.ChangeRevision(ctx, &a, c.useAnnotations)`
`50`	`52`	`}`
`51`	`53`
`52`	`54`	`// TODO: move to abstraction`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,7 @@ type ACRServerOpts struct {`
`54`	`54`	`ApplicationNamespaces []string`
`55`	`55`	`BaseHRef string`
`56`	`56`	`RootPath string`
	`57`	`+ DisableAnnotations bool`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`type handlerSwitcher struct {`
`@@ -96,7 +97,7 @@ func (a *ACRServer) Init(ctx context.Context) {`
`96`	`97`	`}`
`97`	`98`
`98`	`99`	`func (a *ACRServer) RunController(ctx context.Context) {`
`99`		`- controller := acr_controller.NewApplicationChangeRevisionController(a.appInformer, a.ApplicationServiceClient, a.applicationClientset)`
	`100`	`+ controller := acr_controller.NewApplicationChangeRevisionController(a.appInformer, a.ApplicationServiceClient, a.applicationClientset, !a.DisableAnnotations)`
`100`	`101`	`go controller.Run(ctx)`
`101`	`102`	`}`
`102`	`103`