Utilitaires pour la création de pipeline Jenkins dans l’environnement Cadoles.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

197 lines
9.0KB

  1. @Library("cadoles") _
  2. pipeline {
  3. agent {
  4. label 'common'
  5. }
  6. environment {
  7. projectDir = "${env.project_name}_${env.BUILD_ID}"
  8. }
  9. triggers {
  10. // Execute pipeline every day at 7h30 to prepare docker images
  11. cron(env.BRANCH_NAME == 'develop' ? '30 7 * * 1-5' : '')
  12. }
  13. stages {
  14. stage("Prepare build environment") {
  15. when {
  16. anyOf {
  17. triggeredBy cause: "UserIdCause", detail: "wpetit"
  18. triggeredBy 'TimerTrigger'
  19. }
  20. }
  21. steps {
  22. script {
  23. tamarin.prepareEnvironment()
  24. }
  25. }
  26. }
  27. stage("Package project") {
  28. when {
  29. not {
  30. triggeredBy 'TimerTrigger'
  31. }
  32. }
  33. steps {
  34. script {
  35. stage("Clone repository") {
  36. checkout scm:
  37. [
  38. $class: 'GitSCM',
  39. userRemoteConfigs: [[url: env.repository_url, credentialsId: 'jenkins-forge-ssh']],
  40. branches: [[name: env.ref]],
  41. extensions: [
  42. [$class: 'RelativeTargetDirectory', relativeTargetDir: env.projectDir ],
  43. [$class: 'CloneOption', noTags: false, shallow: false, depth: 0, reference: ''],
  44. [$class: 'WipeWorkspace' ]
  45. ]
  46. ],
  47. changelog: false,
  48. poll: false
  49. }
  50. stage("Ensure packaging branch") {
  51. dir(env.projectDir) {
  52. sh 'git checkout "${packageBranch}"'
  53. def commitOrRef = env.commit ? env.commit : env.ref
  54. def branchesWithCommitOrRef = sh(script: "git branch --contains '${commitOrRef}'", returnStdout: true).split(' ')
  55. if (branchesWithCommitOrRef.findAll{env.packageBranch.contains(it)}.any{true}) {
  56. currentBuild.result = 'ABORTED'
  57. error("La référence `${env.ref}` ne fait pas partie de la branche `${env.packageBranch}` !")
  58. }
  59. }
  60. }
  61. stage("Check [ci skip] in tag message") {
  62. dir(env.projectDir) {
  63. sh 'git checkout "${packageBranch}"'
  64. def commitTags = sh(script: 'git describe --exact-match --abbrev=0', returnStdout: true).split(' ')
  65. for (tag in commitTags) {
  66. tag = tag.trim()
  67. def tagMessage = sh(script: "git tag --format='%(subject)' -l '${tag}'", returnStdout: true).trim()
  68. println("Tag '${tag}' message is: '${tagMessage}'")
  69. if (tagMessage.contains('[ci skip]')) {
  70. currentBuild.result = 'ABORTED'
  71. error("Le message du tag '${tag}' contient le marqueur '[ci-skip]' !")
  72. }
  73. }
  74. }
  75. }
  76. stage("Checkout ref") {
  77. dir(env.projectDir) {
  78. sh """
  79. git checkout ${env.ref}
  80. """
  81. }
  82. }
  83. stage("Build package") {
  84. dir(env.projectDir) {
  85. // On construit les paquets à partir des informations
  86. // de contexte provenant de CPKG et du webhook
  87. def result = tamarin.buildPackageWithCPKG(
  88. env.packageProfile ? env.packageProfile : "debian",
  89. env.packageArch ? env.packageArch : "",
  90. env.packageBranch ? env.packageBranch : "",
  91. env.baseImage ? env.baseImage : ""
  92. )
  93. // On publie chacun des paquets construits
  94. result.each { r ->
  95. vulcain.publish(
  96. r.packages,
  97. r.env,
  98. env.packageBranch
  99. )
  100. }
  101. // On liste l'ensemble des paquets construits
  102. def publishedPackages = result.collect { r ->
  103. return r.packages.collect { p ->
  104. def file = new File(p)
  105. return "- Paquet `${file.getName()}`, Dépôt `${r.env}`, Distribution `${r.distrib}`"
  106. }
  107. }.transpose().collectMany { it }
  108. // On notifie le canal Rocket.Chat de la publication des paquets
  109. rocketSend (
  110. avatar: 'https://jenkins.cadol.es/static/b5f67753/images/headshot.png',
  111. message: """
  112. Les paquets suivants ont été publiés pour le projet ${env.project_name}:
  113. ${publishedPackages.join('\n')}
  114. [Visualiser le job](${env.RUN_DISPLAY_URL})
  115. @${env.sender_login}
  116. """.stripIndent(),
  117. rawMessage: true,
  118. attachments: lolops.getRandomDeliveryAttachment()
  119. )
  120. if (env.testPackageInstall != 'yes') {
  121. println "Test d'intallation des paquets désactivé."
  122. return
  123. }
  124. // Pour chaque construction de paquets...
  125. result.each { r ->
  126. // On essaye de trouver un template de VM compatible
  127. // avec la distribution cible de la construction
  128. def vmTemplate = findMatchingVMTemplate(r.distrib)
  129. if (vmTemplate == null) {
  130. println "Aucun template de VM n'a été trouvé correspondant à la distribution `${r.distrib}`."
  131. return
  132. }
  133. // Pour chaque paquets construits...
  134. r.packages.each { p ->
  135. def packageFullName = new File(p).getName()
  136. def packageRepository = r.distrib.split('-')[1] + '-' + r.env
  137. def packageNameParts = packageFullName.split('_')
  138. def packageName = packageNameParts[0]
  139. def packageVersion = packageNameParts[1]
  140. stage("Test package '${packageName}' installation") {
  141. build job: 'Test de paquet Debian', wait: false, parameters: [
  142. [$class: 'StringParameterValue', name: 'packageName', value: packageName],
  143. [$class: 'StringParameterValue', name: 'packageVersion', value: packageVersion],
  144. [$class: 'StringParameterValue', name: 'packageRepository', value: packageRepository],
  145. [$class: 'StringParameterValue', name: 'vmTemplate', value: vmTemplate]
  146. ]
  147. }
  148. }
  149. }
  150. }
  151. }
  152. }
  153. }
  154. post {
  155. always {
  156. sh "rm -rf '${env.projectDir}'"
  157. }
  158. }
  159. }
  160. }
  161. }
  162. // Cette fonction fait un simple "mapping"
  163. // entre les distributions cibles des paquets et
  164. // les templates de VM disponibles sur l'OpenNebula
  165. def findMatchingVMTemplate(String distrib) {
  166. def vmTemplatesMap = [
  167. 'eole-2.7.0': 'eolebase-2.7.0-cadoles',
  168. 'eole-2.6.2': 'eolebase-2.6.2-cadoles'
  169. ]
  170. return vmTemplatesMap.get(distrib, null)
  171. }