sync: release candidate v0.43.0

App.go

@@ -18,7 +18,6 @@ package main
 
 import (
 	"context"
-	"crypto/tls"
 	"errors"
 	"fmt"
 	"github.com/devtron-labs/common-lib/middlewares"
@@ -68,7 +67,6 @@ type App struct {
 	// eventProcessor.CentralEventProcessor is used to register event processors
 	centralEventProcessor *eventProcessor.CentralEventProcessor // do not remove this.
 	// used for local dev only
-	serveTls                   bool
 	sessionManager2            *authMiddleware.SessionManager
 	OtelTracingService         *otel.OtelTracingServiceImpl
 	loggingMiddleware          util.LoggingMiddleware
@@ -99,7 +97,6 @@ func NewApp(router *router.MuxRouter,
 		Enforcer:                   enforcer,
 		EnforcerV2:                 enforcerV2,
 		db:                         db,
-		serveTls:                   false,
 		sessionManager2:            sessionManager2,
 		posthogClient:              posthogClient,
 		OtelTracingService:         otel.NewOtelTracingServiceImpl(Logger),
@@ -132,22 +129,7 @@ func (app *App) Start() {
 		app.MuxRouter.Router.Use(otelmux.Middleware(otel.OTEL_ORCHESTRASTOR_SERVICE_NAME))
 	}
 	app.server = server
-	var err error
-	if app.serveTls {
-		cert, err := tls.LoadX509KeyPair(
-			"localhost.crt",
-			"localhost.key",
-		)
-		if err != nil {
-			log.Fatal(err)
-		}
-		server.TLSConfig = &tls.Config{
-			Certificates: []tls.Certificate{cert},
-		}
-		err = server.ListenAndServeTLS("", "")
-	} else {
-		err = server.ListenAndServe()
-	}
+	err := server.ListenAndServe()
 	//err := http.ListenAndServe(fmt.Sprintf(":%d", port), auth.Authorizer(app.Enforcer, app.sessionManager)(app.MuxRouter.Router))
 	if err != nil && !errors.Is(err, http.ErrServerClosed) {
 		app.Logger.Errorw("error in startup", "err", err)

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.24.0 AS build-env
+FROM golang:1.24.6 AS build-env
 
 RUN echo $GOPATH && \
     apt update && \

DockerfileEA

@@ -1,4 +1,4 @@
-FROM golang:1.24.0  AS build-env
+FROM golang:1.24.6  AS build-env
 
 RUN echo $GOPATH && \
     apt update && \

Makefile

@@ -2,7 +2,7 @@
 
 all: fetch-all-env build
 
-TARGET_BRANCH?=main
+TARGET_BRANCH?=develop
 TAG?=$(shell bash -c 'git log --pretty=format:'%h' -n 1')
 FLAGS=
 ENVVAR=

api/appStore/chartGroup/ChartGroupRestHandler.go

@@ -191,7 +191,7 @@ func (impl *ChartGroupRestHandlerImpl) GetChartGroupWithChartMetaData(w http.Res
 	}
 
 	// Use enhanced parameter parsing with context
-	chartGroupId, err := common.ExtractIntPathParamWithContext(w, r, "chartGroupId", "chart group")
+	chartGroupId, err := common.ExtractIntPathParamWithContext(w, r, "chartGroupId")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return
@@ -223,7 +223,7 @@ func (impl *ChartGroupRestHandlerImpl) GetChartGroupInstallationDetail(w http.Re
 	}
 
 	// Use enhanced parameter parsing with context
-	chartGroupId, err := common.ExtractIntPathParamWithContext(w, r, "chartGroupId", "chart group")
+	chartGroupId, err := common.ExtractIntPathParamWithContext(w, r, "chartGroupId")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return

api/appStore/deployment/AppStoreDeploymentRestHandler.go

@@ -415,6 +415,10 @@ func (handler AppStoreDeploymentRestHandlerImpl) UpdateInstalledApp(w http.Respo
 	handler.Logger.Debugw("request payload, UpdateInstalledApp", "payload", request)
 	installedApp, err := handler.appStoreDeploymentDBService.GetInstalledApp(request.InstalledAppId)
 	if err != nil {
+		if util.IsErrNoRows(err) {
+			common.HandleResourceNotFound(w, r, "installedApp", strconv.Itoa(request.InstalledAppVersionId))
+			return
+		}
 		handler.Logger.Errorw("service err, UpdateInstalledApp", "err", err, "payload", request)
 		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)
 		return
@@ -461,6 +465,8 @@ func (handler AppStoreDeploymentRestHandlerImpl) UpdateInstalledApp(w http.Respo
 	if err != nil {
 		if strings.Contains(err.Error(), "application spec is invalid") {
 			err = &util.ApiError{Code: "400", HttpStatusCode: 400, UserMessage: "application spec is invalid, please check provided chart values"}
+		} else if util.IsErrNoRows(err) {
+			handler.Logger.Errorw("installed app not found", "err", err, "payload", request)
 		}
 		handler.Logger.Errorw("service err, UpdateInstalledApp", "err", err, "payload", request)
 		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)

api/appStore/deployment/CommonDeploymentRestHandler.go

@@ -87,12 +87,12 @@ func (handler *CommonDeploymentRestHandlerImpl) getAppOfferingMode(installedAppI
 	if len(appId) > 0 {
 		appIdentifier, err := handler.helmAppService.DecodeAppId(appId)
 		if err != nil {
-			err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "invalid app id"}
+			// err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "invalid app id"}
 			return appOfferingMode, installedAppDto, err
 		}
 		installedAppDto, err = handler.installedAppService.GetInstalledAppByClusterNamespaceAndName(appIdentifier)
 		if err != nil {
-			err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "unable to find app in database"}
+			// err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "unable to find app in database"}
 			return appOfferingMode, installedAppDto, err
 		}
 		// this is the case when hyperion apps does not linked yet
@@ -103,7 +103,7 @@ func (handler *CommonDeploymentRestHandlerImpl) getAppOfferingMode(installedAppI
 			installedAppDto.AppOfferingMode = appOfferingMode
 			appIdentifier, err := handler.helmAppService.DecodeAppId(appId)
 			if err != nil {
-				err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "invalid app id"}
+				// err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "invalid app id, expected format clusterId|namespace|releaseName"}
 				return appOfferingMode, installedAppDto, err
 			}
 			installedAppDto.ClusterId = appIdentifier.ClusterId
@@ -113,16 +113,17 @@ func (handler *CommonDeploymentRestHandlerImpl) getAppOfferingMode(installedAppI
 	} else if len(installedAppId) > 0 {
 		installedAppId, err := strconv.Atoi(installedAppId)
 		if err != nil {
-			err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "invalid installed app id"}
+			handler.Logger.Errorw("Invalid installedAppId expected int value", "installedAppId", installedAppId, "err", err)
 			return appOfferingMode, installedAppDto, err
 		}
 		installedAppDto, err = handler.installedAppService.GetInstalledAppByInstalledAppId(installedAppId)
 		if err != nil {
-			err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "unable to find app in database"}
+			// err = &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "unable to find app in database"}
 			return appOfferingMode, installedAppDto, err
 		}
 	} else {
 		err := &util.ApiError{HttpStatusCode: http.StatusBadRequest, UserMessage: "app id missing in request"}
+		handler.Logger.Errorw("appId is missing and is a required field", "appId", appId, "err", err)
 		return appOfferingMode, installedAppDto, err
 	}
 	if installedAppDto != nil && installedAppDto.InstalledAppId > 0 {
@@ -188,6 +189,7 @@ func (handler *CommonDeploymentRestHandlerImpl) GetDeploymentHistoryValues(w htt
 	v := r.URL.Query()
 	installedAppId := v.Get("installedAppId")
 	appId := v.Get("appId")
+
 	appOfferingMode, installedAppDto, err := handler.getAppOfferingMode(installedAppId, appId)
 	if err != nil {
 		common.WriteJsonResp(w, err, "bad request", http.StatusBadRequest)

api/auth/user/UserRestHandler.go

@@ -210,7 +210,7 @@ func (handler UserRestHandlerImpl) GetById(w http.ResponseWriter, r *http.Reques
 	}
 
 	// Use enhanced parameter parsing with context
-	id, err := common.ExtractIntPathParamWithContext(w, r, "id", "user")
+	id, err := common.ExtractIntPathParamWithContext(w, r, "id")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return
@@ -334,7 +334,7 @@ func (handler UserRestHandlerImpl) DeleteUser(w http.ResponseWriter, r *http.Req
 	}
 
 	// Use enhanced parameter parsing with context
-	id, err := common.ExtractIntPathParamWithContext(w, r, "id", "user")
+	id, err := common.ExtractIntPathParamWithContext(w, r, "id")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return
@@ -427,7 +427,7 @@ func (handler UserRestHandlerImpl) BulkDeleteUsers(w http.ResponseWriter, r *htt
 
 func (handler UserRestHandlerImpl) FetchRoleGroupById(w http.ResponseWriter, r *http.Request) {
 	// Use enhanced parameter parsing with context
-	id, err := common.ExtractIntPathParamWithContext(w, r, "id", "role group")
+	id, err := common.ExtractIntPathParamWithContext(w, r, "id")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return

api/chartRepo/ChartRepositoryRestHandler.go

@@ -85,7 +85,7 @@ func (handler *ChartRepositoryRestHandlerImpl) GetChartRepoById(w http.ResponseW
 	}
 
 	// Use enhanced parameter parsing with context
-	id, err := common.ExtractIntPathParamWithContext(w, r, "id", "chart repository")
+	id, err := common.ExtractIntPathParamWithContext(w, r, "id")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return

api/cluster/ClusterRestHandler.go

@@ -356,7 +356,7 @@ func (impl ClusterRestHandlerImpl) FindByIds(w http.ResponseWriter, r *http.Requ
 
 func (impl ClusterRestHandlerImpl) FindById(w http.ResponseWriter, r *http.Request) {
 	// Use enhanced parameter parsing with context
-	clusterId, err := common.ExtractIntPathParamWithContext(w, r, "id", "cluster")
+	clusterId, err := common.ExtractIntPathParamWithContext(w, r, "id")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return
@@ -734,7 +734,7 @@ func (impl ClusterRestHandlerImpl) GetClusterNamespaces(w http.ResponseWriter, r
 		isActionUserSuperAdmin = true
 	}
 	// extract cluster and handle response on error
-	clusterId, err := common.ExtractIntPathParamWithContext(w, r, "clusterId", "cluster")
+	clusterId, err := common.ExtractIntPathParamWithContext(w, r, "clusterId")
 	if err != nil {
 		impl.logger.Error("error in parsing clusterId", "clusterId", clusterId, "err", err)
 		return

api/cluster/EnvironmentRestHandler.go

@@ -349,7 +349,7 @@ func (impl EnvironmentRestHandlerImpl) Update(w http.ResponseWriter, r *http.Req
 
 func (impl EnvironmentRestHandlerImpl) FindById(w http.ResponseWriter, r *http.Request) {
 	// Use enhanced parameter parsing with context
-	envId, err := common.ExtractIntPathParamWithContext(w, r, "id", "environment")
+	envId, err := common.ExtractIntPathParamWithContext(w, r, "id")
 	if err != nil {
 		// Error already written by ExtractIntPathParamWithContext
 		return
@@ -482,11 +482,15 @@ func (impl EnvironmentRestHandlerImpl) GetCombinedEnvironmentListForDropDownByCl
 			id, err := strconv.Atoi(clusterId)
 			if err != nil {
 				impl.logger.Errorw("request err, GetCombinedEnvironmentListForDropDownByClusterIds", "err", err, "clusterIdString", clusterIdString)
-				common.WriteJsonResp(w, err, "please send valid cluster Ids", http.StatusBadRequest)
+				common.HandleParameterError(w, r, "ids", clusterIdString)
 				return
 			}
 			clusterIds = append(clusterIds, id)
 		}
+	} else {
+		impl.logger.Errorw("request err empty query param, GetCombinedEnvironmentListForDropDownByClusterIds", "err", err, "clusterIdString", clusterIdString)
+		common.HandleParameterError(w, r, "ids", clusterIdString)
+		return
 	}
 	token := r.Header.Get("token")
 	clusters, err := impl.environmentClusterMappingsService.GetCombinedEnvironmentListForDropDownByClusterIds(token, clusterIds, impl.rbacEnforcementUtil.CheckAuthorizationForGlobalEnvironment)

api/devtronResource/DevtronResourceHistoryRestHandler.go

@@ -54,9 +54,16 @@ func (handler *HistoryRestHandlerImpl) GetDeploymentHistory(w http.ResponseWrite
 	queryParams := apiBean.GetHistoryQueryParams{}
 	err := decoder.Decode(&queryParams, v)
 	if err != nil {
+		handler.logger.Errorw("error in decoding query parameters", "queryParams", v, "err", err)
 		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
 		return
 	}
+	// Validating that filterCriteria is provided
+	if len(queryParams.FilterCriteria) == 0 {
+		handler.logger.Errorw("missing required filterCriteria parameter")
+		common.HandleParameterError(w, r, "filterCriteria", "")
+		return
+	}
 	decodedReqBean, err := handler.apiReqDecoderService.GetFilterCriteriaParamsForDeploymentHistory(queryParams.FilterCriteria)
 	if err != nil {
 		handler.logger.Errorw("error in getting filter criteria params", "err", err, "filterCriteria", queryParams.FilterCriteria)

api/helm-app/service/helper.go

@@ -29,7 +29,7 @@ import (
 func DecodeExternalAppAppId(appId string) (*bean.AppIdentifier, error) {
 	component := strings.Split(appId, "|")
 	if len(component) != 3 {
-		return nil, fmt.Errorf("malformed app id %s", appId)
+		return nil, fmt.Errorf("malformed appId,  appId: %s, expected format clusterId|namespace|releaseName", appId)
 	}
 	clusterId, err := strconv.Atoi(component[0])
 	if err != nil {

api/k8s/application/k8sApplicationRestHandler.go

@@ -1002,14 +1002,19 @@
 		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
 		return
 	}
-	if err = handler.validator.Struct(request); err != nil || (request.BasicData == nil && request.AdvancedData == nil) {
-		if err != nil {
-			err = errors.New("invalid request payload")
-		}
-		handler.logger.Errorw("invalid request payload", "err", err, "payload", request)
+	if request.BasicData == nil && request.AdvancedData == nil {
+		err = errors.New("invalid request payload, neither basic data nor advanced data provided")
+		handler.logger.Errorw("invalid request payload missing basic data and invalid data", "err", err, "payload", request)
 		common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
 		return
 	}
+	err = handler.validator.Struct(request)
+	if err != nil {
+		handler.logger.Errorw("invalid request payload", "err", err, "payload", request)
+		//common.WriteJsonResp(w, err, nil, http.StatusBadRequest)
+		common.HandleValidationErrors(w, r, err)
+		return
+	}
 	// check for super admin
 	restricted := handler.restrictTerminalAccessForNonSuperUsers(w, token)
 	if restricted {
@@ -1079,6 +1084,13 @@
 	_, err = handler.k8sApplicationService.TerminatePodEphemeralContainer(request)
 	if err != nil {
 		handler.logger.Errorw("error occurred in terminating ephemeral container", "err", err, "requestPayload", request)
+		if err.Error() == bean4.EXTERNAL_EPHIMERAL_CONTAINER_ERR {
+			common.WriteJsonResp(w, err, nil, http.StatusForbidden)
+			return
+		} else if err.Error() == bean4.EPHEMERAL_CONTAINER_NOT_FOUND_ERR {
+			common.WriteJsonResp(w, err, nil, http.StatusNotFound)
+			return
+		}
 		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)
 		return
 	}

api/middleware/ErrorHandlingMiddleware.go

@@ -19,12 +19,11 @@ package middleware
 import (
 	"context"
 	"fmt"
-	"github.com/devtron-labs/devtron/internal/util"
-	"github.com/gorilla/mux"
-	"go.uber.org/zap"
 	"net/http"
-	"strconv"
 	"time"
+
+	"github.com/gorilla/mux"
+	"go.uber.org/zap"
 )
 
 // ErrorHandlingMiddleware provides enhanced error handling and logging for REST handlers
@@ -156,47 +155,3 @@ func GetRequestContext(r *http.Request) *RequestContext {
 	}
 	return nil
 }
-
-// LogError logs an error with request context for better debugging
-func (m *ErrorHandlingMiddleware) LogError(r *http.Request, err error, operation string) {
-	reqCtx := GetRequestContext(r)
-	if reqCtx != nil {
-		m.logger.Errorw("Request error",
-			"requestId", reqCtx.RequestID,
-			"operation", operation,
-			"error", err,
-			"method", reqCtx.Method,
-			"path", reqCtx.Path,
-			"resourceType", reqCtx.ResourceType,
-			"resourceId", reqCtx.ResourceID,
-		)
-	} else {
-		m.logger.Errorw("Request error",
-			"operation", operation,
-			"error", err,
-			"method", r.Method,
-			"path", r.URL.Path,
-		)
-	}
-}
-
-// ValidateIntPathParam validates and extracts an integer path parameter with enhanced error handling
-func ValidateIntPathParam(r *http.Request, paramName string) (int, *util.ApiError) {
-	vars := mux.Vars(r)
-	paramValue := vars[paramName]
-
-	if paramValue == "" {
-		return 0, util.NewMissingRequiredFieldError(paramName)
-	}
-
-	id, err := strconv.Atoi(paramValue)
-	if err != nil {
-		return 0, util.NewInvalidPathParameterError(paramName, paramValue)
-	}
-
-	if id <= 0 {
-		return 0, util.NewValidationErrorForField(paramName, "must be a positive integer")
-	}
-
-	return id, nil
-}