github.com/ouraigua/jenkins-library@v0.0.0-20231028010029-fbeaf2f3aa9b/pkg/documentation/generator/defaults.go (about)

     1  package generator
     2  
     3  import (
     4  	"sort"
     5  	"strings"
     6  
     7  	"github.com/SAP/jenkins-library/pkg/config"
     8  )
     9  
    10  func appendContextParameters(stepData *config.StepData) {
    11  	contextParameterNames := stepData.GetContextParameterFilters().All
    12  	if len(contextParameterNames) > 0 {
    13  		contextDetailsPath := "pkg/generator/helper/piper-context-defaults.yaml"
    14  
    15  		contextDetails := config.StepData{}
    16  		readContextInformation(contextDetailsPath, &contextDetails)
    17  
    18  		for _, contextParam := range contextDetails.Spec.Inputs.Parameters {
    19  			if contains(contextParameterNames, contextParam.Name) {
    20  				stepData.Spec.Inputs.Parameters = append(stepData.Spec.Inputs.Parameters, contextParam)
    21  			}
    22  		}
    23  	}
    24  }
    25  
    26  func consolidateContextDefaults(stepData *config.StepData) {
    27  	paramConditions := paramConditionDefaults{}
    28  	for _, container := range stepData.Spec.Containers {
    29  		containerParams := getContainerParameters(container, false)
    30  		if container.Conditions != nil && len(container.Conditions) > 0 {
    31  			for _, cond := range container.Conditions {
    32  				if cond.ConditionRef == "strings-equal" {
    33  					for _, condParam := range cond.Params {
    34  						for paramName, val := range containerParams {
    35  							if _, ok := paramConditions[paramName]; !ok {
    36  								paramConditions[paramName] = &conditionDefaults{}
    37  							}
    38  							paramConditions[paramName].equal = append(paramConditions[paramName].equal, conditionDefault{key: condParam.Name, value: condParam.Value, def: val})
    39  						}
    40  					}
    41  				}
    42  			}
    43  		} else {
    44  			for paramName, val := range containerParams {
    45  				if _, ok := paramConditions[paramName]; !ok {
    46  					paramConditions[paramName] = &conditionDefaults{}
    47  				}
    48  				paramConditions[paramName].equal = append(paramConditions[paramName].equal, conditionDefault{def: val})
    49  			}
    50  		}
    51  	}
    52  
    53  	stashes := []interface{}{}
    54  	conditionalStashes := []conditionDefault{}
    55  	for _, res := range stepData.Spec.Inputs.Resources {
    56  		//consider only resources of type stash, others not relevant for conditions yet
    57  		if res.Type == "stash" {
    58  			if res.Conditions == nil || len(res.Conditions) == 0 {
    59  				stashes = append(stashes, res.Name)
    60  			} else {
    61  				for _, cond := range res.Conditions {
    62  					if cond.ConditionRef == "strings-equal" {
    63  						for _, condParam := range cond.Params {
    64  							conditionalStashes = append(conditionalStashes, conditionDefault{key: condParam.Name, value: condParam.Value, def: res.Name})
    65  						}
    66  					}
    67  				}
    68  			}
    69  		}
    70  	}
    71  
    72  	sortConditionalDefaults(conditionalStashes)
    73  
    74  	for _, conditionalStash := range conditionalStashes {
    75  		stashes = append(stashes, conditionalStash)
    76  	}
    77  
    78  	for key, param := range stepData.Spec.Inputs.Parameters {
    79  		if param.Name == "stashContent" {
    80  			stepData.Spec.Inputs.Parameters[key].Default = stashes
    81  		}
    82  
    83  		for containerParam, paramDefault := range paramConditions {
    84  			if param.Name == containerParam {
    85  				sortConditionalDefaults(paramConditions[param.Name].equal)
    86  				stepData.Spec.Inputs.Parameters[key].Default = paramDefault.equal
    87  			}
    88  		}
    89  	}
    90  }
    91  
    92  func consolidateConditionalParameters(stepData *config.StepData) {
    93  	newParamList := []config.StepParameters{}
    94  
    95  	paramConditions := paramConditionDefaults{}
    96  
    97  	for _, param := range stepData.Spec.Inputs.Parameters {
    98  		if param.Conditions == nil || len(param.Conditions) == 0 {
    99  			newParamList = append(newParamList, param)
   100  			continue
   101  		}
   102  
   103  		if _, ok := paramConditions[param.Name]; !ok {
   104  			newParamList = append(newParamList, param)
   105  			paramConditions[param.Name] = &conditionDefaults{}
   106  		}
   107  		for _, cond := range param.Conditions {
   108  			if cond.ConditionRef == "strings-equal" {
   109  				for _, condParam := range cond.Params {
   110  					paramConditions[param.Name].equal = append(paramConditions[param.Name].equal, conditionDefault{key: condParam.Name, value: condParam.Value, def: param.Default})
   111  				}
   112  			}
   113  		}
   114  	}
   115  
   116  	for i, param := range newParamList {
   117  		if _, ok := paramConditions[param.Name]; ok {
   118  			newParamList[i].Conditions = nil
   119  			sortConditionalDefaults(paramConditions[param.Name].equal)
   120  			newParamList[i].Default = paramConditions[param.Name].equal
   121  		}
   122  	}
   123  
   124  	stepData.Spec.Inputs.Parameters = newParamList
   125  }
   126  
   127  func sortConditionalDefaults(conditionDefaults []conditionDefault) {
   128  	sort.SliceStable(conditionDefaults[:], func(i int, j int) bool {
   129  		keyLess := strings.Compare(conditionDefaults[i].key, conditionDefaults[j].key) < 0
   130  		valLess := strings.Compare(conditionDefaults[i].value, conditionDefaults[j].value) < 0
   131  		return keyLess || keyLess && valLess
   132  	})
   133  }
   134  
   135  type paramConditionDefaults map[string]*conditionDefaults
   136  
   137  type conditionDefaults struct {
   138  	equal []conditionDefault
   139  }
   140  
   141  type conditionDefault struct {
   142  	key   string
   143  	value string
   144  	def   interface{}
   145  }