Merge pull request #6318 from devtron-labs/bypass-ns-check

misc: bypass ns check

Author: prakash100198

api/helm-app/gRPC/applicationClient.go

@@ -72,6 +72,7 @@ func NewHelmAppClientImpl(logger *zap.SugaredLogger,
 	}
 }
 
+// CATEGORY=INFRA_SETUP
 type HelmClientConfig struct {
 	Url string `env:"HELM_CLIENT_URL" envDefault:"127.0.0.1:50051"`
 }

api/helm-app/service/HelmAppService.go

@@ -146,6 +146,7 @@ func NewHelmAppServiceImpl(Logger *zap.SugaredLogger, clusterService cluster.Clu
 	}
 }
 
+// CATEGORY=CD
 type HelmReleaseConfig struct {
 	RevisionHistoryLimitDevtronApp      int `env:"REVISION_HISTORY_LIMIT_DEVTRON_APP" envDefault:"1"`
 	RevisionHistoryLimitHelmApp         int `env:"REVISION_HISTORY_LIMIT_HELM_APP" envDefault:"1"`

api/restHandler/app/appList/AppListingRestHandler.go

@@ -493,7 +493,7 @@ func (handler AppListingRestHandlerImpl) FetchAppDetailsV2(w http.ResponseWriter
 		return
 	}
 
-	err = handler.updateApprovalConfigDataInAppDetailResp(appDetail, appId, envId)
+	appDetail, err = handler.updateApprovalConfigDataInAppDetailResp(appDetail, appId, envId)
 	if err != nil {
 		common.WriteJsonResp(w, err, nil, http.StatusInternalServerError)
 		return

api/restHandler/app/appList/AppListingRestHandler_ent.go

@@ -14,6 +14,6 @@ func (handler AppListingRestHandlerImpl) FetchAutocompleteJobCiPipelines(w http.
 func (handler AppListingRestHandlerImpl) GetAllAppEnvsFromResourceNames(w http.ResponseWriter, r *http.Request) {
 }
 
-func (handler AppListingRestHandlerImpl) updateApprovalConfigDataInAppDetailResp(appDetail AppView.AppDetailContainer, appId, envId int) error {
-	return nil
+func (handler AppListingRestHandlerImpl) updateApprovalConfigDataInAppDetailResp(appDetail AppView.AppDetailContainer, appId, envId int) (AppView.AppDetailContainer, error) {
+	return AppView.AppDetailContainer{}, nil
 }

client/dashboard/Config.go

@@ -20,6 +20,7 @@ import (
 	"github.com/caarlos0/env"
 )
 
+// CATEGORY=INFRA_SETUP
 type Config struct {
 	Host      string `env:"DASHBOARD_HOST" envDefault:"localhost"`
 	Port      string `env:"DASHBOARD_PORT" envDefault:"3000"`

client/gitSensor/GitSensorClient.go

@@ -79,6 +79,7 @@ func NewGitSensorClient(logger *zap.SugaredLogger, config *ClientConfig) (*Clien
 	return client, nil
 }
 
+// CATEGORY=INFRA_SETUP
 type ClientConfig struct {
 	Url      string `env:"GIT_SENSOR_URL" envDefault:"127.0.0.1:7070"`
 	Protocol string `env:"GIT_SENSOR_PROTOCOL" envDefault:"REST"`

env_gen.json

@@ -17,6 +17,8 @@
 package main
 
 import (
+	"encoding/json"
+	"errors"
 	"go/ast"
 	"go/parser"
 	"go/token"
@@ -31,56 +33,55 @@ import (
 
 type EnvField struct {
 	Env            string
+	EnvType        string
 	EnvValue       string
 	EnvDescription string
+	Example        string
+	Deprecated     string
+}
+
+type CategoryField struct {
+	Category string
+	Fields   []EnvField
 }
 
 const (
-	envFieldTypeTag            = "env"
-	envDefaultFieldTypeTag     = "envDefault"
-	envDescriptionFieldTypeTag = "envDescription"
-	MARKDOWN_FILENAME          = "env_gen.md"
+	categoryCommentStructPrefix = "CATEGORY="
+	defaultCategory             = "DEVTRON"
+	deprecatedDefaultValue      = "false"
+
+	envFieldTypeTag               = "env"
+	envDefaultFieldTypeTag        = "envDefault"
+	envDescriptionFieldTypeTag    = "description"
+	envPossibleValuesFieldTypeTag = "example"
+	envDeprecatedFieldTypeTag     = "deprecated"
+	MARKDOWN_FILENAME             = "env_gen.md"
+	MARKDOWN_JSON_FILENAME        = "env_gen.json"
 )
 
 const MarkdownTemplate = `
-## Devtron Environment Variables
-| Key   | Value        | Description       |
-|-------|--------------|-------------------|
-{{range .}} | {{ .Env }} | {{ .EnvValue }} | {{ .EnvDescription }} | 
+{{range . }}
+## {{ .Category }} Related Environment Variables
+| Key   | Type     | Default Value     | Description       | Example       | Deprecated       |
+|-------|----------|-------------------|-------------------|-----------------------|------------------|
+{{range .Fields }} | {{ .Env }} | {{ .EnvType }} |{{ .EnvValue }} | {{ .EnvDescription }} | {{ .Example }} | {{ .Deprecated }} |
+{{end}}
 {{end}}`
 
-func writeToFile(allFields []EnvField) {
-	sort.Slice(allFields, func(i, j int) bool {
-		return allFields[i].Env < allFields[j].Env
-	})
-
-	file, err := os.Create(MARKDOWN_FILENAME)
-	if err != nil {
-		panic(err)
-	}
-	defer file.Close()
-
-	tmpl, err := template.New("markdown").Parse(MarkdownTemplate)
-	if err != nil {
-		panic(err)
-	}
-
-	err = tmpl.Execute(file, allFields)
-	if err != nil {
-		panic(err)
-	}
+func main() {
+	WalkThroughProject()
+	return
 }
 
 func WalkThroughProject() {
-	var allFields []EnvField
+	categoryFieldsMap := make(map[string][]EnvField)
 	uniqueKeys := make(map[string]bool)
-
 	err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
 		if !info.IsDir() && strings.HasSuffix(path, ".go") {
-			err = processGoFile(path, &allFields, &uniqueKeys)
+			err = processGoFile(path, categoryFieldsMap, uniqueKeys)
 			if err != nil {
 				log.Println("error in processing go file", err)
 				return err
@@ -91,49 +92,41 @@ func WalkThroughProject() {
 	if err != nil {
 		return
 	}
-	writeToFile(allFields)
-}
-
-func convertTagToStructTag(tag string) reflect.StructTag {
-	return reflect.StructTag(strings.Split(tag, "`")[1])
-}
-
-func getEnvKeyAndValue(tag reflect.StructTag) (string, string, string) {
-	envKey := tag.Get(envFieldTypeTag)
-	envValue := tag.Get(envDefaultFieldTypeTag)
-	envDescription := tag.Get(envDescriptionFieldTypeTag)
-	// check if there exist any value provided in env for this field
-	if value, ok := os.LookupEnv(envKey); ok {
-		envValue = value
-	}
-	return envKey, envValue, envDescription
+	writeToFile(categoryFieldsMap)
 }
 
-func processGoFile(filePath string, allFields *[]EnvField, uniqueKeys *map[string]bool) error {
+func processGoFile(filePath string, categoryFieldsMap map[string][]EnvField, uniqueKeys map[string]bool) error {
 	fset := token.NewFileSet()
 	node, err := parser.ParseFile(fset, filePath, nil, parser.ParseComments)
 	if err != nil {
 		log.Println("error parsing file:", err)
 		return err
 	}
-
 	ast.Inspect(node, func(n ast.Node) bool {
-		switch x := n.(type) {
-		case *ast.TypeSpec:
-			if structType, ok := x.Type.(*ast.StructType); ok {
-				for _, field := range structType.Fields.List {
-					if field.Tag != nil {
-						strippedTags := convertTagToStructTag(field.Tag.Value)
-						envKey, envValue, envDescription := getEnvKeyAndValue(strippedTags)
-						if len(envKey) == 0 || (*uniqueKeys)[envKey] {
-							continue
+		if genDecl, ok := n.(*ast.GenDecl); ok {
+			// checking if type declaration, one of [func, map, struct, array, channel, interface]
+			if genDecl.Tok == token.TYPE {
+				for _, spec := range genDecl.Specs {
+					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+						// only checking struct type declarations
+						if structType, ok2 := typeSpec.Type.(*ast.StructType); ok2 {
+							allFields := make([]EnvField, 0, len(structType.Fields.List))
+							for _, field := range structType.Fields.List {
+								if field.Tag != nil {
+									envField := getEnvKeyAndValue(field)
+									envKey := envField.Env
+									if len(envKey) == 0 || uniqueKeys[envKey] {
+										continue
+									}
+									allFields = append(allFields, envField)
+									uniqueKeys[envKey] = true
+								}
+							}
+							if len(allFields) > 0 {
+								category := getCategoryForAStruct(genDecl)
+								categoryFieldsMap[category] = append(categoryFieldsMap[category], allFields...)
+							}
 						}
-						*allFields = append(*allFields, EnvField{
-							Env:            envKey,
-							EnvValue:       envValue,
-							EnvDescription: envDescription,
-						})
-						(*uniqueKeys)[envKey] = true
 					}
 				}
 			}
@@ -143,7 +136,91 @@ func processGoFile(filePath string, allFields *[]EnvField, uniqueKeys *map[strin
 	return nil
 }
 
-func main() {
-	WalkThroughProject()
-	return
+func getEnvKeyAndValue(field *ast.Field) EnvField {
+	tag := reflect.StructTag(strings.Trim(field.Tag.Value, "`")) // remove surrounding backticks
+
+	envKey := addReadmeTableDelimiterEscapeChar(tag.Get(envFieldTypeTag))
+	envValue := addReadmeTableDelimiterEscapeChar(tag.Get(envDefaultFieldTypeTag))
+	envDescription := addReadmeTableDelimiterEscapeChar(tag.Get(envDescriptionFieldTypeTag))
+	envPossibleValues := addReadmeTableDelimiterEscapeChar(tag.Get(envPossibleValuesFieldTypeTag))
+	envDeprecated := addReadmeTableDelimiterEscapeChar(tag.Get(envDeprecatedFieldTypeTag))
+	// check if there exist any value provided in env for this field
+	if value, ok := os.LookupEnv(envKey); ok {
+		envValue = value
+	}
+	env := EnvField{
+		Env:            envKey,
+		EnvValue:       envValue,
+		EnvDescription: envDescription,
+		Example:        envPossibleValues,
+		Deprecated:     envDeprecated,
+	}
+	if indent, ok := field.Type.(*ast.Ident); ok && indent != nil {
+		env.EnvType = indent.Name
+	}
+	if len(envDeprecated) == 0 {
+		env.Deprecated = deprecatedDefaultValue
+	}
+	return env
+}
+
+func getCategoryForAStruct(genDecl *ast.GenDecl) string {
+	category := defaultCategory
+	if genDecl.Doc != nil {
+		commentTexts := strings.Split(genDecl.Doc.Text(), "\n")
+		for _, comment := range commentTexts {
+			commentText := strings.TrimPrefix(strings.ReplaceAll(comment, " ", ""), "//") // this can happen if comment group is in /* */
+			if strings.HasPrefix(commentText, categoryCommentStructPrefix) {
+				categories := strings.Split(strings.TrimPrefix(commentText, categoryCommentStructPrefix), ",")
+				if len(categories) > 0 && len(categories[0]) > 0 { //only supporting one category as of now
+					category = categories[0] //overriding category
+					break
+				}
+			}
+		}
+	}
+	return category
+}
+
+func addReadmeTableDelimiterEscapeChar(s string) string {
+	return strings.ReplaceAll(s, "|", `\|`)
+}
+
+func writeToFile(categoryFieldsMap map[string][]EnvField) {
+	cfs := make([]CategoryField, 0, len(categoryFieldsMap))
+	for category, allFields := range categoryFieldsMap {
+		sort.Slice(allFields, func(i, j int) bool {
+			return allFields[i].Env < allFields[j].Env
+		})
+
+		cfs = append(cfs, CategoryField{
+			Category: category,
+			Fields:   allFields,
+		})
+	}
+	sort.Slice(cfs, func(i, j int) bool {
+		return cfs[i].Category < cfs[j].Category
+	})
+	file, err := os.Create(MARKDOWN_FILENAME)
+	if err != nil && !errors.Is(err, os.ErrExist) {
+		panic(err)
+	}
+	defer file.Close()
+	tmpl, err := template.New("markdown").Parse(MarkdownTemplate)
+	if err != nil {
+		panic(err)
+	}
+	err = tmpl.Execute(file, cfs)
+	if err != nil {
+		panic(err)
+	}
+	cfsMarshaled, err := json.Marshal(cfs)
+	if err != nil {
+		log.Println("error marshalling category fields:", err)
+		panic(err)
+	}
+	err = os.WriteFile(MARKDOWN_JSON_FILENAME, cfsMarshaled, 0644)
+	if err != nil {
+		panic(err)
+	}
 }

env_gen.md

@@ -72,6 +72,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
+// CATEGORY=CD
 type AppServiceConfig struct {
 	CdPipelineStatusCronTime                   string `env:"CD_PIPELINE_STATUS_CRON_TIME" envDefault:"*/2 * * * *"`
 	CdHelmPipelineStatusCronTime               string `env:"CD_HELM_PIPELINE_STATUS_CRON_TIME" envDefault:"*/2 * * * *"`