Le paramètre doit être de type string

This reverts commit fad3f5fdcc.

Jenkinsfile

@@ -0,0 +1,231 @@
+@Library("cadoles@pipeline/packaging_pulp") _
+
+pipeline {
+
+    agent {
+        label 'docker'
+    }
+    
+    environment {
+        projectDir = "${env.project_name}_${env.BUILD_ID}" 
+    }
+
+    triggers {
+        // Execute pipeline every day at 7h30 to prepare docker images
+        cron('30 7 * * 1-5')
+    }
+
+    stages {
+
+        stage("Prepare build environment") {
+            when {
+                anyOf {
+                    triggeredBy cause: "UserIdCause", detail: "wpetit"
+                    triggeredBy 'TimerTrigger'
+                }   
+            }
+            steps {
+                script {
+                    tamarin.prepareEnvironment()
+                }
+            }
+        }
+
+        stage("Package project") {
+            when {
+                not {
+                    triggeredBy 'TimerTrigger'
+                }
+            }
+            steps {
+                script {
+                    stage("Clone repository") {
+                        checkout scm: 
+                            [
+                                $class: 'GitSCM', 
+                                userRemoteConfigs: [[url: env.repository_url, credentialsId: 'jenkins-forge-ssh']], 
+                                branches: [[name: env.ref]],
+                                extensions: [
+                                    [$class: 'RelativeTargetDirectory', relativeTargetDir: env.projectDir ],
+                                    [$class: 'CloneOption', noTags: false, shallow: false, depth: 0, reference: ''],
+                                    [$class: 'WipeWorkspace' ]
+                                ]
+                            ], 
+                            changelog: false, 
+                            poll: false
+                    }
+                    
+                    stage("Ensure packaging branch") {
+                        dir(env.projectDir) {
+                            sh 'git checkout "${packageBranch}"'
+                            def commitOrRef = env.commit ? env.commit : env.ref
+                            def branchesWithCommitOrRef = sh(script: "git branch --contains '${commitOrRef}'", returnStdout: true).split(' ')
+                            if (branchesWithCommitOrRef.findAll{env.packageBranch.contains(it)}.any{true}) {
+                                currentBuild.result = 'ABORTED'
+                                error("La référence `${env.ref}` ne fait pas partie de la branche `${env.packageBranch}` !")
+                            }
+                        }
+                    }
+
+                    stage("Check [ci skip] in tag message") {
+                        dir(env.projectDir) {
+                            sh 'git checkout "${packageBranch}"'
+                            def commitTags = sh(script: 'git describe --exact-match --abbrev=0', returnStdout: true).split(' ')
+                            for (tag in commitTags) {
+                                tag = tag.trim()
+                                def tagMessage = sh(script: "git tag --format='%(subject)' -l '${tag}'", returnStdout: true).trim()
+                                println("Tag '${tag}' message is: '${tagMessage}'")
+                                if (tagMessage.contains('[ci skip]')) {
+                                    currentBuild.result = 'ABORTED'
+                                    error("Le message du tag '${tag}' contient le marqueur '[ci-skip]' !")
+                                }
+                            }
+                        }
+                    }
+                    
+                    stage("Checkout ref") {
+                        dir(env.projectDir) {
+                            sh """
+                            git checkout ${env.ref}
+                            """
+                        }
+                    }
+                
+                    stage("Build package") {
+                        dir(env.projectDir) {  
+                            // On construit les paquets à partir des informations
+                            // de contexte provenant de CPKG et du webhook
+                            def result = tamarin.buildPackageWithCPKG(
+                                env.packageProfile ? env.packageProfile : "debian",
+                                env.packageArch ? env.packageArch : "",
+                                env.packageBranch ? env.packageBranch : "",
+                                env.baseImage ? env.baseImage : ""
+                            )
+                            
+                            // On publie chacun des paquets construits
+			    def splittedTag = env.ref.split('/')
+			    def repositoryName = "${splittedTag[2]} ${splittedTag[1]}"
+			    def distributionName = repositoryName
+			    def basePath = repositoryName.replace(' ', '-')
+			    def product = splittedTag[2].split('-')[0]
+			    def contentGuardMapping = ['mse': 'mse_contentguard']
+			    def signingServiceMapping = ['mse': 'sign_deb_release']
+                            def credentials = 'jenkins-pulp-api-client'
+                            def repositoryHREF = pulp.getRepositoryHREF(credentials, repositoryName)
+                            def exportTasks = pulp.exportPackages(credentials, result.packages)
+                            def pulpPackages = []
+                            exportTasks.each {
+                            def created_resources = pulp.waitForTaskCompletion(credentials, it)
+                            for (created_resource in created_resources) {
+                                pulpPackages << created_resource
+                            }
+                            }
+                            pulp.addToRepository(credentials, pulpPackages, repositoryHREF)
+                           // def publicationHREF = pulp.publishRepository(credentials, repositoryHREF, signingServiceMapping.get(product))
+                            def publicationHREF = pulp.publishRepository(credentials, repositoryHREF, 'sign_deb_release')
+                            def distributionHREF = pulp.distributePublication(credentials, publicationHREF[0], distributionName, basePath, contentGuardMapping.get(product))
+                            def distributionURL = pulp.getDistributionURL(credentials, distributionHREF[0])
+
+                            // On liste l'ensemble des paquets construits
+                            def publishedPackages = result.packages.collect { p ->
+                                    def file = new File(p)
+                                    return "- Paquet `${file.getName()}`, Dépôt `${result.env}`, Distribution `${result.distrib}`, URL `${distributionURL}`"
+                            }
+                            
+                            // On notifie le canal Rocket.Chat de la publication des paquets
+                            rocketSend (
+                                avatar: 'https://jenkins.cadol.es/static/b5f67753/images/headshot.png',
+                                message: """
+                                Les paquets suivants ont été publiés pour le projet ${env.project_name}:
+                                
+                                ${publishedPackages.join('\n')}
+                        
+                                [Visualiser le job](${env.RUN_DISPLAY_URL})
+                                
+                                @${env.sender_login}
+                                """.stripIndent(),
+                                rawMessage: true,
+                                attachments: lolops.getRandomDeliveryAttachment()
+                            )
+
+                            if (env.testPackageInstall != 'yes') {
+                                println "Test d'intallation des paquets désactivé."
+                                return
+                            }
+                            
+                            // On essaye de trouver un template de VM compatible
+                            // avec la distribution cible de la construction
+                            def vmTemplate = findMatchingVMTemplate(result.distrib)
+                            if (vmTemplate == null) {
+                                println "Aucun template de VM n'a été trouvé correspondant à la distribution `${result.distrib}`."
+                                return
+                            }
+
+                            // Pour chaque paquets construits...
+                            result.packages.each { p ->
+                                def packageFullName = new File(p).getName()
+                                def packageRepository = result.distrib.split('-')[1] + '-' + result.env
+                                def packageNameParts = packageFullName.split('_')
+                                def packageName = packageNameParts[0]
+                                def packageVersion = packageNameParts[1]
+
+                                stage("Test package '${packageName}' installation") {
+                                build job: 'Test de paquet Debian', wait: false, parameters: [
+                                    [$class: 'StringParameterValue', name: 'packageName', value: packageName], 
+                                    [$class: 'StringParameterValue', name: 'packageVersion', value: packageVersion],
+                                    [$class: 'StringParameterValue', name: 'packageRepository', value: packageRepository],
+                                    [$class: 'StringParameterValue', name: 'vmTemplate', value: vmTemplate]
+                                ]
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            post {
+                always {
+                    sh "rm -rf '${env.projectDir}'"
+                }
+            }
+        }
+
+    }
+    
+   
+}
+
+// Cette fonction fait un simple "mapping"
+// entre les distributions cibles des paquets et
+// les templates de VM disponibles sur l'OpenNebula
+def findMatchingVMTemplate(String distrib) {
+    def vmTemplatesMap = [
+        'eole-2.7.0': 'eolebase-2.7.0-cadoles',
+        'eole-2.6.2': 'eolebase-2.6.2-cadoles'
+    ]
+    return vmTemplatesMap.get(distrib, null)
+}
+
+def waitForPackages(String tagRef, buildResults) {
+    def packageVersion = tagRef.split('/')[3];
+    def packageDistrib = env.packageBranch.split('/')[2];
+        
+    buildResults.each { r ->
+        def distrib = "${packageDistrib}-${r.env}"
+
+        r.packages.each { p ->
+            def file = new File(p)
+            def fileNameParts = file.getName().take(file.getName().lastIndexOf('.')).split('_')
+            def packageName = fileNameParts[0]
+            def packageArch = fileNameParts[2]
+            
+            debian.waitForRepoPackage(packageName, [
+                baseURL: 'https://vulcain.cadoles.com',
+                distrib: distrib,
+                component: 'main',
+                type: 'binary',
+                arch: packageArch,
+                expectedVersion: packageVersion
+            ])
+        }
+    }
+}

vars/pulp.groovy

@@ -1,43 +1,88 @@
 import groovy.json.JsonOutput
 
+def getResourceHREF(
+    String credentials,
+    String resourceEndpoint,
+    String resourceName,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/${resourceEndpoint}", httpMode: 'GET', ignoreSslErrors: true, validResponseCodes: "200"
+    def jsonResponse = readJSON text: response.content
+    def resource = jsonResponse.results.find { it -> it.name == resourceName}
+    if (resource) {
+        return resource.pulp_href
+    }
+    return null
+}
+
+def waitForTaskCompletion(
+    String credentials,
+    String taskHREF,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def status = ''
+    def created_resources = []
+    while (status != 'completed') {
+        def response = httpRequest authentication: credentials, url: "https://${pulpHost}${taskHREF}", httpMode: 'GET', ignoreSslErrors: true, validResponseCodes: "200"
+        def jsonResponse = readJSON text: response.content
+        status = jsonResponse.state
+        if (status == 'completed') {
+            return jsonResponse.created_resources
+        } else if (!(status in ['running','waiting'])) {
+            break
+        }
+        sleep(10)
+    }
+    throw new Exception("Task failed:" + jsonResponse.error.description)
+}
+
 def exportPackages(
     String credentials,
     List packages = [],
-    String pulpHost = 'pulp.bbohard.lan'
+    String pulpHost = 'pulp.cadoles.com'
 ) {
     def exportTasks = []
-    packages.each {
+   packages.each {
-        def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/content/deb/packages/", httpMode: 'POST', ignoreSslErrors: true, multipartName: "file", timeout: 900, responseHandle: 'NONE', uploadFile: "${it}"
+        def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/content/deb/packages/", httpMode: 'POST', ignoreSslErrors: true, multipartName: "file", timeout: 900, uploadFile: "${it}", validResponseCodes: "202"
-        jsonResponse = readJSON text: response.content
+        def jsonResponse = readJSON text: response.content
-        println(jsonResponse)
         exportTasks << jsonResponse['task']
     }
     return exportTasks
 }
 
+def createRepository(
+	String credentials,
+    String name,
+    String pulpHost = 'pulp.cadoles.com'
+    ) {
+    def repositoryName = ["name": name]
+    def postBody = JsonOutput.toJson(repositoryName)
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/repositories/deb/apt/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "201"
+    def jsonResponse = readJSON text: response.content
+    return jsonResponse.pulp_href
+
+}
 def getRepositoryHREF(
     String credentials,
-    String repositoryLevel = 'dev',
+    String repository = 'Cadoles4MSE unstable'
-    String pulpHost = 'pulp.bbohard.lan'
     ) {
-    def repositoriesMapping = ['dev': 'Cadoles4MSE']
+    def repositoryHREF = getResourceHREF(credentials, 'repositories/deb/apt/', repository)
-    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/repositories/deb/apt/", httpMode: 'GET', ignoreSslErrors: true
+    if (repositoryHREF) {
-    def jsonResponse = readJSON text: response.content
+        return repositoryHREF
-    println(jsonResponse)
+    } else {
-    def repositories = jsonResponse.results
+        return createRepository(credentials, repository)
-    def repositoryHREF = repositories.find { it -> it['name'] == repositoriesMapping[repositoryLevel] }
+    }
-    return repositoryHREF.pulp_href
 }
 
 def addToRepository(
     String credentials,
     List packagesHREF,
     String repositoryHREF,
-    String pulpHost = 'pulp.bbohard.lan'
+    String pulpHost = 'pulp.cadoles.com'
 ) {
     def packagesHREFURL = ["add_content_units": packagesHREF.collect { "https://$pulpHost$it" }]
     def postBody = JsonOutput.toJson(packagesHREFURL)
-    def response = httpRequest authentication: credentials, url: "https://${pulpHost}${repositoryHREF}modify/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "100:599"
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}${repositoryHREF}modify/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "202"
     def jsonResponse = readJSON text: response.content
     return waitForTaskCompletion(credentials, jsonResponse.task)
 }
@@ -45,12 +90,19 @@ def addToRepository(
 def publishRepository(
     String credentials,
     String repositoryHREF,
-    String pulpHost = 'pulp.bbohard.lan'
+    String signing_service = null,
+    String pulpHost = 'pulp.cadoles.com'
 ) {
-    def postBody = JsonOutput.toJson(["repository": repositoryHREF, "simple": true])
+    def postContent = ["repository": repositoryHREF, "simple": true]
-    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/publications/deb/apt/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true
+    if (signing_service) {
+        def signingServiceHREF = getResourceHREF(credentials, 'signing-services/', signing_service)
+        if (signingServiceHREF) {
+            postContent.put("signing_service", "https://${pulpHost}${signingServiceHREF}")
+        }
+    }
+    def postBody = JsonOutput.toJson(postContent)
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/publications/deb/apt/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "202"
     def jsonResponse = readJSON text: response.content
-    println(jsonResponse)
     return waitForTaskCompletion(credentials, jsonResponse.task)
 }
 
@@ -59,26 +111,30 @@ def distributePublication(
     String publicationHREF,
     String distributionName,
     String basePath,
-    String pulpHost = 'pulp.bbohard.lan',
+    String contentGuard = null,
-    String contentGuard = null
+    String pulpHost = 'pulp.cadoles.com'
 ) {
-    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/distributions/deb/apt/", httpMode: 'GET', ignoreSslErrors: true
-    def jsonResponse = readJSON text: response.content
     def httpMode = ''
     def url = ''
-    def distribution = jsonResponse.results.find { it -> it.name == distributionName}
+    def distributionHREF = getResourceHREF(credentials, 'distributions/deb/apt/', distributionName)
-    if (distribution) {
+    if (distributionHREF) {
         httpMode = 'PUT'
-        url = distribution.pulp_href
+        url = distributionHREF
-
     } else {
         httpMode = 'POST'
         url = '/pulp/api/v3/distributions/deb/apt/'
     }
-    def postBody = JsonOutput.toJson(["publication": publicationHREF, "name": distributionName, "base_path": basePath, "content_guard": contentGuard])
+    def bodyContent = ["publication": publicationHREF, "name": distributionName, "base_path": basePath]
-    response = httpRequest authentication: credentials, url: "https://${pulpHost}${url}", httpMode: httpMode, requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "100:599"
+    if (contentGuard) {
+        def contentGuardHREF = getResourceHREF(credentials, 'contentguards/core/rbac/', contentGuard)
+        if (contentGuardHREF) {
+            bodyContent.put('content_guard', "https://${pulpHost}${contentGuardHREF}")
+        }
+    }
+    def postBody = JsonOutput.toJson(bodyContent)
+    response = httpRequest authentication: credentials, url: "https://${pulpHost}${url}", httpMode: httpMode, requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "202"
     jsonResponse = readJSON text: response.content
-    if (distribution) {
+    if (distributionHREF) {
         waitForTaskCompletion(credentials, jsonResponse.task)
         return [url]
     } else {
@@ -86,31 +142,12 @@ def distributePublication(
     }
 }
 
-def waitForTaskCompletion(
-    String credentials,
-    String taskHREF,
-    String pulpHost = 'pulp.bbohard.lan'
-) {
-    def status = ''
-    def created_resources = []
-    while (status != 'completed') {
-        def response = httpRequest authentication: credentials, url: "https://${pulpHost}${taskHREF}", httpMode: 'GET', ignoreSslErrors: true
-        def jsonResponse = readJSON text: response.content
-        status = jsonResponse.state
-        if (status == 'completed') {
-            created_resources = jsonResponse.created_resources
-        }
-        sleep(10)
-    }
-    return created_resources
-}
-
 def getDistributionURL(
     String credentials,
     String resourceHREF,
-    String pulpHost = 'pulp.bbohard.lan'
+    String pulpHost = 'pulp.cadoles.com'
 ) {
-    def response = httpRequest authentication: credentials, url: "https://${pulpHost}${resourceHREF}", httpMode: 'GET', ignoreSslErrors: true
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}${resourceHREF}", httpMode: 'GET', ignoreSslErrors: true, validResponseCodes: "200"
     def jsonResponse = readJSON text: response.content
     println(jsonResponse)
     return jsonResponse.base_url

vars/pulp.groovy.bak

@@ -0,0 +1,154 @@
+import groovy.json.JsonOutput
+
+def getResourceHREF(
+    String credentials,
+    String resourceEndpoint,
+    String resourceName,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/${resourceEndpoint}", httpMode: 'GET', ignoreSslErrors: true, validResponseCodes: "200"
+    def jsonResponse = readJSON text: response.content
+    def resource = jsonResponse.results.find { it -> it.name == resourceName}
+    if (resource) {
+        return resource.pulp_href
+    }
+    return null
+}
+
+def waitForTaskCompletion(
+    String credentials,
+    String taskHREF,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def status = ''
+    def created_resources = []
+    while (status != 'completed') {
+        def response = httpRequest authentication: credentials, url: "https://${pulpHost}${taskHREF}", httpMode: 'GET', ignoreSslErrors: true, validResponseCodes: "200"
+        def jsonResponse = readJSON text: response.content
+        status = jsonResponse.state
+        if (status == 'completed') {
+            return jsonResponse.created_resources
+        } else if (!(status in ['running','waiting'])) {
+            break
+        }
+        sleep(10)
+    }
+    throw new Exception("Task failed:" + jsonResponse.error.description)
+}
+
+def exportPackages(
+    String credentials,
+    List packages = [],
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def exportTasks = []
+   packages.each {
+        def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/content/deb/packages/", httpMode: 'POST', ignoreSslErrors: true, multipartName: "file", timeout: 900, uploadFile: "${it}", validResponseCodes: "202"
+        def jsonResponse = readJSON text: response.content
+        exportTasks << jsonResponse['task']
+    }
+    return exportTasks
+}
+
+def createRepository(
+	String credentials,
+    String name,
+    String pulpHost = 'pulp.cadoles.com'
+    ) {
+    def repositoryName = ["name": name]
+    def postBody = JsonOutput.toJson(repositoryName)
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/repositories/deb/apt/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "201"
+    def jsonResponse = readJSON text: response.content
+    return jsonResponse.pulp_href
+
+}
+def getRepositoryHREF(
+    String credentials,
+    String repository = 'Cadoles4MSE unstable'
+    ) {
+    def repositoryHREF = getResourceHREF(credentials, 'repositories/deb/apt/', repository)
+    if (repositoryHREF) {
+        return repositoryHREF
+    } else {
+        return createRepository(credentials, repository)
+    }
+}
+
+def addToRepository(
+    String credentials,
+    List packagesHREF,
+    String repositoryHREF,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def packagesHREFURL = ["add_content_units": packagesHREF.collect { "https://$pulpHost$it" }]
+    def postBody = JsonOutput.toJson(packagesHREFURL)
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}${repositoryHREF}modify/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "202"
+    def jsonResponse = readJSON text: response.content
+    return waitForTaskCompletion(credentials, jsonResponse.task)
+}
+
+def publishRepository(
+    String credentials,
+    String repositoryHREF,
+    String signing_service = null,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def postContent = ["repository": repositoryHREF, "simple": true]
+    if (signing_service) {
+        def signingServiceHREF = getResourceHREF(credentials, 'signing-services/', signing_service)
+        if (signingServiceHREF) {
+            postContent.put("signing_service", "https://${pulpHost}${signingServiceHREF}")
+        }
+    }
+    def postBody = JsonOutput.toJson(postContent)
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}/pulp/api/v3/publications/deb/apt/", httpMode: 'POST', requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "202"
+    def jsonResponse = readJSON text: response.content
+    return waitForTaskCompletion(credentials, jsonResponse.task)
+}
+
+def distributePublication(
+    String credentials,
+    String publicationHREF,
+    String distributionName,
+    String basePath,
+    String contentGuard = null,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def httpMode = ''
+    def url = ''
+    def distributionHREF = getResourceHREF(credentials, 'distributions/deb/apt/', distributionName)
+    if (distributionHREF) {
+        httpMode = 'PUT'
+        url = distributionHREF
+    } else {
+        httpMode = 'POST'
+        url = '/pulp/api/v3/distributions/deb/apt/'
+    }
+    def bodyContent = ["publication": publicationHREF, "name": distributionName, "base_path": basePath]
+    if (contentGuard) {
+        def contentGuardHREF = getResourceHREF(credentials, 'contentguards/core/rbac/', contentGuard)
+        if (contentGuardHREF) {
+            bodyContent.put('content_guard', "https://${pulpHost}${contentGuardHREF}")
+        }
+    }
+    def postBody = JsonOutput.toJson(bodyContent)
+    response = httpRequest authentication: credentials, url: "https://${pulpHost}${url}", httpMode: httpMode, requestBody: postBody, contentType: 'APPLICATION_JSON', ignoreSslErrors: true, validResponseCodes: "202"
+    jsonResponse = readJSON text: response.content
+    if (distributionHREF) {
+        waitForTaskCompletion(credentials, jsonResponse.task)
+        return [url]
+    } else {
+        return waitForTaskCompletion(credentials, jsonResponse.task)
+    }
+}
+
+def getDistributionURL(
+    String credentials,
+    String resourceHREF,
+    String pulpHost = 'pulp.cadoles.com'
+) {
+    def response = httpRequest authentication: credentials, url: "https://${pulpHost}${resourceHREF}", httpMode: 'GET', ignoreSslErrors: true, validResponseCodes: "200"
+    def jsonResponse = readJSON text: response.content
+    println(jsonResponse)
+    return jsonResponse.base_url
+}

vars/tamarin.groovy

@@ -7,46 +7,38 @@ def buildPackageWithCPKG(
     Boolean forceRebuild = false
 ) {
 
-    def builds = []
+    def result = [:]
 
     // Retrieve commit tags
-    def commitTags = sh(script: 'git describe --exact-match --abbrev=0', returnStdout: true).split(' ')
+    def commitTag = sh(script: 'git describe --exact-match --abbrev=0', returnStdout: true)
-    if (commitTags.length == 0) {
+    if (commitTag == '') {
         error 'No build build tags on last commit'
     }
 
-    // For each tags
+    // Split tag to retrieve context informations
-    for (tag in commitTags) {
+    def tagParts = commitTag.split('/')
+    def packageEnv = tagParts[1]
+    def packageDistrib = tagParts[2]
+    def packageVersion = tagParts[3]
 
-        // Split tag to retrieve context informations
+    // Create .tamarinrc file
-        def tagParts = tag.split('/')
+    def tamarinrc = """
-        def packageEnv = tagParts[1]
+    project_version=${packageVersion}
-        def packageDistrib = tagParts[2]
+    no_version_suffix=${ packageEnv == 'stable' || packageEnv == 'staging' ? 'yes' : 'no' }
-        def packageVersion = tagParts[3]
+    """.stripIndent()
+    writeFile file: '.tamarinrc', text: tamarinrc
 
-        // Create .tamarinrc file
+    sh "rm -rf ${destDir}/*"
-        def tamarinrc = """
-        project_version=${packageVersion}
-        no_version_suffix=${ packageEnv == 'stable' || packageEnv == 'staging' ? 'yes' : 'no' }
-        """.stripIndent()
-        writeFile file: '.tamarinrc', text: tamarinrc
-        
-        sh "rm -rf ${destDir}/*"
 
-        stage("Build ${packageEnv} package (version ${packageVersion}) for ${packageDistrib}") {
+    stage("Build ${packageEnv} package (version ${packageVersion}) for ${packageDistrib}") {
-            def result = [:]
+        result.put('tag', commitTag)
-            result.put('tag', tag)
+        result.put('env', packageEnv)
-            result.put('env', packageEnv)
+        result.put('version', packageVersion)
-            result.put('version', packageVersion)
+        result.put('distrib', packageDistrib)
-            result.put('distrib', packageDistrib)
+        def packages = buildPackage(packageProfile, packageArch, baseImage, destDir, forceRebuild)
-            def packages = buildPackage(packageProfile, packageArch, baseImage, destDir, forceRebuild)
+        result.put('packages', packages)
-            result.put('packages', packages)
-            builds << result
-        }
-        
     }
-
+    return result
-    return builds
 
 }
 
@@ -129,4 +121,4 @@ def buildDockerImage() {
         def imageTag = "${safeJobName}-${env.BUILD_ID}"
         return docker.build("tamarin:${imageTag}", ".")
     }
-}
+}