web-dev-qa-db-fra.com

Puis-je créer des étapes de manière dynamique dans un pipeline Jenkins?

Je dois lancer un ensemble de tests dynamiques dans un pipeline déclaratif. Pour une meilleure visualisation, j'aimerais créer une étape pour chaque test. Y a-t-il un moyen de le faire?

La seule façon de créer une scène que je connaisse est la suivante:

stage('foo') {
   ...
}

J'ai vu cet exemple , mais je n'utilise pas de syntaxe déclarative.

jenkinsjenkins-pipeline
28
david.perez

Utilisez la syntaxe scriptée qui permet plus de flexibilité que la syntaxe déclarative, même si la déclaration est plus documentée et recommandée.

Par exemple, les étapes peuvent être créées en boucle:

def tests = params.Tests.split(',')
for (int i = 0; i < tests.length; i++) {
    stage("Test ${tests[i]}") {
        sh '....'
    }
}
19
david.perez

Vous voudrez peut-être jeter un oeil à cet exemple - vous pouvez faire en sorte qu'une fonction retourne une fermeture qui devrait pouvoir avoir une étape en elle.

Ce code montre le concept, mais n'a pas d'étape.

def transformDeployBuildStep(OS) {
    return {
        node ('master') { 
        wrap([$class: 'TimestamperBuildWrapper']) {
...
        } } // ts / node
    } // closure
} // transformDeployBuildStep

stage("Yum Deploy") {
  stepsForParallel = [:]
  for (int i = 0; i < TargetOSs.size(); i++) {
      def s = TargetOSs.get(i)
      def stepName = "CentOS ${s} Deployment"
      stepsForParallel[stepName] = transformDeployBuildStep(s)
  }
  stepsForParallel['failFast'] = false
  parallel stepsForParallel
} // stage
13
Aaron D. Marasco

@ Jorge Machado: Parce que je ne peux pas commenter, je devais l'afficher en tant que réponse. Je l'ai résolu récemment. J'espère que ça vous aidera.

Pipeline déclaratif:

Un exemple statique simple:

stage('Dynamic') {
        steps {
            script {
                stage('NewOne') {

                        echo('new one echo')

                }
            }
        }
    }

Exemple réel dynamique:

    // in a declarative pipeline
        stage('Trigger Building') {
              when {
                environment(name: 'DO_BUILD_PACKAGES', value: 'true')
              }
              steps {
                executeModuleScripts('build') // local method, see at the end of this script
              }
            }


    // at the end of the file or in a shared library
        void executeModuleScripts(String operation) {

          def allModules = ['module1', 'module2', 'module3', 'module4', 'module11']

          allModules.each { module ->  
          String action = "${operation}:${module}"  

          echo("---- ${action.toUpperCase()} ----")        
          String command = "npm run ${action} -ddd"                   

            // here is the trick           
            script {
              stage(module) {
                bat(command)
              }
            }
          }

}
8
BuckTheBug

J'utilise cela pour générer mes stages qui contiennent un travail Jenkins. build_list est une liste des travaux Jenkins que je veux déclencher à partir de mon travail principal, mais j'ai une étape pour chaque travail qui est déclencheur.

build_list = ['job1', 'job2', 'job3']
        for(int i=0; i < build_list.size(); i++) {
          stage(build_list[i]){
               build job: build_list[i], propagate: false
          }
        }
2
JamesD

Comme l'a suggéré JamesD, vous pouvez créer des étapes de manière dynamique (mais elles seront séquentielles) comme ceci:

def list
pipeline {
    agent none
    options {buildDiscarder(logRotator(daysToKeepStr: '7', numToKeepStr: '1'))}
    stages {
        stage('Create List') {
            agent {node 'nodename'}
            steps {
                script {
                    // you may create your list here, lets say reading from a file after checkout
                    list = ["Test-1", "Test-2", "Test-3", "Test-4", "Test-5"]
                }
            }
            post {
                cleanup {
                    cleanWs()
                }
            }
        }
        stage('Dynamic Stages') {
            agent {node 'nodename'}
            steps {
                script {
                    for(int i=0; i < list.size(); i++) {
                        stage(list[i]){
                            echo "Element: $i"
                        }
                    }
                }
            }
            post {
                cleanup {
                    cleanWs()
                }
            }
        }
    }
}

Cela se traduira par: étapes dynamiques-séquentielles

1
Anton Yurchenko