Jenkins/pipelines/debian-packaging.jenkinsfile

@Library("cadoles@redesign-tamarin") _

pipeline {

    agent {
        label 'common'
    }
    
    environment {
        projectDir = "${env.project_name}_${env.BUILD_ID}" 
    }

    stages {
      
        stage("Clone repository") {
            steps {
                checkout scm: 
                    [
                        $class: 'GitSCM', 
                        userRemoteConfigs: [[url: env.repository_url, credentialsId: 'forge-jenkins']], 
                        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") {
            steps {
                script {
                    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("Checkout ref") {
            steps {
                dir(env.projectDir) {
                    sh """
                    git checkout ${env.ref}
                    """
                }
            }
        }
    
        stage("Build package") {
            steps {
                script {
                    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
                        result.each { r ->
                            vulcain.publish(
                                r.packages,
                                r.env,
                                env.packageBranch
                            )
                        }
                        
                        // On liste l'ensemble des paquets construits
                        def publishedPackages = result.collect { r ->
                            return r.packages.collect { p ->
                                def file = new File(p)
                                return "- Paquet `${file.getName()}`, Dépôt `${r.env}`, Distribution `${r.distrib}`"
                            }
                        }.transpose().collectMany { it }
                        
                        // 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
                        )

                        if (env.testPackageInstall == 'no') {
                            println "Test d'intallation des paquets désactivé."
                            return
                        }
                        
                        // Pour chaque construction de paquets...
                        result.each { r ->

                            // On essaye de trouver un template de VM compatible
                            // avec la distribution cible de la construction
                            def vmTemplate = findMatchingVMTemplate(r.distrib)
                            if (vmTemplate == null) {
                                println "Aucun template de VM n'a été trouvé correspondant à la distribution `${r.distrib}`."
                                return
                            }

                            // Pour chaque paquets construits...
                            r.packages.each { p ->
                                def packageName = new File(p).getName()
                                stage("Test package '${packageName}' installation") {
                                    try {
                                        // On démarre une nouvelle VM et on lance l'installation du paquet publié
                                        testPackageInstallation(vmTemplate, r.distrib, r.env, packageName)
                                    } catch(e) {
                                        currentBuild.result = 'UNSTABLE'
                                        rocketSend (
                                            avatar: 'https://jenkins.cadol.es/static/b5f67753/images/headshot.png',
                                            message: """
                                            [Installation du paquet `${packageName}` échouée sur `${vmTemplate}`](${env.RUN_DISPLAY_URL})
                                            
                                            @${env.sender_login}
                                            """.stripIndent(),
                                            rawMessage: true
                                        )
                                        error("Installation du paquet `${packageName}` échouée.")
                                    }
                                }
                            }
                        }
                        
                    }
                }
            }
        }

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

// Cette fonction démarre une nouvelle VM, configure les dépôts tiers pour ajouter
// celui de Cadoles correspondant à la cible du paquet et tente d'installer celui ci.
def testPackageInstallation(String vmTemplate, String distrib, String env, String packageName) {
    def version = distrib.split('-')[1]
    def packageNameParts = packageName.split('_')
    nebula.runInNewVM([
        vmTemplate: vmTemplate,
        script: """
        set -xeo pipefail
        wget -qO - https://vulcain.cadoles.com/cadoles.gpg | apt-key add -
        echo 'deb https://vulcain.cadoles.com ${version}-${env} main' > /etc/apt/sources.list.d/${version}-${env}.list
        apt-get update -y
        apt-get install -y ${packageNameParts[0]}=${packageNameParts[1]}
        """
    ])
}