How do pipeline parameters and jenkins GUI parameters work together?

Question

I am using a pipeline in a jenkinsfile and I am not sure how to properly link the job in Jenkins and the pipeline.

I defined parameters in my jenkinsfile (some with default values, some without) and have them initialized from the parameters coming from jenkins gui. The problem is that it seams the parameters in my pipeline are overiding my job parameters, EVEN when no default value is specified in the pipeline which means the pipeline is overriding my job setup in jenkins.

for example, one of my job is setup to run the pipeline with some specific values (all NON-EMPTY), if I trigger the job, the pipeline seem to reset the properties to '' for fields b and c.

How to I get the pipeline to not touch my jenkins job definition?

e.g. the params in the pipeline:

    properties([
      parameters([
        string(name: 'a',   defaultValue: 'Default A value', description: '', ),
        string(name: 'b',   description: '', ),
        string(name: 'c',   description: '', ),
       ])
])

I am not find any help in the documentation at https://jenkins.io/doc/book/pipeline/syntax/#parameters-example

Answer 1

Ah, yes, it got me the first time around also.

The first time that you run the pipeline, the jenkinsFile DSL job definition pretty much overrides the whole job definition that you have entered thru the GUI. That affects the parameters in particular.

So make sure you define the parameters exactly how you want them in the Jenkinsfile, then run the job once, and the GUI will have the same config for the parameters, so that when you run again, it will ask for the parameters and use the default values, that you specified in the DSL. There is nothing more to it.

Yes, having to run twice everytime you modify the parameters in the DSL is annoying. But it sort of makes sense if you consider that the job has to execute for the DSL to be evaluated, but first it needs to ask for parameters if you have some defined via the UI, BEFORE it checks out and evaluates the DSL...

Answer 2

This problem can be solved by adding a special parameter to avoid default values being override. Here is the sample code.

if (!params.__INIT__) { // this value will be true once parameters get initialized
    properties([ parameters([
            string(name: 'SOURCE_URL', trim: true),
            string(name: 'TARGET_URL', trim: true),

            string(name: 'DEPLOY_URL', trim: true),
            credentials(name: 'DEPLOY_KEY', required: true ),

            string(name: 'BUILD_NODE', trim: true),

            booleanParam(name: '__INIT__', defaultValue: true, description: "Uncheck this field in configuration page and run this job once if you want to re init parameter."),
    ]) ])
    return // exit 
}

// Your task stars from here

By doing this way, the parameters won't be initialized again next time because __INIT__ has been set to true. On the other hand, if you update your script and change some parameters, you can just run the job by unchecking the __INIT__ field.

Answer 3

Old question, and there are maybe some better solutions now, but I didn't find them, so posting this anyway in case it helps.
@link69 answer is really good, and led me to something maybe a bit more advanced,
which allows choosing whereas a user provided value is stored or not as the default value.
On my side, there are parameters that I would like to be "one shot", eg "debug build", while I would like to be able to set some persistent parameters from the UI (eg git branch to be used).
The main drawback is that the pipeline doesn't know if a parameter has been modified from the project "configure" page or in "build with parameters", and saves the value as "default" in both cases. I also don't like to repeat the parameter name twice for each parameter in the parameters block.

// Update parameters[paramName] with defaultValue if paramName key is not present,
// Return the default value
def <T> T updateMapReturnDefault(Map parameters, String paramName, T defaultValue)
{
    if (!parameters.containsKey(paramName))
        parameters[paramName] = defaultValue

    return defaultValue
}

// Update parameters[paramName] with defaultValue if paramName key is not present,
// Return the value read from the map if present, the default value otherwise
def <T> T updateMapReturnValue(Map parameters, String paramName, T defaultValue)
{
    if (!parameters.containsKey(paramName))
        parameters[paramName] = defaultValue

    return parameters[paramName]
}

def call(Map config) {
    node {
        // Copy params map to allow modifying it
        userParams = new HashMap(params)

        properties([
            parameters([
                // Value will be stored as default on each build
                string(name: "GIT_BRANCH", defaultValue: updateMapReturnValue(userParams, "GIT_BRANCH", "main")),
                // Value will be reset on each build
                booleanParam(name: "DEBUG_BUILD", defaultValue: updateMapReturnDefault(userParams, "DEBUG_BUILD", false)),
                // Set JUST_UPDATE_PARAMETERS to true to update the parameters list and exit
                // True by default so that the first build just updates the parameters
                booleanParam(name: "JUST_UPDATE_PARAMETERS", defaultValue: updateMapReturnValue(userParams, "JUST_UPDATE_PARAMETERS", true)),
            ])
        ])

        if (userParams.JUST_UPDATE_PARAMETERS) {
            stage("Update pipeline parameters") {
                println("JUST_UPDATE_PARAMETERS is set, not building")
                currentBuild.displayName = "parameters update"
                return
            }
        }

        stage("build") {
            println("Build started, branch ${userParams.GIT_BRANCH}, debug_build: ${userParams.DEBUG_BUILD}")
        }
    }
}