chore: sync all codefresh code changes into v3.0.2 without event-reporter related changes

Signed-off-by: oleksandr-codefresh <oleksandr.saulyak@octopus.com>

Author: oleksandr-codefresh

Makefile

@@ -542,6 +542,9 @@ start-local: mod-vendor-local dep-ui-local cli-local
 run:
 	bash ./hack/goreman-start.sh
 
+.PHONY: cf-release
+cf-release:
+	go run ./hack/release
 
 # Runs pre-commit validation with the virtualized toolchain
 .PHONY: pre-commit

acr_controller/application/client.go

@@ -23,6 +23,7 @@ type httpApplicationClient struct {
 	httpClient *http.Client
 	baseURL    string
 	token      string
+	rootpath   string
 }
 
 func NewHTTPApplicationClient(token string, address string, rootpath string) ApplicationClient {
@@ -46,13 +47,14 @@ func NewHTTPApplicationClient(token string, address string, rootpath string) App
 				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
 			},
 		},
-		baseURL: address,
-		token:   token,
+		baseURL:  address,
+		token:    token,
+		rootpath: rootpath,
 	}
 }
 
 func (c *httpApplicationClient) execute(ctx context.Context, url string, result any) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, http.NoBody)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return err
 	}

acr_controller/controller/controller.go

@@ -13,6 +13,8 @@ import (
 	appclientset "github.com/argoproj/argo-cd/v3/pkg/client/clientset/versioned"
 
 	appv1 "github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
+	applisters "github.com/argoproj/argo-cd/v3/pkg/client/listers/application/v1alpha1"
+	servercache "github.com/argoproj/argo-cd/v3/server/cache"
 )
 
 var watchAPIBufferSize = 1000
@@ -22,21 +24,27 @@ type ACRController interface {
 }
 
 type applicationChangeRevisionController struct {
-	appBroadcaster Broadcaster
-	acrService     service.ACRService
-	useAnnotations bool
+	appBroadcaster           Broadcaster
+	cache                    *servercache.Cache
+	appLister                applisters.ApplicationLister
+	applicationServiceClient appclient.ApplicationClient
+	acrService               service.ACRService
+	applicationClientset     appclientset.Interface
 }
 
-func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInformer, applicationServiceClient appclient.ApplicationClient, applicationClientset appclientset.Interface, useAnnotations bool) ACRController {
+func NewApplicationChangeRevisionController(appInformer cache.SharedIndexInformer, cache *servercache.Cache, applicationServiceClient appclient.ApplicationClient, appLister applisters.ApplicationLister, applicationClientset appclientset.Interface) ACRController {
 	appBroadcaster := NewBroadcaster()
 	_, err := appInformer.AddEventHandler(appBroadcaster)
 	if err != nil {
 		log.Error(err)
 	}
 	return &applicationChangeRevisionController{
-		appBroadcaster: appBroadcaster,
-		acrService:     service.NewACRService(applicationClientset, applicationServiceClient),
-		useAnnotations: useAnnotations,
+		appBroadcaster:           appBroadcaster,
+		cache:                    cache,
+		applicationServiceClient: applicationServiceClient,
+		appLister:                appLister,
+		applicationClientset:     applicationClientset,
+		acrService:               service.NewACRService(applicationClientset, applicationServiceClient),
 	}
 }
 
@@ -48,7 +56,7 @@ func (c *applicationChangeRevisionController) Run(ctx context.Context) {
 			return nil // ignore this event
 		}
 
-		return c.acrService.ChangeRevision(ctx, &a, c.useAnnotations)
+		return c.acrService.ChangeRevision(ctx, &a)
 	}
 
 	// TODO: move to abstraction

acr_controller/server.go

@@ -2,11 +2,14 @@ package acr_controller
 
 import (
 	"context"
+	"crypto/tls"
 	"fmt"
 	"net"
 	"net/http"
 	"time"
 
+	applisters "github.com/argoproj/argo-cd/v3/pkg/client/listers/application/v1alpha1"
+	settings_util "github.com/argoproj/argo-cd/v3/util/settings"
 	"github.com/redis/go-redis/v9"
 	log "github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -33,11 +36,15 @@ var backoff = wait.Backoff{
 type ACRServer struct {
 	ACRServerOpts
 
+	settings             *settings_util.ArgoCDSettings
+	log                  *log.Entry
 	appInformer          cache.SharedIndexInformer
+	appLister            applisters.ApplicationLister
 	applicationClientset appclientset.Interface
 
 	// stopCh is the channel which when closed, will shutdown the Event Reporter server
-	stopCh chan struct{}
+	stopCh     chan struct{}
+	serviceSet *ACRServerSet
 }
 
 type ACRServerSet struct{}
@@ -97,7 +104,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, !a.DisableAnnotations)
+	controller := acr_controller.NewApplicationChangeRevisionController(a.appInformer, a.Cache, a.ApplicationServiceClient, a.appLister, a.applicationClientset)
 	go controller.Run(ctx)
 }
 
@@ -156,6 +163,10 @@ func (a *ACRServer) Listen() (*Listeners, error) {
 // golang/protobuf).
 func (a *ACRServer) Run(ctx context.Context, lns *Listeners) {
 	httpS := a.newHTTPServer(ctx, a.ListenPort)
+	tlsConfig := tls.Config{}
+	tlsConfig.GetCertificate = func(_ *tls.ClientHelloInfo) (*tls.Certificate, error) {
+		return a.settings.Certificate, nil
+	}
 	go func() { a.checkServeErr("httpS", httpS.Serve(lns.Main)) }()
 	go a.RunController(ctx)
 
@@ -176,10 +187,13 @@ func NewApplicationChangeRevisionServer(_ context.Context, opts ACRServerOpts) *
 	appFactory := appinformer.NewSharedInformerFactoryWithOptions(opts.AppClientset, 0, appinformer.WithNamespace(appInformerNs), appinformer.WithTweakListOptions(func(_ *metav1.ListOptions) {}))
 
 	appInformer := appFactory.Argoproj().V1alpha1().Applications().Informer()
+	appLister := appFactory.Argoproj().V1alpha1().Applications().Lister()
 
 	server := &ACRServer{
 		ACRServerOpts:        opts,
+		log:                  log.NewEntry(log.StandardLogger()),
 		appInformer:          appInformer,
+		appLister:            appLister,
 		applicationClientset: opts.AppClientset,
 	}
 

acr_controller/service/acr_service.go

@@ -3,7 +3,6 @@ package service
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"sync"
 
 	log "github.com/sirupsen/logrus"
@@ -25,7 +24,7 @@ const (
 )
 
 type ACRService interface {
-	ChangeRevision(ctx context.Context, application *application.Application, useAnnotations bool) error
+	ChangeRevision(ctx context.Context, application *application.Application) error
 }
 
 type acrService struct {
@@ -63,7 +62,7 @@ func getChangeRevision(app *application.Application) string {
 	return ""
 }
 
-func (c *acrService) ChangeRevision(ctx context.Context, a *application.Application, useAnnotations bool) error {
+func (c *acrService) ChangeRevision(ctx context.Context, a *application.Application) error {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
@@ -81,108 +80,36 @@ func (c *acrService) ChangeRevision(ctx context.Context, a *application.Applicat
 		return nil
 	}
 
-	currentRevision, previousRevision := c.getRevisions(ctx, a)
-	if currentRevision == "" {
-		c.logger.Infof("Got empty current revision for application %s, is it an unsupported multisource or helm repo based application?", app.Name)
-		return nil
-	}
-	revision, err := c.calculateRevision(ctx, app, currentRevision, previousRevision)
+	revision, err := c.calculateRevision(ctx, app)
 	if err != nil {
 		return err
 	}
 
-	var revisions []string
 	if revision == nil || *revision == "" {
 		c.logger.Infof("Revision for application %s is empty", app.Name)
-	} else {
-		c.logger.Infof("Change revision for application %s is %s", app.Name, *revision)
-		revisions = []string{*revision}
+		return nil
 	}
 
+	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
 	}
 
-	patchMap := make(map[string]any, 2)
-
-	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(revisions)
-		} else {
-			c.logger.Infof("Patch operation for application %s", app.Name)
-			patchMap = c.patchOperationWithChangeRevision(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
-	}
-	c.logger.Infof("No patch needed")
-	return nil
-}
-
-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) 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
+	revisions := []string{*revision}
 
-	if changeRevision != "" {
-		addPatchIfNeeded(annotations, currentAnnotations, CHANGE_REVISION_ANN, changeRevision)
-	}
-	if len(changeRevisions) > 0 {
-		changeRevisionsJSON, err := json.Marshal(changeRevisions)
-		if err != nil {
-			return fmt.Errorf("failed to marshall changeRevisions %v: %w", changeRevisions, err)
-		}
-		addPatchIfNeeded(annotations, currentAnnotations, CHANGE_REVISIONS_ANN, string(changeRevisionsJSON))
-	}
-	if gitRevision != "" {
-		addPatchIfNeeded(annotations, currentAnnotations, GIT_REVISION_ANN, gitRevision)
-	}
-	if len(gitRevisions) > 0 {
-		gitRevisionsJSON, err := json.Marshal(gitRevisions)
-		if err != nil {
-			return fmt.Errorf("failed to marshall gitRevisions %v: %w", gitRevisions, err)
-		}
-		addPatchIfNeeded(annotations, currentAnnotations, GIT_REVISIONS_ANN, string(gitRevisionsJSON))
+	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(annotations) == 0 {
-		c.logger.Info("no need to add annotations")
-	} else {
-		c.logger.Infof("added annotations to application %s patch: %v", a.Name, annotations)
-		m["metadata"] = map[string]any{"annotations": annotations}
-	}
-	return nil
+	c.logger.Infof("Patch operation for application %s", app.Name)
+	return c.patchOperationWithChangeRevision(ctx, app, revisions)
 }
 
-func (c *acrService) calculateRevision(ctx context.Context, a *application.Application, currentRevision string, previousRevision string) (*string, error) {
+func (c *acrService) calculateRevision(ctx context.Context, a *application.Application) (*string, error) {
+	currentRevision, previousRevision := c.getRevisions(ctx, a)
 	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()),
@@ -196,28 +123,33 @@ func (c *acrService) calculateRevision(ctx context.Context, a *application.Appli
 	return changeRevisionResult.Revision, nil
 }
 
-func (c *acrService) patchOperationWithChangeRevision(revisions []string) map[string]any {
+func (c *acrService) patchOperationWithChangeRevision(ctx context.Context, a *application.Application, revisions []string) error {
 	if len(revisions) == 1 {
-		return map[string]any{
+		patch, _ := json.Marshal(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
 	}
-	return map[string]any{
+
+	patch, _ := json.Marshal(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(revisions []string) map[string]any {
+func (c *acrService) patchOperationSyncResultWithChangeRevision(ctx context.Context, a *application.Application, revisions []string) error {
 	if len(revisions) == 1 {
-		return map[string]any{
+		patch, _ := json.Marshal(map[string]any{
 			"status": map[string]any{
 				"operationState": map[string]any{
 					"operation": map[string]any{
@@ -227,9 +159,12 @@ func (c *acrService) patchOperationSyncResultWithChangeRevision(revisions []stri
 					},
 				},
 			},
-		}
+		})
+		_, err := c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
+		return err
 	}
-	return map[string]any{
+
+	patch, _ := json.Marshal(map[string]any{
 		"status": map[string]any{
 			"operationState": map[string]any{
 				"operation": map[string]any{
@@ -239,7 +174,9 @@ func (c *acrService) patchOperationSyncResultWithChangeRevision(revisions []stri
 				},
 			},
 		},
-	}
+	})
+	_, err := c.applicationClientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(ctx, a.Name, types.MergePatchType, patch, metav1.PatchOptions{})
+	return err
 }
 
 func getCurrentRevisionFromOperation(a *application.Application) string {