mirror of
https://github.com/SAP/jenkins-library.git
synced 2024-12-14 11:03:09 +02:00
0ba4c2206c
* update all deprecated ioutil usages * forgotten changes * add missing imports * undo changing comment * add missing 'os' import * fix integration test --------- Co-authored-by: I557621 <jordi.van.liempt@sap.com> Co-authored-by: Gulom Alimov <gulomjon.alimov@sap.com>
211 lines
6.4 KiB
Go
211 lines
6.4 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
|
|
"github.com/SAP/jenkins-library/pkg/piperutils"
|
|
"github.com/ghodss/yaml"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// RunConfig ...
|
|
type RunConfig struct {
|
|
StageConfigFile io.ReadCloser
|
|
StageConfig StageConfig
|
|
RunStages map[string]bool
|
|
RunSteps map[string]map[string]bool
|
|
OpenFile func(s string, t map[string]string) (io.ReadCloser, error)
|
|
FileUtils *piperutils.Files
|
|
}
|
|
|
|
type RunConfigV1 struct {
|
|
RunConfig
|
|
PipelineConfig PipelineDefinitionV1
|
|
}
|
|
|
|
type StageConfig struct {
|
|
Stages map[string]StepConditions `json:"stages,omitempty"`
|
|
}
|
|
|
|
type StepConditions struct {
|
|
Conditions map[string]map[string]interface{} `json:"stepConditions,omitempty"`
|
|
}
|
|
|
|
type PipelineDefinitionV1 struct {
|
|
APIVersion string `json:"apiVersion"`
|
|
Kind string `json:"kind"`
|
|
Metadata Metadata `json:"metadata"`
|
|
Spec Spec `json:"spec"`
|
|
openFile func(s string, t map[string]string) (io.ReadCloser, error)
|
|
runSteps map[string]map[string]bool
|
|
}
|
|
|
|
type Metadata struct {
|
|
Name string `json:"name,omitempty"`
|
|
DisplayName string `json:"displayName,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
}
|
|
|
|
type Spec struct {
|
|
Stages []Stage `json:"stages"`
|
|
}
|
|
|
|
type Stage struct {
|
|
Name string `json:"name,omitempty"`
|
|
DisplayName string `json:"displayName,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
Steps []Step `json:"steps,omitempty"`
|
|
}
|
|
|
|
type Step struct {
|
|
Name string `json:"name,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
Conditions []StepCondition `json:"conditions,omitempty"`
|
|
NotActiveConditions []StepCondition `json:"notActiveConditions,omitempty"`
|
|
Orchestrators []string `json:"orchestrators,omitempty"`
|
|
}
|
|
|
|
type StepCondition struct {
|
|
Config map[string][]interface{} `json:"config,omitempty"`
|
|
ConfigKey string `json:"configKey,omitempty"`
|
|
FilePattern string `json:"filePattern,omitempty"`
|
|
FilePatternFromConfig string `json:"filePatternFromConfig,omitempty"`
|
|
Inactive bool `json:"inactive,omitempty"`
|
|
OnlyActiveStepInStage bool `json:"onlyActiveStepInStage,omitempty"`
|
|
NpmScript string `json:"npmScript,omitempty"`
|
|
CommonPipelineEnvironment map[string]interface{} `json:"commonPipelineEnvironment,omitempty"`
|
|
PipelineEnvironmentFilled string `json:"pipelineEnvironmentFilled,omitempty"`
|
|
}
|
|
|
|
func (r *RunConfigV1) InitRunConfigV1(config *Config, utils piperutils.FileUtils, envRootPath string) error {
|
|
|
|
if len(r.PipelineConfig.Spec.Stages) == 0 {
|
|
if err := r.LoadConditionsV1(); err != nil {
|
|
return fmt.Errorf("failed to load pipeline run conditions: %w", err)
|
|
}
|
|
}
|
|
|
|
err := r.evaluateConditionsV1(config, utils, envRootPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to evaluate step conditions: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// InitRunConfig ...
|
|
func (r *RunConfig) InitRunConfig(config *Config, filters map[string]StepFilters, parameters map[string][]StepParameters,
|
|
secrets map[string][]StepSecrets, stepAliases map[string][]Alias, glob func(pattern string) (matches []string, err error),
|
|
openFile func(s string, t map[string]string) (io.ReadCloser, error)) error {
|
|
r.OpenFile = openFile
|
|
r.RunSteps = map[string]map[string]bool{}
|
|
|
|
if len(r.StageConfig.Stages) == 0 {
|
|
if err := r.loadConditions(); err != nil {
|
|
return errors.Wrap(err, "failed to load pipeline run conditions")
|
|
}
|
|
}
|
|
|
|
err := r.evaluateConditions(config, filters, parameters, secrets, stepAliases, glob)
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to evaluate step conditions: %v")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ToDo: optimize parameter handling
|
|
func (r *RunConfig) getStepConfig(config *Config, stageName, stepName string, filters map[string]StepFilters,
|
|
parameters map[string][]StepParameters, secrets map[string][]StepSecrets, stepAliases map[string][]Alias) (StepConfig, error) {
|
|
// no support for flag values and envParameters
|
|
// so far not considered necessary
|
|
|
|
flagValues := map[string]interface{}{} // args of step from pipeline_generated.yml
|
|
|
|
envParameters := map[string]interface{}{}
|
|
|
|
// parameters via paramJSON not supported
|
|
// not considered releavant for pipeline yaml syntax resolution
|
|
paramJSON := ""
|
|
|
|
stepMeta := StepData{
|
|
Spec: StepSpec{
|
|
Inputs: StepInputs{Parameters: parameters[stepName], Secrets: secrets[stepName]},
|
|
},
|
|
Metadata: StepMetadata{Aliases: stepAliases[stepName]},
|
|
}
|
|
|
|
return config.GetStepConfig(flagValues, paramJSON, nil, nil, false, filters[stepName], stepMeta, envParameters, stageName, stepName)
|
|
}
|
|
|
|
func (r *RunConfig) loadConditions() error {
|
|
defer r.StageConfigFile.Close()
|
|
content, err := io.ReadAll(r.StageConfigFile)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "error: failed to read the stageConfig file")
|
|
}
|
|
|
|
err = yaml.Unmarshal(content, &r.StageConfig)
|
|
if err != nil {
|
|
return errors.Errorf("format of configuration is invalid %q: %v", content, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// LoadConditionsV1 loads stage conditions (in CRD-style) into PipelineConfig
|
|
func (r *RunConfigV1) LoadConditionsV1() error {
|
|
defer r.StageConfigFile.Close()
|
|
content, err := io.ReadAll(r.StageConfigFile)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "error: failed to read the stageConfig file")
|
|
}
|
|
|
|
err = yaml.Unmarshal(content, &r.PipelineConfig)
|
|
if err != nil {
|
|
return errors.Errorf("format of configuration is invalid %q: %v", content, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func stepConfigLookup(m map[string]interface{}, stepName, key string) interface{} {
|
|
// flat map: key is on top level
|
|
if m[key] != nil {
|
|
return m[key]
|
|
}
|
|
// lookup for step config with following format
|
|
// general:
|
|
// <key>: <value>
|
|
// stages:
|
|
// <stepName>:
|
|
// <key>: <value>
|
|
// steps:
|
|
// <stepName>:
|
|
// <key>: <value>
|
|
if m["general"] != nil {
|
|
general := m["general"].(map[string]interface{})
|
|
if general[key] != nil {
|
|
return general[key]
|
|
}
|
|
}
|
|
if m["stages"] != nil {
|
|
stages := m["stages"].(map[string]interface{})
|
|
if stages[stepName] != nil {
|
|
stageStepConfig := stages[stepName].(map[string]interface{})
|
|
if stageStepConfig[key] != nil {
|
|
return stageStepConfig[key]
|
|
}
|
|
}
|
|
}
|
|
if m["steps"] != nil {
|
|
steps := m["steps"].(map[string]interface{})
|
|
if steps[stepName] != nil {
|
|
stepConfig := steps[stepName].(map[string]interface{})
|
|
if stepConfig[key] != nil {
|
|
return stepConfig[key]
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|