Jenkinsfile

pipeline {
    agent {
        node {
            label 'ozgcloud-jenkins-build-agent-jdk21'
        }
    }

    environment {
        JENKINS_URL = "https://jenkins.infra.ozg-cloud.systems/job/codeSH_user-manager/job/${env.BRANCH_NAME}/${env.BUILD_NUMBER}/"
        RELEASE_REGEX = /\d+.\d+.\d+/
        SNAPSHOT_REGEX = /\d+.\d+.\d+-SNAPSHOT/
        FAILED_STAGE = ""
        SH_SUCCESS_STATUS_CODE = 0

        //The container runtime (e.g. docker) that is used to do an image based build. If this is set then a container build is always done.
        QUARKUS_NATIVE_CONTAINER_RUNTIME = "docker"
        QUARKUS_CONTAINER_IMAGE_NAME = "user-manager"
        QUARKUS_CONTAINER_IMAGE_TAG = "build-latest"
    }

    options {
        timeout(time: 1, unit: 'HOURS')
        disableConcurrentBuilds()
        buildDiscarder(logRotator(numToKeepStr: '5'))
    }

    stages {
        stage('Check Version') {
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME
                    def rootVersion = getPomVersion('pom.xml')

                    if(env.BRANCH_NAME == 'release'){
                        if ( !(rootVersion ==~ RELEASE_REGEX)) {
                            error("Keine Release Version für Branch ${env.BRANCH_NAME}.")
                        }
                    } else {
                        if ( !(rootVersion ==~ SNAPSHOT_REGEX) ) {
                            error("Keine Snapshot Version für Branch ${env.BRANCH_NAME}.")
                        }
                    }
                }
            }
        }
       stage('Set Version') {
          when {
            not {
                anyOf {
                    branch 'main'
                    branch 'release'
                }
            }
          }
          steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME
                    JAR_TAG = getPomVersion('pom.xml').replace("SNAPSHOT", "${env.BRANCH_NAME}-SNAPSHOT")
                }
                configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                    sh "mvn -s $MAVEN_SETTINGS versions:set -DnewVersion=${JAR_TAG} -DprocessAllModules=true"
                    
                }
          }
        }   
        stage('Build and deploy UserManager parent pom') {
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME
                }

                configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                    sh 'mvn -N -s $MAVEN_SETTINGS clean deploy -Dmaven.wagon.http.retryHandler.count=3'
                    
                }
            }
        }

        stage('Build and deploy UserManager GRPC') {
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME
                }

                configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                    sh 'mvn -pl user-manager-interface -s $MAVEN_SETTINGS clean deploy -Dmaven.wagon.http.retryHandler.count=3'
                }
            }
        }

        stage('Build and deploy UserManager') {
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME

                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        sh 'mvn -pl user-manager-server -s $MAVEN_SETTINGS clean deploy -Dmaven.wagon.http.retryHandler.count=3'
                        junit testResults: '**/target/surefire-reports/*.xml', skipPublishingChecks: true
                    }
                }
            }
        }

        stage('Build native container image') {
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME

                    withCredentials([usernamePassword(credentialsId: 'jenkins-nexus-login', usernameVariable: 'USER', passwordVariable: 'PASSWORD')]) {
                        configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                            sh 'mvn -pl user-manager-server -s $MAVEN_SETTINGS clean verify -Pnative -Dquarkus.container-image.registry=docker.ozg-sh.de -Dquarkus.container-image.username=${USER} -Dquarkus.container-image.password=${PASSWORD} -Dquarkus.container-image.push=true -Dquarkus.container-image.build=true -Dquarkus.native.remote-container-build=true -Dmaven.wagon.http.retryHandler.count=3'
                        }
                    }
                }
            }
        }

        stage('Revert Version') {
              steps {
                    script {
                        FAILED_STAGE=env.STAGE_NAME
                    }
                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        sh 'mvn -s $MAVEN_SETTINGS versions:revert'

                    }
              }
        }

        stage ('Deploy SBOM to DependencyTrack') {
            steps {
              script {
                IMAGE_TAG = buildVersionName()
                
                configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                    withCredentials([string(credentialsId: 'dependency-track-api-key', variable: 'API_KEY')]) {

                        dir('user-manager-server') {

                            catchError(buildResult: 'UNSTABLE', stageResult: 'FAILURE') {
                                sh "mvn  --no-transfer-progress -s $MAVEN_SETTINGS io.github.pmckeown:dependency-track-maven-plugin:upload-bom -Ddependency-track.apiKey=$API_KEY -Ddependency-track.projectVersion=${IMAGE_TAG} -Ddependency-track.dependencyTrackBaseUrl=https://dependency-track.ozg-sh.de"
                            }
                        }
                    }
                }
              }
            }
        }


        stage('Sonar Checks') {
            when {
                branch 'main'
            }
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME

                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        dir('user-manager-server') {
                            try {
                                withSonarQubeEnv('sonarqube-ozg-sh'){
                                    sh "mvn -s $MAVEN_SETTINGS package sonar:sonar -Dsonar.coverage.jacoco.xmlReportPaths=${env.WORKSPACE}/user-manager-server/target/jacoco-report/jacoco.xml"
                                }
                            } catch (Exception e) {
                                unstable("SonarQube failed")
                            }
                        }
                    }
                }
            }
        }

        stage('Tag and Push Docker image') {
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME
                    IMAGE_TAG = buildVersionName()

                    tagAndPushDockerImage(IMAGE_TAG)

                    if (isMainBranch()) {
                        tagAndPushDockerImage('snapshot-latest')
                    }
                    else if (env.BRANCH_NAME == 'release') {
                        tagAndPushDockerImage('latest')
                    }
                }
            }
        }

        stage('Test, build and deploy Helm Chart') {
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME
                    HELM_CHART_VERSION = buildVersionName()

                    sh "./run_helm_test.sh"
                    
                    dir('src/main/helm') {
    
                        sh "helm package --version=${HELM_CHART_VERSION} ."

                        deployHelmChart(HELM_CHART_VERSION)
                    }
                }
            }
        }

        stage('Rollout Dev UserManager') {
            when {
                branch 'main'
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    cloneGitopsRepo()

                    setNewDevUserManagerVersion()

                    pushDevGitopsRepo()
                }
            }
        }

        stage('Trigger Test rollout') {
            when {
                branch 'release'
            }

            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    cloneGitopsRepo()

                    setNewTestUserManagerVersion()

                    pushTestGitopsRepo()
                }
            }
        }


        stage('march build image') {
            when {
                branch 'main'
            }
            steps {
                script {
                    FAILED_STAGE=env.STAGE_NAME

                    withCredentials([usernamePassword(credentialsId: 'jenkins-nexus-login', usernameVariable: 'USER', passwordVariable: 'PASSWORD')]) {
                        configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                            sh 'mvn -pl user-manager-server -s $MAVEN_SETTINGS clean verify \
                                       -Pnative -Dquarkus.container-image.registry=docker.ozg-sh.de \
                                       -Dquarkus.container-image.username=${USER} \
                                       -Dquarkus.container-image.password=${PASSWORD} \
                                       -Dquarkus.container-image.push=true \
                                       -Dquarkus.container-image.build=true \
                                       -Dquarkus.native.remote-container-build=true \
                                       -Dquarkus.native.additional-build-args=-march=compatibility \
                                       -Dmaven.wagon.http.retryHandler.count=3'
                        }
                    }
                }
            }
        }

        stage('march push image') {
            when {
                branch 'main'
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME
                    tagAndPushDockerImage('march-snapshot-latest')
                }
            }
        }
    }

    post {
        failure {
            script {
                if (isMainBranch() || env.BRANCH_NAME == 'release') {
                    sendFailureMessage()
                }
            }
        }
    }
}

Void deployHelmChart(String helmChartVersion) {
    withCredentials([usernamePassword(credentialsId: 'jenkins-nexus-login', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]){
        if (env.BRANCH_NAME == 'release') {
            result = sh script: '''curl -u $USERNAME:$PASSWORD https://nexus.ozg-sh.de/service/rest/v1/components?repository=ozg-base-apps -F file=@user-manager-'''+helmChartVersion+'''.tgz''', returnStdout: true
        }
        else {
            result = sh script: '''curl -u $USERNAME:$PASSWORD https://nexus.ozg-sh.de/service/rest/v1/components?repository=ozg-base-apps-snapshot -F file=@user-manager-'''+helmChartVersion+'''.tgz''', returnStdout: true
        }

        if (result != '') {
            error(result)
        }
    }
}

String validateBranchName(branchName) {
    int maxLength = 30
    if (branchName.length() > maxLength) {
        String originalBranchName = branchName
        branchName = branchName.substring(0, maxLength)
        echo "WARNING: Branch name '${originalBranchName}' exceeded ${maxLength} characters. " +
             "It has been truncated to '${branchName}' for deployment purposes."
    }
    return branchName
}

String buildVersionName() {
    if (env.BRANCH_NAME == 'release') {
        return getPomVersion('pom.xml')
    }
    return "${getPomVersion('pom.xml')}-${validateBranchName(env.BRANCH_NAME)}-${env.GIT_COMMIT.take(7)}".replaceAll("_", "-")
}

Void sendFailureMessage() {
    def room = ''
    def data = """{"msgtype":"m.text", \
                    "body":"UserManager: Build Failed. Stage: ${FAILED_STAGE} Build-ID: ${env.BUILD_NUMBER} Link: ${JENKINS_URL}", \
                    "format": "org.matrix.custom.html", \
                    "formatted_body":"UserManager: Build Failed. Stage: ${FAILED_STAGE} Build-ID: <a href='${JENKINS_URL}'>${env.BUILD_NUMBER}</a>"}"""

    if (isMainBranch()) {
        room = "!iQPAvQIiRwRpNOszjw:matrix.ozg-sh.de"
    }
    else if (env.BRANCH_NAME == 'release') {
        room = "!oWZpUGTFsxkJIYNfYg:matrix.ozg-sh.de"
    }

    sh "curl -XPOST -H 'authorization: Bearer ${getElementAccessToken()}' -d '${data}' https://matrix.ozg-sh.de/_matrix/client/v3/rooms/$room/send/m.room.message"
}

String getElementAccessToken() {
    withCredentials([string(credentialsId: 'element-login-json', variable: 'LOGIN_JSON')]) {
        return readJSON ( text: sh (script: '''curl -XPOST -d \"$LOGIN_JSON\" https://matrix.ozg-sh.de/_matrix/client/v3/login''', returnStdout: true)).access_token
    }
}

Void setNewDevUserManagerVersion() {
    setNewGitopsVersion('dev')
}

Void setNewTestUserManagerVersion() {
    setNewGitopsVersion('test')
}

Void setNewGitopsVersion(String environment) {
    dir("gitops") {
        def envFile = "${environment}/application/values/user-manager-values.yaml"

        def envVersions = readYaml file: envFile

        envVersions.user_manager.image.tag = IMAGE_TAG
        envVersions.user_manager.helm.version = HELM_CHART_VERSION

        writeYaml file: envFile, data: envVersions, overwrite: true
    }
}

Void configureGit() {
    final email = "jenkins@ozg-sh.de"
    final name = "jenkins"

    dir("gitops") {
        sh "git config user.email '${email}'"
        sh "git config user.name '${name}'"
    }
}

Void cloneGitopsRepo() {
    withCredentials([usernamePassword(credentialsId: 'jenkins-gitea-access-token', passwordVariable: 'TOKEN', usernameVariable: 'USER')]) {
        sh 'git clone https://${USER}:${TOKEN}@git.ozg-sh.de/ozgcloud-devops/gitops.git'
    }

    configureGit()
}

Void pushDevGitopsRepo(){
    pushNewGitopsVersion('dev')
}

Void pushTestGitopsRepo(){
    pushNewGitopsVersion('test')
}

Void pushNewGitopsVersion(String environment) {
    dir('gitops') {
        if (!hasUserManagerValuesFileChanged(environment)) {
            return
        }

        withCredentials([usernamePassword(credentialsId: 'jenkins-gitea-access-token', passwordVariable: 'TOKEN', usernameVariable: 'USER')]) {
            sh "git add ${environment}/application/values/user-manager-values.yaml"

            sh "git commit -m 'jenkins rollout ${environment} user-manager version ${IMAGE_TAG}'"
            sh 'git push https://${USER}:${TOKEN}@git.ozg-sh.de/ozgcloud-devops/gitops.git'
        }
    }
}

Boolean hasUserManagerValuesFileChanged(String environment) {
    return sh (script: "git status | grep '${environment}/application/values/user-manager-values.yaml'", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

String getPomVersion(String pomFile){
    def pom = readMavenPom file: pomFile

    return pom.version
}

Void tagAndPushDockerImage(String newTag) {
    withCredentials([usernamePassword(credentialsId: 'jenkins-nexus-login', usernameVariable: 'USER', passwordVariable: 'PASSWORD')]) {
        sh 'docker login docker.ozg-sh.de -u ${USER} -p ${PASSWORD}'
        sh "docker pull docker.ozg-sh.de/root/user-manager:build-latest"

        sh "docker tag docker.ozg-sh.de/root/user-manager:build-latest docker.ozg-sh.de/user-manager:${newTag}"
        sh "docker push docker.ozg-sh.de/user-manager:${newTag}"
    }
}

Boolean isMainBranch() {
    return env.BRANCH_NAME == 'main'
}