Première version du pipeline pour la compilation des supports de formation

resources/com/cadoles/tamarin/Dockerfile

@@ -1,17 +1,16 @@
-FROM alpine:3.12
+FROM alpine:latest
 
 ARG HTTP_PROXY=
 ARG HTTPS_PROXY=
 ARG http_proxy=
 ARG https_proxy=
 
-ARG TAMARIN_VERSION=develop
-
 RUN apk add --no-cache git docker python3 bash openssl curl
 
 RUN curl -k https://forge.cadoles.com/Cadoles/Jenkins/raw/branch/master/resources/com/cadoles/common/add-letsencrypt-ca.sh | bash
 
-RUN git clone http://forge.cadoles.com/Cadoles/Tamarin /tamarin\
+ARG TAMARIN_VERSION=feature/doc-compile
+RUN git clone https://forge.cadoles.com/Cadoles/Tamarin /tamarin\
   && cd /tamarin\
   && git checkout ${TAMARIN_VERSION}
 

resources/com/cadoles/tamarin/run-tamarin.sh

@@ -28,6 +28,6 @@ DEST_DIR=${TAMARIN_DEST_DIR:-dist}
 mkdir -p ${DEST_DIR}
 for f in /dist/*; do
     if [ -e "$f" ]; then
-        cp "$f" ./${DEST_DIR}
+        cp -r "$f" ./${DEST_DIR}
     fi
-done
+done

vars/compileDoc.groovy

@@ -0,0 +1,232 @@
+// Pipeline de construction des images Docker des services Zéphir
+def call() {
+    def buildTag
+
+    pipeline {
+
+        agent any
+
+        environment {
+            projectDir = "${env.project_name}_${env.BUILD_ID}"
+        }
+                        
+        triggers {   
+            // Execute pipeline every day at 7h30 to prepare docker images
+            cron('30 7 * * 1-5')
+        }
+    
+
+        parameters {
+            string(
+                name: 'targetUrl', 
+                description: 'URL cible pour le dépôt de fichier',
+                defaultValue: 'http://nextcloud.cadoles.com'
+            )
+            string(
+                name: 'targetFolder',
+                description: 'Répertoire racine cible partagé avec l’utilisateur',
+                defaultValue: 'documents_formations'
+            )
+            string(
+                name: 'credentialsId', 
+                description: "Identifiant du compte de type login/mot de passe",
+                defaultValue: 'jenkins-on-nextcloud'
+            )
+        }
+
+        stages {
+
+	        stage("Prepare build environment") {
+                when {
+                    anyOf {
+                       triggeredBy cause: "UserIdCause", detail: "bbohard"
+                       triggeredBy 'TimerTrigger'
+                    }   
+                }
+                steps {
+                    script {
+                        tamarin.prepareEnvironment()
+                    }
+                }
+            }   
+
+            stage("Build doc") {
+                when {
+                    not {
+                        triggeredBy 'TimerTrigger'
+                    }
+                }
+                steps {
+                    script {
+                        stage("Check tag") {
+                             buildTag = env.ref
+                             if (!buildTag.startsWith('build/')) {
+                                 currentBuild.result= 'ABORTED'
+                                 error("La référence `${buildTag}` n’est pas une demande de paquet valide.")
+                             }
+                        }
+                        stage("Clone repository") {
+                            checkout scm: 
+                                [
+                                    $class: 'GitSCM', 
+                                    userRemoteConfigs: [[url: env.repository_url, credentialsId: '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("Checkout ref") {
+                            dir(env.projectDir) {
+                                sh """
+                                git checkout ${env.ref}
+                                """
+                                return
+                            }
+                        }
+                        stage("Compile document") {
+                            dir(env.projectDir) {
+                                def date = new Date()
+                                def dateTag = date.format('yyyyMMdd')
+                                def splittedTag = env.ref.split('/')
+                                def docProfile = splittedTag[1]
+                                withCredentials([
+                                    usernamePassword(
+                                        credentialsId: params.credentialsId,
+                                        usernameVariable: "NEXTCLOUD_USER",
+                                        passwordVariable: "NEXTCLOUD_PASSWORD"
+                                    )
+                                ]) {
+                                    def rootFolder = "${params.targetUrl}/remote.php/dav/files/${NEXTCLOUD_USER}/${targetFolder}"
+                                    def projectName = env.project_name
+                                    def destFolder = "${projectName}/${docProfile}"
+                                    def result = tamarin.compileDoc()
+                                    println(result)
+                                    if(docProfile != 'draft') {
+                                        def publicFolder = "${destFolder}/latest/public"
+                                        def privateFolder = "${destFolder}/latest/private"
+                                        def archivePublicFolder = "${destFolder}/archive/${dateTag}/public"
+                                        def archivePrivateFolder = "${destFolder}/archive/${dateTag}/private"
+                                        createWebDAVFolder (params.credentialsId, rootFolder, publicFolder)
+                                        createWebDAVFolder (params.credentialsId, rootFolder, privateFolder)
+                                        createWebDAVFolder (params.credentialsId, rootFolder, archivePublicFolder)
+                                        createWebDAVFolder (params.credentialsId, rootFolder, archivePrivateFolder)
+                                        result.each { r ->
+                                            println(r)
+                                            splittedDest = r.split('/')
+                                            if(splittedDest[2] == 'public') {
+                                                def destPath = "${rootFolder}/${publicFolder}/${splittedDest[-1]}"
+                                                def destArchivePath = "${rootFolder}/${archivePublicFolder}/${splittedDest[-1]}"
+                                                copyWebDAVFile (params.credentialsId, r, destPath)
+                                                copyWebDAVFile (params.credentialsId, r, destArchivePath)
+                                            } else {
+                                                def destPath = "${rootFolder}/${privateFolder}/${splittedDest[-1]}"
+                                                def destArchivePath = "${rootFolder}/${archivePrivateFolder}/${splittedDest[-1]}"
+                                                copyWebDAVFile (params.credentialsId, r, destPath)
+                                                copyWebDAVFile (params.credentialsId, r, destArchivePath)
+                                            }
+                                        }
+                                    } else {
+                                        def draftPublicFolder = "${destFolder}/public"
+                                        def draftPrivateFolder = "${destFolder}/private"
+                                        createWebDAVFolder (params.credentialsId, rootFolder, draftPublicFolder)
+                                        createWebDAVFolder (params.credentialsId, rootFolder, draftPrivateFolder)
+                                        result.each { r ->
+                                            println(r)
+                                            splittedDest = r.split('/')
+                                            if(splittedDest[2] == 'public') {
+                                                def destPath = "${rootFolder}/${draftPublicFolder}/${splittedDest[-1]}"
+                                                copyWebDAVFile (params.credentialsId, r, destPath)
+                                            } else {
+                                                def destPath = "${rootFolder}/${draftPrivateFolder}/${splittedDest[-1]}"
+                                                copyWebDAVFile (params.credentialsId, r, destPath)
+                                            }
+                                        }
+                                    }
+                                }
+                                withCredentials([sshUserPrivateKey(credentialsId: 'jenkins', keyFileVariable: 'FORGE_SSH_KEY')]) {
+                                    writeFile(
+                                        file : "./sshForJenkins.sh",
+                                        text: '''
+                                        #!/bin/sh
+                                        ssh -i "${FORGE_SSH_KEY}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null "$@"
+                                        '''
+                                    )
+                                    sh(script: "chmod +x ./sshForJenkins.sh")
+                                    if (docProfile != 'draft') { 
+                                        withEnv(["GIT_SSH=./sshForJenkins.sh"]) {
+                                            sh """
+                                            git tag -am "paquet" release/v${dateTag}
+                                            """
+                                            sh """
+                                            git push --tags origin
+                                            """
+                                        }
+                                    }
+                                    withEnv(["GIT_SSH=./sshForJenkins.sh"]) {
+                                        sh """
+                                        git tag -d ${env.ref}
+                                        git push origin :${env.ref}
+                                        """
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+def createWebDAVFolder (
+    String creds,
+    String rootUrl,
+    String folder
+) {
+    withCredentials([
+        usernamePassword(
+        credentialsId: creds,
+        usernameVariable: "NEXTCLOUD_USER",
+        passwordVariable: "NEXTCLOUD_PASSWORD"
+        )
+    ]) {
+        println(rootUrl)
+        println(folder)
+        def splittedFolder = folder.split('/')
+        splittedFolder.eachWithIndex { subfolder, i ->
+            def newFolder = ""
+            if(i == 0) {
+                newFolder = subfolder
+            } else {
+                def prec = i - 1
+                def parentFolder = splittedFolder[0..prec].join('/')
+                newFolder = "${parentFolder}/${subfolder}"
+            }
+            println(newFolder)
+
+            sh 'curl -X MKCOL --user ${NEXTCLOUD_USER}:${NEXTCLOUD_PASSWORD} --basic ' + "${rootUrl}/${newFolder}"
+        }
+    }
+}
+
+def copyWebDAVFile (
+    String creds,
+    String newFile,
+    String destUrl
+) {
+    withCredentials([
+        usernamePassword(
+        credentialsId: creds,
+        usernameVariable: "NEXTCLOUD_USER",
+        passwordVariable: "NEXTCLOUD_PASSWORD"
+        )
+    ]) {
+
+        sh "curl -T ${newFile}" + ' --user ${NEXTCLOUD_USER}:${NEXTCLOUD_PASSWORD} --basic ' + destUrl
+    }
+}

vars/tamarin.groovy

@@ -67,6 +67,7 @@ def buildPackage(
     
     stage("Run Tamarin") {
         def dockerArgs = """
+	    -u 0
         -v /var/run/docker.sock:/var/run/docker.sock
         ${forceRebuild ? '-e TAMARIN_FORCE_REBUILD=1' : ''}
         ${packageArch ? '-e TAMARIN_PACKAGE_ARCH='+packageArch : ''}
@@ -89,6 +90,42 @@ def buildPackage(
     
 }
 
+def compileDoc(
+    String packageProfile = "doc-compiler", 
+    String destDir = "./packages",
+    Boolean forceRebuild = false
+    ) {
+    
+    def tamarinImage
+    def packages = []
+    
+    stage("Create Tamarin environment") {
+        tamarinImage = buildDockerImage()
+    }   
+    
+    stage("Run Tamarin") {
+        def dockerArgs = """
+    	-u 0
+        -v /var/run/docker.sock:/var/run/docker.sock
+        ${forceRebuild ? '-e TAMARIN_FORCE_REBUILD=1' : ''}
+        ${packageProfile ? '-e TAMARIN_PROFILE='+packageProfile : ''}
+        -e TAMARIN_DEST_DIR=${destDir}
+        """.stripIndent()
+
+        tamarinImage.inside(dockerArgs) {
+            sh 'run-tamarin'
+        }
+
+        packages = sh(script: "find '${destDir}' -type f -name *.pdf", returnStdout: true)
+            .split('\n')
+            .collect { return it.trim() }
+            .findAll { it != '' }
+    }
+    println(packages)
+    return packages
+    
+}
+
 def prepareEnvironment(
     String packageProfile = "debian",
     String baseImage = ""
@@ -101,6 +138,7 @@ def prepareEnvironment(
     
     stage("Prepare Tamarin") {
         def dockerArgs = """
+        -u 0
         -v /var/run/docker.sock:/var/run/docker.sock
         ${baseImage ? '-e TAMARIN_BASE_IMAGE='+baseImage : ''}
         ${packageProfile ? '-e TAMARIN_PROFILE='+packageProfile : ''}
@@ -129,4 +167,4 @@ def buildDockerImage() {
         def imageTag = "${safeJobName}-${env.BUILD_ID}"
         return docker.build("tamarin:${imageTag}", ".")
     }
-}
+}