क्या मैं जेनकींस पाइपलाइन में गतिशील चरणों को बना सकता हूं?

Question

मुझे एक घोषणात्मक पाइपलाइन में परीक्षणों का एक गतिशील सेट लॉन्च करने की आवश्यकता है। बेहतर विज़ुअलाइजेशन उद्देश्यों के लिए, मैं प्रत्येक परीक्षण के लिए एक मंच बनाना चाहता हूं। ऐसा करने का कोई तरीका है?

एक मंच मैं जानता हूँ कि बनाने के लिए एक ही रास्ता है:

stage('foo') { 
    ... 
} 

मैं this example देखा है, लेकिन मैं इसे कथात्मक सिंटैक्स का उपयोग नहीं करता है।

Answer 1

लिखित वाक्यविन्यास का उपयोग करें जो घोषणात्मक वाक्यविन्यास की तुलना में अधिक लचीलापन की अनुमति देता है, भले ही घोषणात्मक अधिक दस्तावेज और अनुशंसित हो।

उदाहरण चरणों के लिए एक पाश में बनाया जा सकता है:

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

Answer 2

मैं इस का उपयोग अपने चरणों जो उन्हें में एक जेनकींस काम होते हैं उत्पन्न करने के लिए। build_list जेनकींस नौकरियों की एक सूची है जो मैं अपने मुख्य जेनकींस नौकरी से ट्रिगर करना चाहता हूं, लेकिन ट्रिगर होने वाली प्रत्येक नौकरी के लिए एक मंच है।

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 
      } 
     } 

Answer 3

आप this example पर एक नज़र लेने के लिए चाहते हो सकता है - आप एक समारोह को बंद करने की जो उस में एक चरण के लिए सक्षम होना चाहिए वापसी हो सकती है।

यह कोड अवधारणा को दिखाता है, लेकिन इसमें कोई मंच नहीं है।

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