Jenkinsfile

#!groovy
@Library(['github.com/cloudogu/ces-build-lib@1.62.0', 'github.com/cloudogu/zalenium-build-lib@v2.1.1'])
import com.cloudogu.ces.cesbuildlib.*

// Creating necessary git objects, object cannot be named 'git' as this conflicts with the method named 'git' from the library
gitWrapper = new Git(this, "cesmarvin")
gitWrapper.committerName = 'cesmarvin'
gitWrapper.committerEmail = 'cesmarvin@cloudogu.com'
gitflow = new GitFlow(this, gitWrapper)
github = new GitHub(this, gitWrapper)
changelog = new Changelog(this)

// Configuration of repository
repositoryOwner = "cloudogu"
repositoryName = "k8s-blueprint-lib"
project = "github.com/${repositoryOwner}/${repositoryName}"
goVersion = "1.25.3"

// Configuration of branches
productionReleaseBranch = "main"
developmentBranch = "develop"
currentBranch = "${env.BRANCH_NAME}"

registry = "registry.cloudogu.com"
registry_namespace = "k8s"

makefile = new Makefile(this)
k8sTargetDir = "target/k8s"
helmCRDChartDir = "${k8sTargetDir}/helm-crd"
helmCRDChartName = "k8s-blueprint-operator-crd"

node('docker') {
    timestamps {
        properties([
                // Keep only the last x builds to preserve space
                buildDiscarder(logRotator(numToKeepStr: '10')),
                // Don't run concurrent builds for a branch, because they use the same workspace directory
                disableConcurrentBuilds(),
        ])

        stage('Checkout') {
            checkout scm
            make 'clean'
        }

        withBuildDependencies {
            // no build stage as we have no main function in this lib

            stage('Unit Tests') {
                make 'unit-test'
                junit allowEmptyResults: true, testResults: 'target/unit-tests/*-tests.xml'
            }

            stage('Integration Test') {
                // If SKIP_DOCKER_TESTS is true, tests which need Docker containers are skipped
                make 'integration-test'
                junit allowEmptyResults: true, testResults: 'target/integration-tests/*-tests.xml'
            }

            stage("Review dog analysis") {
                stageStaticAnalysisReviewDog()
            }
        }

        stage('SonarQube') {
            stageStaticAnalysisSonarQube()
        }

        stageAutomaticRelease()
    }
}

void stageStaticAnalysisReviewDog() {
    def commitSha = sh(returnStdout: true, script: 'git rev-parse HEAD').trim()

    withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: 'sonarqube-gh', usernameVariable: 'USERNAME', passwordVariable: 'REVIEWDOG_GITHUB_API_TOKEN']]) {
        withEnv(["CI_PULL_REQUEST=${env.CHANGE_ID}", "CI_COMMIT=${commitSha}", "CI_REPO_OWNER=${repositoryOwner}", "CI_REPO_NAME=${repositoryName}"]) {
            make 'static-analysis'
        }
    }
}

void stageStaticAnalysisSonarQube() {
    def scannerHome = tool name: 'sonar-scanner', type: 'hudson.plugins.sonar.SonarRunnerInstallation'
    withSonarQubeEnv {
        gitWrapper.fetch()

        if (currentBranch == productionReleaseBranch) {
            echo "This branch has been detected as the production branch."
            sh "${scannerHome}/bin/sonar-scanner -Dsonar.branch.name=${env.BRANCH_NAME}"
        } else if (currentBranch == developmentBranch) {
            echo "This branch has been detected as the development branch."
            sh "${scannerHome}/bin/sonar-scanner -Dsonar.branch.name=${env.BRANCH_NAME}"
        } else if (env.CHANGE_TARGET) {
            echo "This branch has been detected as a pull request."
            sh "${scannerHome}/bin/sonar-scanner -Dsonar.pullrequest.key=${env.CHANGE_ID} -Dsonar.pullrequest.branch=${env.CHANGE_BRANCH} -Dsonar.pullrequest.base=${developmentBranch}"
        } else if (currentBranch.startsWith("feature/")) {
            echo "This branch has been detected as a feature branch."
            sh "${scannerHome}/bin/sonar-scanner -Dsonar.branch.name=${env.BRANCH_NAME}"
        } else {
            echo "This branch has been detected as a miscellaneous branch."
            sh "${scannerHome}/bin/sonar-scanner -Dsonar.branch.name=${env.BRANCH_NAME} "
        }
    }
    timeout(time: 2, unit: 'MINUTES') { // Needed when there is no webhook for example
        def qGate = waitForQualityGate()
        if (qGate.status != 'OK') {
            unstable("Pipeline unstable due to SonarQube quality gate failure")
        }
    }
}

void stageAutomaticRelease() {
    if (!gitflow.isReleaseBranch()) {
        return
    }

    String controllerVersion = makefile.getVersion()
    String releaseVersion = "v${controllerVersion}".toString()

    stage('Push Helm chart to Harbor') {
        new Docker(this)
                .image("golang:${goVersion}")
                .mountJenkinsUser()
                .inside("--volume ${WORKSPACE}:/go/src/${project} -w /go/src/${project}")
                        {
                            make 'crd-helm-package'
                            archiveArtifacts "${k8sTargetDir}/**/*"

                            // Push charts
                            withCredentials([usernamePassword(credentialsId: 'harborhelmchartpush', usernameVariable: 'HARBOR_USERNAME', passwordVariable: 'HARBOR_PASSWORD')]) {
                                sh ".bin/helm registry login ${registry} --username '${HARBOR_USERNAME}' --password '${HARBOR_PASSWORD}'"

                                sh ".bin/helm push ${helmCRDChartDir}/${helmCRDChartName}-${controllerVersion}.tgz oci://${registry}/${registry_namespace}/"
                            }
                        }
    }

    stage('Finish Release') {
        gitflow.finishRelease(releaseVersion, productionReleaseBranch)
    }

    stage('Add Github-Release') {
        releaseId = github.createReleaseWithChangelog(releaseVersion, changelog, productionReleaseBranch)
    }
}

void make(String makeArgs) {
    sh "make ${makeArgs}"
}

void withBuildDependencies(Closure closure) {
    new Docker(this)
        .image("golang:${goVersion}")
        .mountJenkinsUser()
        .inside("-e SKIP_SYSLOG_TESTS=true -e SKIP_DOCKER_TESTS=true --volume ${WORKSPACE}:/go/src/${project} -w /go/src/${project}") {
            closure.call()
        }
}