feat: Flux added functionaities

Wire.go

@@ -41,6 +41,7 @@ import (
 	"github.com/devtron-labs/devtron/api/deployment"
 	"github.com/devtron-labs/devtron/api/devtronResource"
 	"github.com/devtron-labs/devtron/api/externalLink"
+	fluxApplication "github.com/devtron-labs/devtron/api/fluxApplication"
 	client "github.com/devtron-labs/devtron/api/helm-app"
 	"github.com/devtron-labs/devtron/api/infraConfig"
 	"github.com/devtron-labs/devtron/api/k8s"
@@ -193,7 +194,7 @@ func InitializeApp() (*App, error) {
 		build.BuildWireSet,
 		deployment2.DeploymentWireSet,
 		argoApplication.ArgoApplicationWireSet,
-
+		fluxApplication.FluxApplicationWireSet,
 		eventProcessor.EventProcessorWireSet,
 		workflow3.WorkflowWireSet,
 

api/fluxApplication/FluxApplicationRestHandler.go

@@ -0,0 +1,94 @@
+package fluxApplication
+
+import (
+	"errors"
+	"github.com/devtron-labs/devtron/api/restHandler/common"
+	"github.com/devtron-labs/devtron/pkg/auth/authorisation/casbin"
+	clientErrors "github.com/devtron-labs/devtron/pkg/errors"
+	"github.com/devtron-labs/devtron/pkg/fluxApplication"
+	"github.com/gorilla/mux"
+	"go.uber.org/zap"
+	"net/http"
+)
+
+type FluxApplicationRestHandler interface {
+	ListFluxApplications(w http.ResponseWriter, r *http.Request)
+	GetApplicationDetail(w http.ResponseWriter, r *http.Request)
+}
+
+type FluxApplicationRestHandlerImpl struct {
+	fluxApplicationService fluxApplication.FluxApplicationService
+	logger                 *zap.SugaredLogger
+	enforcer               casbin.Enforcer
+}
+
+func NewFluxApplicationRestHandlerImpl(fluxApplicationService fluxApplication.FluxApplicationService,
+	logger *zap.SugaredLogger, enforcer casbin.Enforcer) *FluxApplicationRestHandlerImpl {
+	return &FluxApplicationRestHandlerImpl{
+		fluxApplicationService: fluxApplicationService,
+		logger:                 logger,
+		enforcer:               enforcer,
+	}
+
+}
+
+func (handler *FluxApplicationRestHandlerImpl) ListFluxApplications(w http.ResponseWriter, r *http.Request) {
+
+	//handle super-admin RBAC
+	token := r.Header.Get("token")
+	if ok := handler.enforcer.Enforce(token, casbin.ResourceGlobal, casbin.ActionGet, "*"); !ok {
+		common.WriteJsonResp(w, errors.New("unauthorized"), nil, http.StatusForbidden)
+		return
+	}
+	v := r.URL.Query()
+	clusterIdString := v.Get("clusterIds")
+	var clusterIds []int
+	var err error
+
+	//handling when the clusterIds string is empty ,it will not support the
+	if len(clusterIdString) == 0 {
+		handler.logger.Errorw("error in getting cluster ids", "error", err, "clusterIds", clusterIds)
+		common.WriteJsonResp(w, errors.New("error in getting cluster ids"), nil, http.StatusBadRequest)
+		return
+	}
+	clusterIds, err = common.ExtractIntArrayQueryParam(w, r, "clusterIds")
+	if err != nil {
+		handler.logger.Errorw("error in parsing cluster ids", "error", err, "clusterIds", clusterIds)
+		return
+	}
+	handler.logger.Debugw("extracted ClusterIds successfully ", "clusterIds", clusterIds)
+	handler.fluxApplicationService.ListFluxApplications(r.Context(), clusterIds, w)
+}
+
+func (handler *FluxApplicationRestHandlerImpl) GetApplicationDetail(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	appIdString := vars["appId"]
+	appIdentifier, err := fluxApplication.DecodeFluxExternalAppId(appIdString)
+	if err != nil {
+		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
+		return
+	}
+	if appIdentifier.IsKustomizeApp == true && appIdentifier.Name == "flux-system" && appIdentifier.Namespace == "flux-system" {
+
+		common.WriteJsonResp(w, errors.New("cannot proceed for the flux system root level "), nil, http.StatusBadRequest)
+		return
+	}
+
+	// handle super-admin RBAC
+	token := r.Header.Get("token")
+	if ok := handler.enforcer.Enforce(token, casbin.ResourceGlobal, casbin.ActionGet, "*"); !ok {
+		common.WriteJsonResp(w, errors.New("unauthorized"), nil, http.StatusForbidden)
+		return
+	}
+
+	res, err := handler.fluxApplicationService.GetFluxAppDetail(r.Context(), appIdentifier)
+	if err != nil {
+		apiError := clientErrors.ConvertToApiError(err)
+		if apiError != nil {
+			err = apiError
+		}
+		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)
+		return
+	}
+	common.WriteJsonResp(w, err, res, http.StatusOK)
+}

api/fluxApplication/FluxApplicationRouter.go

@@ -0,0 +1,27 @@
+package fluxApplication
+
+import (
+	"github.com/gorilla/mux"
+)
+
+type FluxApplicationRouter interface {
+	InitFluxApplicationRouter(fluxApplicationRouter *mux.Router)
+}
+
+type FluxApplicationRouterImpl struct {
+	fluxApplicationRestHandler FluxApplicationRestHandler
+}
+
+func NewFluxApplicationRouterImpl(fluxApplicationRestHandler FluxApplicationRestHandler) *FluxApplicationRouterImpl {
+	return &FluxApplicationRouterImpl{
+		fluxApplicationRestHandler: fluxApplicationRestHandler,
+	}
+}
+
+func (impl *FluxApplicationRouterImpl) InitFluxApplicationRouter(fluxApplicationRouter *mux.Router) {
+	fluxApplicationRouter.Path("").
+		Methods("GET").
+		HandlerFunc(impl.fluxApplicationRestHandler.ListFluxApplications)
+	fluxApplicationRouter.Path("/app").Queries("appId", "{appId}").
+		HandlerFunc(impl.fluxApplicationRestHandler.GetApplicationDetail).Methods("GET")
+}

api/fluxApplication/wire_fluxApplication.go

@@ -0,0 +1,17 @@
+package fluxApplication
+
+import (
+	"github.com/devtron-labs/devtron/pkg/fluxApplication"
+	"github.com/google/wire"
+)
+
+var FluxApplicationWireSet = wire.NewSet(
+	fluxApplication.NewFluxApplicationServiceImpl,
+	wire.Bind(new(fluxApplication.FluxApplicationService), new(*fluxApplication.FluxApplicationServiceImpl)),
+
+	NewFluxApplicationRestHandlerImpl,
+	wire.Bind(new(FluxApplicationRestHandler), new(*FluxApplicationRestHandlerImpl)),
+
+	NewFluxApplicationRouterImpl,
+	wire.Bind(new(FluxApplicationRouter), new(*FluxApplicationRouterImpl)),
+)

api/helm-app/HelmAppRestHandler.go

@@ -25,6 +25,8 @@ import (
 	"github.com/devtron-labs/devtron/pkg/appStore/installedApp/service"
 	"github.com/devtron-labs/devtron/pkg/appStore/installedApp/service/EAMode"
 	clientErrors "github.com/devtron-labs/devtron/pkg/errors"
+	"github.com/devtron-labs/devtron/pkg/fluxApplication"
+	"github.com/devtron-labs/devtron/pkg/k8s"
 	"net/http"
 	"strconv"
 	"strings"
@@ -72,13 +74,14 @@ type HelmAppRestHandlerImpl struct {
 	userAuthService           user.UserService
 	attributesService         attributes.AttributesService
 	serverEnvConfig           *serverEnvConfig.ServerEnvConfig
+	fluxApplication           fluxApplication.FluxApplicationService
 }
 
 func NewHelmAppRestHandlerImpl(logger *zap.SugaredLogger,
 	helmAppService service2.HelmAppService, enforcer casbin.Enforcer,
 	clusterService cluster.ClusterService, enforcerUtil rbac.EnforcerUtilHelm,
 	appStoreDeploymentService service.AppStoreDeploymentService, installedAppService EAMode.InstalledAppDBService,
-	userAuthService user.UserService, attributesService attributes.AttributesService, serverEnvConfig *serverEnvConfig.ServerEnvConfig) *HelmAppRestHandlerImpl {
+	userAuthService user.UserService, attributesService attributes.AttributesService, serverEnvConfig *serverEnvConfig.ServerEnvConfig, fluxApplication fluxApplication.FluxApplicationService) *HelmAppRestHandlerImpl {
 	return &HelmAppRestHandlerImpl{
 		logger:                    logger,
 		helmAppService:            helmAppService,
@@ -90,6 +93,7 @@ func NewHelmAppRestHandlerImpl(logger *zap.SugaredLogger,
 		userAuthService:           userAuthService,
 		attributesService:         attributesService,
 		serverEnvConfig:           serverEnvConfig,
+		fluxApplication:           fluxApplication,
 	}
 }
 
@@ -159,68 +163,124 @@ func (handler *HelmAppRestHandlerImpl) GetApplicationDetail(w http.ResponseWrite
 }
 
 func (handler *HelmAppRestHandlerImpl) Hibernate(w http.ResponseWriter, r *http.Request) {
-	hibernateRequest := &openapi.HibernateRequest{}
-	decoder := json.NewDecoder(r.Body)
-	err := decoder.Decode(hibernateRequest)
-	if err != nil {
-		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
-		return
-	}
-	appIdentifier, err := handler.helmAppService.DecodeAppId(*hibernateRequest.AppId)
+	hibernateRequest, err := decodeHibernateRequest(r)
 	if err != nil {
 		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
 		return
 	}
 
-	// RBAC enforcer applying
-	rbacObject, rbacObject2 := handler.enforcerUtil.GetHelmObjectByClusterIdNamespaceAndAppName(appIdentifier.ClusterId, appIdentifier.Namespace, appIdentifier.ReleaseName)
 	token := r.Header.Get("token")
-	ok := handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject) || handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject2)
-	if !ok {
-		common.WriteJsonResp(w, errors.New("unauthorized"), nil, http.StatusForbidden)
-		return
+	var res []*openapi.HibernateStatus
+
+	if k8s.IsClusterStringContainsFluxField(*hibernateRequest.AppId) {
+		res, err = handler.handleFluxApplicationHibernate(r, token, hibernateRequest)
+	} else {
+		res, err = handler.handleHelmApplicationHibernate(r, token, hibernateRequest)
 	}
-	//RBAC enforcer Ends
-	res, err := handler.helmAppService.HibernateApplication(r.Context(), appIdentifier, hibernateRequest)
 	if err != nil {
-		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)
+		common.WriteJsonResp(w, err, nil, service2.GetStatusCode(err))
 		return
 	}
 	common.WriteJsonResp(w, err, res, http.StatusOK)
 }
 
-func (handler *HelmAppRestHandlerImpl) UnHibernate(w http.ResponseWriter, r *http.Request) {
+func decodeHibernateRequest(r *http.Request) (*openapi.HibernateRequest, error) {
 	hibernateRequest := &openapi.HibernateRequest{}
 	decoder := json.NewDecoder(r.Body)
 	err := decoder.Decode(hibernateRequest)
 	if err != nil {
-		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
-		return
+		return nil, err
+	}
+	return hibernateRequest, nil
+}
+
+func (handler *HelmAppRestHandlerImpl) handleFluxApplicationHibernate(r *http.Request, token string, hibernateRequest *openapi.HibernateRequest) ([]*openapi.HibernateStatus, error) {
+	appIdentifier, err := fluxApplication.DecodeFluxExternalAppId(*hibernateRequest.AppId)
+	if err != nil {
+		return nil, err
 	}
+
+	if !handler.enforcer.Enforce(token, casbin.ResourceGlobal, casbin.ActionUpdate, "*") {
+		return nil, errors.New("unauthorized")
+	}
+
+	return handler.fluxApplication.HibernateFluxApplication(r.Context(), appIdentifier, hibernateRequest)
+}
+
+func (handler *HelmAppRestHandlerImpl) handleHelmApplicationHibernate(r *http.Request, token string, hibernateRequest *openapi.HibernateRequest) ([]*openapi.HibernateStatus, error) {
 	appIdentifier, err := handler.helmAppService.DecodeAppId(*hibernateRequest.AppId)
+	if err != nil {
+		return nil, err
+	}
+	rbacObject, rbacObject2 := handler.enforcerUtil.GetHelmObjectByClusterIdNamespaceAndAppName(
+		appIdentifier.ClusterId,
+		appIdentifier.Namespace,
+		appIdentifier.ReleaseName,
+	)
+
+	ok := handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject) ||
+		handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject2)
+	if !ok {
+		return nil, errors.New("unauthorized")
+	}
+
+	return handler.helmAppService.HibernateApplication(r.Context(), appIdentifier, hibernateRequest)
+}
+func (handler *HelmAppRestHandlerImpl) UnHibernate(w http.ResponseWriter, r *http.Request) {
+	hibernateRequest, err := decodeHibernateRequest(r)
 	if err != nil {
 		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
 		return
 	}
-	// RBAC enforcer applying
-	rbacObject, rbacObject2 := handler.enforcerUtil.GetHelmObjectByClusterIdNamespaceAndAppName(appIdentifier.ClusterId, appIdentifier.Namespace, appIdentifier.ReleaseName)
 	token := r.Header.Get("token")
+	var res []*openapi.HibernateStatus
 
-	ok := handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject) || handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject2)
-
-	if !ok {
-		common.WriteJsonResp(w, errors.New("unauthorized"), nil, http.StatusForbidden)
-		return
+	if k8s.IsClusterStringContainsFluxField(*hibernateRequest.AppId) {
+		res, err = handler.handleFluxApplicationUnHibernate(r, token, hibernateRequest)
+	} else {
+		res, err = handler.handleHelmApplicationUnHibernate(r, token, hibernateRequest)
 	}
-	//RBAC enforcer Ends
-	res, err := handler.helmAppService.UnHibernateApplication(r.Context(), appIdentifier, hibernateRequest)
+
 	if err != nil {
-		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)
+		common.WriteJsonResp(w, err, nil, service2.GetStatusCode(err))
 		return
 	}
+
 	common.WriteJsonResp(w, err, res, http.StatusOK)
 }
 
+func (handler *HelmAppRestHandlerImpl) handleFluxApplicationUnHibernate(r *http.Request, token string, hibernateRequest *openapi.HibernateRequest) ([]*openapi.HibernateStatus, error) {
+	appIdentifier, err := fluxApplication.DecodeFluxExternalAppId(*hibernateRequest.AppId)
+	if err != nil {
+		return nil, err
+	}
+	if !handler.enforcer.Enforce(token, casbin.ResourceGlobal, casbin.ActionUpdate, "*") {
+		return nil, errors.New("unauthorized")
+	}
+	return handler.fluxApplication.UnHibernateFluxApplication(r.Context(), appIdentifier, hibernateRequest)
+}
+
+func (handler *HelmAppRestHandlerImpl) handleHelmApplicationUnHibernate(r *http.Request, token string, hibernateRequest *openapi.HibernateRequest) ([]*openapi.HibernateStatus, error) {
+	appIdentifier, err := handler.helmAppService.DecodeAppId(*hibernateRequest.AppId)
+	if err != nil {
+		return nil, err
+	}
+
+	rbacObject, rbacObject2 := handler.enforcerUtil.GetHelmObjectByClusterIdNamespaceAndAppName(
+		appIdentifier.ClusterId,
+		appIdentifier.Namespace,
+		appIdentifier.ReleaseName,
+	)
+
+	ok := handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject) ||
+		handler.enforcer.Enforce(token, casbin.ResourceHelmApp, casbin.ActionUpdate, rbacObject2)
+	if !ok {
+		return nil, errors.New("unauthorized")
+	}
+
+	return handler.helmAppService.UnHibernateApplication(r.Context(), appIdentifier, hibernateRequest)
+}
+
 func (handler *HelmAppRestHandlerImpl) GetReleaseInfo(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	appId := vars["appId"]

api/helm-app/gRPC/applicationClient.go

@@ -30,6 +30,7 @@ import (
 
 type HelmAppClient interface {
 	ListApplication(ctx context.Context, req *AppListRequest) (ApplicationService_ListApplicationsClient, error)
+	ListFluxApplication(ctx context.Context, req *AppListRequest) (ApplicationService_ListFluxApplicationsClient, error)
 	GetAppDetail(ctx context.Context, in *AppDetailRequest) (*AppDetail, error)
 	GetResourceTreeForExternalResources(ctx context.Context, in *ExternalResourceTreeRequest) (*ResourceTreeResponse, error)
 	GetAppStatus(ctx context.Context, in *AppDetailRequest) (*AppStatus, error)
@@ -50,6 +51,7 @@ type HelmAppClient interface {
 	InstallReleaseWithCustomChart(ctx context.Context, in *HelmInstallCustomRequest) (*HelmInstallCustomResponse, error)
 	GetNotes(ctx context.Context, request *InstallReleaseRequest) (*ChartNotesResponse, error)
 	ValidateOCIRegistry(ctx context.Context, OCIRegistryRequest *RegistryCredential) (*OCIRegistryResponse, error)
+	GetExternalFluxAppDetail(ctx context.Context, in *FluxAppDetailRequest) (*FluxAppDetail, error)
 }
 
 type HelmAppClientImpl struct {
@@ -368,3 +370,25 @@ func (impl *HelmAppClientImpl) ValidateOCIRegistry(ctx context.Context, in *Regi
 	}
 	return response, nil
 }
+func (impl *HelmAppClientImpl) ListFluxApplication(ctx context.Context, req *AppListRequest) (ApplicationService_ListFluxApplicationsClient, error) {
+	applicationClient, err := impl.getApplicationClient()
+	if err != nil {
+		return nil, err
+	}
+	stream, err := applicationClient.ListFluxApplications(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return stream, nil
+}
+func (impl *HelmAppClientImpl) GetExternalFluxAppDetail(ctx context.Context, in *FluxAppDetailRequest) (*FluxAppDetail, error) {
+	applicationClient, err := impl.getApplicationClient()
+	if err != nil {
+		return nil, err
+	}
+	detail, err := applicationClient.GetFluxAppDetail(ctx, in)
+	if err != nil {
+		return nil, err
+	}
+	return detail, nil
+}