Benjamin Bohard
6fa3cdf8c1
Some checks failed
Cadoles/Jenkins/pipeline/head There was a failure building this commit
232 lines
11 KiB
Groovy
232 lines
11 KiB
Groovy
@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
|
|
])
|
|
}
|
|
}
|
|
}
|