how to schedule parameterized pipelines to run just once with one parameter and the rest with another one?

Question

I have a pipeline which I just added 2 parameters to build release or debug (parameters are called release or debug). The pipeline uses cron syntax to check for changes in the SCM every 10 mins, the pipeline checks for every commit and then build release (C++ program) but I would like to build debug once a day, let's say everyday every coomit pushed from 12 to 13 will be build in debug. All of this without me having to run the pipeline and changing the parameter manually (it is set to release by default). Is there any way to do this? This is a very short version of what the pipeline looks like:

    pipeline {
    
        stages {
          stage('Setup parameters') {
            steps {
                script { 
                    properties([
                        parameters([
                            choice(
                                defaultValue: 'RELEASE', 
                                choices: ['RELEASE', 'DEBUG'], 
                                name: 'BUILD_CONFIG'
                            ),
                        ])
                    ])
                }
            }
        }
        stage('Build release'){
            when {
                expression {
                   return params.BUILD_CONFIG == 'RELEASE'
                }
            }
            steps{
                script {
                    def msbuild = tool name: 'MSBuild', type: 'hudson.plugins.msbuild.MsBuildInstallation'
                    bat "\"${msbuild}\" /Source/project-GRDK.sln /t:Rebuild  /p:configuration=\"Release Steam D3D11\""
                }
            }
        }
        stage('Build debug'){
            when {
                expression {
                   return params.BUILD_CONFIG == 'DEBUG'
                }
            }
            steps{
                script {
                    def msbuild = tool name: 'MSBuild', type: 'hudson.plugins.msbuild.MsBuildInstallation'
                    bat "\"${msbuild}\" /Source/project-GRDK.sln /t:Rebuild /p:configuration=\"Debug Steam D3D11\""
                }
            }
        }
        }
    }

Answer 1

It is possible to determine the cause of the build with currentBuild.rawBuild.getCause(Class<T> type). The type you are looking for is UserIdCause. Following would build a stage in case the job was not triggered by an user (manually). In this stage steps are from Build debug stage.

stage('Build debug if time triggered') {
   when {
     expression {
       return currentBuild.rawBuild.getCause(hudson.model.Cause$UserIdCause) == null
     }
   }
   steps {
     script {
       def msbuild = tool name: 'MSBuild', type: 'hudson.plugins.msbuild.MsBuildInstallation'
       bat "\"${msbuild}\" /Source/project-GRDK.sln /t:Rebuild /p:configuration=\"Debug Steam D3D11\""
            
     }
}

You will also need to add an expression to Build release and Build debug stages, in order to prevent building if the job is not triggered by an user (manually).

    stage('Build release'){
        when {
            allOf {
               expression {
                   return params.BUILD_CONFIG == 'RELEASE'
               }
               expression {
                   return currentBuild.rawBuild.getCause(hudson.model.Cause$UserIdCause) != null
               }
            }
        }
        ...

Docu:
https://javadoc.jenkins-ci.org/hudson/model/Cause.html
https://javadoc.jenkins-ci.org/hudson/model/Run.html
How to differentiate build triggers in Jenkins Pipeline

EDIT
If you want to keep everything in one pipeline, then you need to create two new variables. Following code creates Calendar object for 12 am today and converts it to milliseconds.

Calendar date = new GregorianCalendar()
date.set(Calendar.HOUR_OF_DAY, 12);
date.set(Calendar.MINUTE, 0);
date.set(Calendar.SECOND, 0);
date.set(Calendar.MILLISECOND, 0);

def start = date.getTime().getTime()

In same way you could create a Calendar object for 1 pm today (e.g. end). With currentBuild.rawBuild.getTimestamp() you get Calendar object, when the build was scheduled. If the scheduled time is between start and end set for example a boolean variable and check it in the pipeline when block.

def buildDebug = false
def scheduled = currentBuild.rawBuild.getTimestamp().getTime().getTime()
if(scheduled > start && scheduled < end)
  buildDebug = true

...

stage('Build release'){
  when {
    allOf {
      expression {
        return params.BUILD_CONFIG == 'RELEASE'
      }
      expression {
        return currentBuild.rawBuild.getCause(hudson.model.Cause$UserIdCause) == null
      }
      expression {
        return buildDebug == false
      }
    }
  }
  ...
stage('Build debug'){
  when {
    allOf {
      expression {
        return params.BUILD_CONFIG == 'RELEASE'
      }
      expression {
        return currentBuild.rawBuild.getCause(hudson.model.Cause$UserIdCause) == null
      }
      expression {
        return buildDebug == true
      }
    }
  }
  
 

How to create a Java Date object of midnight today and midnight tomorrow?

Answer 2

Another option would be to create a second job, which triggers the build job with the right parameters:

pipeline {
   agent any

   triggers {
       cron('H 12 * * *')
   }

   stages {
       stage('Build xxx debug') {
           steps {
               build job: "your-job-name-here", parameters: [
                   choice(name: 'BUILD_CONFIG', value: 'DEBUG')
               ]
           }
       }
   }
}

Answer 3

parameterizedCron plugin does what you need:

pipeline {
    agent any
    parameters {
        choice(name: 'BUILD_CONFIG', choices: ['RELEASE', 'DEBUG'], defaultValue: 'RELEASE')
    }
    triggers {
        parameterizedCron('''
            1,2,3,4,5,6,7,8,9,10 * * * * % BUILD_CONFIG=RELEASE
            12 * * * * % BUILD_CONFIG=DEBUG
        ''')
    }