एक घोषणात्मक पाइपलाइन के साथ गतिशील समानांतर कार्रवाई को ठीक से कैसे प्राप्त करें?

Question

वर्तमान में, मुझे एक कार्यान्वयन की आवश्यकता है जो एक निर्देशिका के भीतर सभी फ़ाइलों को ढूंढना चाहिए और प्रत्येक फ़ाइल के लिए एक समानांतर कार्य शुरू करना चाहिए।

क्या घोषणात्मक पाइपलाइनों का उपयोग करके इसे प्राप्त करना संभव है?

pipeline {
    agent any
    stages {
        stage("test") {
            steps {
                dir ("file_path") {
                    // find all files with complete path
                    parallel (
                        // execute parallel tasks for each file found.
                        // this must be dynamic
                        }
                    }
                }
            }
        }
    }
}

Comments

अगर मैं कई चरणों को अनुक्रमिक रूप से चलाना चाहता हूं और समानांतर नहीं तो मैं कैसे कर सकता हूं?

— फ्रैंक एस्कोबार

ज़रूर, लेकिन इस तरह से आप समानांतर कार्यों को गतिशील रूप से उत्पन्न नहीं कर सकते हैं, उदाहरण के लिए, रिपॉजिटरी पर कुछ फ़ाइलों के आधार पर।

— राउल सालिनास-मोंटेगुडो

Answer 1

निम्नलिखित कोड के साथ इसे हल करने में कामयाब:

pipeline {
    agent { label "master"}
    stages {
        stage('1') {
            steps {
                script {
                    def tests = [:]
                    for (f in findFiles(glob: '**/html/*.html')) {
                        tests["${f}"] = {
                            node {
                                stage("${f}") {
                                    echo '${f}'
                                }
                            }
                        }
                    }
                    parallel tests
                }
            }
        }       
    }
}

Comments

कृपया आधिकारिक पाइपलाइन के उदाहरण भी देखें - jenkins.io/doc/pipeline/examples/#parallel-multiple-nodes

— phedoreanu

@phedoreanu मैं कथात्मक पाइप लाइन का उपयोग कर रहा ...

— thclpr

@phedoreanu मैंने आपके संपादन को अस्वीकार कर दिया है, संपादन कोड के अच्छे कारण होने चाहिए, आपकी टिप्पणी मेरे लिए पर्याप्त नहीं है कि मैं इस उत्तर को इस तरह से संपादित करूं जो एक आत्म समाधान था। मुझे लगता है कि आपको इस संपादन को करने से पहले उत्तर लेखक से इस विषय पर चर्चा करने के लिए टिप्पणी करनी चाहिए थी।

— तैंसीबाई

@phedoreanu मुझे लगता है कि आपके पास एक बेहतर व्युत्पन्न कार्य है, तो कृपया अपना जवाब लिखें और बताएं कि इसके बजाय यह बेहतर क्यों है (त्रुटि हैंडलिंग, टेम्पलेट आदि में)।

— तेन्सीबाई

नमस्ते, मैं कुछ असफल प्रयासों के बाद एक ही पता लगा। अभी मेरी एकमात्र समस्या यह है कि अगर मैं किसी कारण से नोड स्टेज के अंदर दो चरण {..} खंड डाल देता हूं तो वर्कफ़्लो स्टेज चार्ट और ब्लू ओशन भ्रमित हो जाते हैं। उदाहरण के लिए वर्कफ़्लो स्टेज चार्ट में मुझे NaNy NaNd मिलता है और ब्लू ओशन में मुझे केवल पहला चरण मिलता है।

— Giuseppe

Answer 2

यह भी काम करता है, अगर आप Declarative Pipelineअंतरिक्ष के भीतर रहना चाहते हैं

// declare our vars outside the pipeline
def tests = [:]
def files

pipeline {
    agent any
    stages {
        stage('1') {
            steps {
                script {
                    // we've declared the variable, now we give it the values
                    files = findFiles(glob: '**/html/*.html')
                    // Loop through them
                    files.each { f ->
                        // add each object from the 'files' loop to the 'tests' array
                        tests[f] = {
                            // we're already in the script{} block, so do our advanced stuff here
                            echo f.toString()
                        }
                    }
                    // Still within the 'Script' block, run the parallel array object
                    parallel tests
                }
            }
        }       
    }
}

Comments

यदि आप प्रत्येक समानांतर कार्य को अलग-अलग जेनकींस नोड्स में आवंटित करना चाहते हैं, तो बस node {}इस तरह से एक ब्लॉक में क्रियाओं को लपेटें : tests[f] = { node { echo f.toString() } }

— प्राइमेटियस

Answer 3

यह करने के लिए स्क्रिप्टेड पाइपलाइनों का उपयोग करना बहुत आसान है क्योंकि आप मनमाने ढंग से ग्रूवी का उपयोग कर सकते हैं, लेकिन आपको अभी भी findFilesचरण का उपयोग करते हुए घोषित पाइपलाइनों के साथ ऐसा करने में सक्षम होना चाहिए ।

Answer 4

ज्ञात हो, कि डायनामिक बिल्ड स्टेप्स कुछ बिल्ड स्टेप्स में कुछ समस्या पैदा कर सकते हैं, जैसे जब आप दूसरी नौकरी कहते हैं:

pipeline {
    stages {
        stage('Test') {
            steps {
                script {
                    def tests = [:]
                    for (f in findFiles(glob: '**/html/*.html')) {
                        // Create temp variable, otherwise the name will be the last value of the for loop
                        def name = f
                        tests["${name}"] = {
                            build job: "${name}"
                        }
                    }
                    parallel tests
                }
            }
        }       
    }
}