Skip to content
Snippets Groups Projects
Select Git revision
  • bc5fe5ced109b7c4214d148403898e0e2ecfa963
  • master default protected
  • add-frequency-to-form
  • dev protected
  • ckan-2.11.0
  • add-package-custom-fields
  • fix-adding-datasets-for-users-and-editors
  • add-auth-subroute
  • 71-migrate-custom-fields-to-ckanext-scheming
  • add-author-maintainer-information
  • fix-inline-flex-btns
  • fix-known-spatial-uri-validation
  • py3
  • 47-aktuelle-resource-einer-collection-wird-nicht-mehr-gefunden
  • 10-eingabe-der-dct-accrualperiodicity-in-weboberflache
  • v1.3
  • 2.5.3
  • 2.5.2
  • 2.5.1
  • 2.5.0
  • 2.4.7
  • 2.4.6
  • 2.4.5
  • 2.4.4
  • 2.4.3
  • 2.4.2
  • 2.4.1
  • 2.4.0
  • 2.3.1
  • 2.3.0
  • 2.2.0
  • 2.1.0
  • 2.0.0
  • 1.4.3
  • 1.4.2
  • 1.4.1
36 results

login_form.html

Blame
  • Jenkinsfile 14.61 KiB
    pipeline {
        agent {
           node {
               label 'ozgcloud-jenkins-build-agent-jdk21'
            }
        }
    
        environment {
            BLUE_OCEAN_URL = "https://jenkins.infra.ozg-cloud.systems/job/vorgang-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
        }
    
        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')
                        def serverVersion = getPomVersion('vorgang-manager-server/pom.xml')
                        def interfaceVersion = getPomVersion('vorgang-manager-interface/pom.xml')
    
                        if(isReleaseBranch()){
                            if ( !(rootVersion ==~ RELEASE_REGEX) || !(serverVersion ==~ RELEASE_REGEX) || !(interfaceVersion ==~ RELEASE_REGEX) ) {
                                error("Keine Release Version für Branch ${env.BRANCH_NAME}.")
                            }
                        } else {
                            if ( !(rootVersion ==~ SNAPSHOT_REGEX) || !(serverVersion ==~ SNAPSHOT_REGEX) || !(interfaceVersion ==~ SNAPSHOT_REGEX) ) {
                                error("Keine Snapshot Version für Branch ${env.BRANCH_NAME}.")
                            }
                        }
    
                        if( !(rootVersion == serverVersion && rootVersion == interfaceVersion )){
                            error("Versionen sind nicht identisch")                        
                        }
                    }
                }
            }
    
            stage('Set Version') {
              when {
                not {
                    anyOf {
                        branch 'master'
                        branch 'release'
                    }
                }
              }
              steps {
                    script {
                        FAILED_STAGE=env.STAGE_NAME
                        VORGANG_MANAGER_TAG = getPomVersion('pom.xml').replace("SNAPSHOT", "${env.BRANCH_NAME}-SNAPSHOT");
                        BESCHEID_MANAGER_TAG = getPomVersion('bescheid-manager/pom.xml').replace("SNAPSHOT", "${env.BRANCH_NAME}-SNAPSHOT")
                        
                        updateDependencyVersions(BESCHEID_MANAGER_TAG, VORGANG_MANAGER_TAG)
                    }
                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        sh "mvn -s $MAVEN_SETTINGS versions:set -DnewVersion=${VORGANG_MANAGER_TAG} -DprocessAllModules=true -X"
                        dir('bescheid-manager') {
                            sh "mvn -s $MAVEN_SETTINGS versions:set -DnewVersion=${BESCHEID_MANAGER_TAG} -X"
                        }
                    }
              }
            }
            
            stage('Build VorgangManager') {
              steps {
                    script {
                        FAILED_STAGE=env.STAGE_NAME
                    }
    
                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        sh 'mvn --no-transfer-progress -s $MAVEN_SETTINGS clean install -Dmaven.wagon.http.retryHandler.count=3 -DelasticTests.disabled=true'
                    }
                }
            }
            
            stage('Deploy to Nexus'){
                steps {
                    script {
                        FAILED_STAGE = env.STAGE_NAME
                    }
                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        sh 'mvn --no-transfer-progress -s $MAVEN_SETTINGS -DskipTests deploy -Dmaven.wagon.http.retryHandler.count=3'
                        
                    }
                }
            }
    
    	   stage('Build Docker image vorgang-manager') {
              steps {
                    script {
                        FAILED_STAGE=env.STAGE_NAME
                    }
    
                    configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                        dir('vorgang-manager-server') {
                            sh 'mvn --no-transfer-progress -s $MAVEN_SETTINGS spring-boot:build-image -DskipTests -Dmaven.wagon.http.retryHandler.count=3'
                        }
                        sh 'mvn -s $MAVEN_SETTINGS versions:revert'
                    }
               }
            }
    
            stage('Tag and Push Docker image vorgang-manager') {
                steps {
                    script {
                        FAILED_STAGE=env.STAGE_NAME
                        
                        IMAGE_TAG = generateImageTag('pom.xml')
    
                        tagAndPushDockerImage('vorgang-manager', IMAGE_TAG)
                        
                        if (env.BRANCH_NAME == 'master') {
                            tagAndPushDockerImage('vorgang-manager', 'snapshot-latest')
                            tagAndPushDockerImage('vorgang-manager', 'e2e-test')
                        }
                        else if (env.BRANCH_NAME == 'release') {
                            tagAndPushDockerImage('vorgang-manager', 'latest')
                        }
                    }
                }
            }
    
            stage('Test, build and deploy Helm Chart vorgang-manager') {
                steps {
                    script {
                        FAILED_STAGE=env.STAGE_NAME
                        HELM_CHART_VERSION = generateHelmChartVersion("pom.xml")
    
                        sh "./run_helm_test.sh"
    
                        dir('src/main/helm') {
    
                            sh "helm package --version=${HELM_CHART_VERSION} ."
    
                             deployHelmChart("vorgang-manager", HELM_CHART_VERSION)
                        }
                    }
                }
            }        
    
            stage('Trigger Dev rollout') {
                when {
                    branch 'master'
                }
                steps {
                    script {
                        FAILED_STAGE = env.STAGE_NAME
    
                        cloneGitopsRepo()
    
                        setNewVorgangManagerGitopsVersion("dev")
                        pushDevGitopsRepo()
                    }
                }
            }
            stage('Trigger Test rollout') {
                when {
                    branch 'release'
                }	
                	
                steps {	
                    script {	
                        FAILED_STAGE = env.STAGE_NAME
    
                        cloneGitopsRepo()
    
                        setNewVorgangManagerGitopsVersion("test")
    
                        pushTestGitopsRepo()
                    }
                }	
            }
            
            stage ('Deploy SBOM to DependencyTrack') {
                steps {
                    script {
                        IMAGE_TAG = generateImageTag('pom.xml')
    
                        configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                            withCredentials([string(credentialsId: 'dependency-track-api-key', variable: 'API_KEY')]) {
    
                                dir('vorgang-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 'master'
                }
            	steps {
            	    script {
                        FAILED_STAGE=env.STAGE_NAME
    
                      	configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
                       		dir('vorgang-manager-server') {
                            	try {
    	                            withSonarQubeEnv('sonarqube-ozg-sh'){
    	                                sh 'mvn -s $MAVEN_SETTINGS sonar:sonar'
    	                            }
    	                        } catch (Exception e) {
                                    unstable("SonarQube failed")
                                }
                            }
                    		
                    		dir('vorgang-manager-utils') {
                            	try {
    	                            withSonarQubeEnv('sonarqube-ozg-sh'){
    	                                sh 'mvn -s $MAVEN_SETTINGS sonar:sonar'
    	                            }
    	                        } catch (Exception e) {
                                    unstable("SonarQube failed")
                                }
                            }
                		}
                    }
                }
            }
        }
        
    
        post {
            always{
                junit testResults: '**/target/surefire-reports/*.xml', skipPublishingChecks: true
            }
            failure {
                script {
                    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME == 'release') {
                        sendFailureMessage()
                    }
                }
            }
        }
    }
    
    
    Boolean isReleaseBranch() {
        return env.BRANCH_NAME == 'release'
    }
    
    void deployHelmChart(String helmChartName, 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=@'''+helmChartName+'''-'''+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=@'''+helmChartName+'''-'''+helmChartVersion+'''.tgz''', returnStdout: true
            }
    
            if (result != '') {
                error(result)
            }
        }
    }
    
    String generateHelmChartVersion(String pomFile) {
        def chartVersion = getPomVersion(pomFile)
    
        if (env.BRANCH_NAME == 'master') {
            chartVersion += "-${env.GIT_COMMIT.take(7)}"
        }
        else if (env.BRANCH_NAME != 'release') {
            chartVersion += "-${env.BRANCH_NAME}"
        }
    
        return chartVersion.replaceAll("_", "-")
    }
    
    Void tagAndPushDockerImage(String imageName, 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 tag docker.ozg-sh.de/${imageName}:build-latest docker.ozg-sh.de/${imageName}:${newTag}"
            sh "docker push docker.ozg-sh.de/${imageName}:${newTag}"
        }
    }
    
    String getPomVersion(String pomFile){
        def pom = readMavenPom file: pomFile
    
        return pom.version
    }
    
    void updateDependencyVersions(String bescheidManagerSnapshotVersion, String vorgangManagerSnapshotVersion) {
        def vorgangManagerServerPom = readMavenPom file: 'vorgang-manager-server/pom.xml'
        if ( vorgangManagerServerPom.properties['bescheid-manager.version'] ==~ SNAPSHOT_REGEX ) {
            vorgangManagerServerPom.properties['bescheid-manager.version'] = bescheidManagerSnapshotVersion
            writeMavenPom model: vorgangManagerServerPom, file: 'vorgang-manager-server/pom.xml'
    	}
    	def bescheidManagerServerPom = readMavenPom file: 'bescheid-manager/pom.xml'
        if ( bescheidManagerServerPom.properties['vorgang-manager.version'] ==~ SNAPSHOT_REGEX ) {        
    		bescheidManagerServerPom.properties['vorgang-manager.version'] = vorgangManagerSnapshotVersion
            writeMavenPom model: bescheidManagerServerPom, file: 'bescheid-manager/pom.xml' 
        }
    }
    
    String generateImageTag(String pomFile) {
        def imageTag = "${env.BRANCH_NAME}-${getPomVersion(pomFile)}"
    
        if (env.BRANCH_NAME == 'master') {
            imageTag += "-${env.GIT_COMMIT.take(7)}"
        }
    
        return imageTag
    }
    
    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 setNewVorgangManagerGitopsVersion(String environment) {
        dir("gitops") {
            def envFile = "${environment}/application/values/vorgang-manager-values.yaml"
            def envVersions = readYaml file: envFile
    
            envVersions.vorgang_manager.image.tag = IMAGE_TAG
            envVersions.vorgang_manager.helm.version = HELM_CHART_VERSION
    
            writeYaml file: envFile, data: envVersions, overwrite: true
        }
    }
    
    Void pushDevGitopsRepo() {
        pushNewGitopsVersion('dev')
    }
    
    Void pushTestGitopsRepo() {
        pushNewGitopsVersion('test')
    }
    
    Void pushNewGitopsVersion(String environment) {
        dir('gitops') {
            if (!hasGitopsValuesFileChanged(environment)) {
                return
            }
    
            withCredentials([usernamePassword(credentialsId: 'jenkins-gitea-access-token', passwordVariable: 'TOKEN', usernameVariable: 'USER')]) {
                sh "git add ${environment}/application/values/*-values.yaml"
    
                sh "git commit -m 'jenkins rollout ${environment} vorgang-manager version ${IMAGE_TAG}'"
                sh 'git push https://${USER}:${TOKEN}@git.ozg-sh.de/ozgcloud-devops/gitops.git'
            }
        }
    }
    
    Boolean hasGitopsValuesFileChanged(String environment) {
        return sh (script: "git status | grep '${environment}/application/values/'", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
    }
    
    Void sendFailureMessage() {
        def room = ''
        def data = """{"msgtype":"m.text", \
                        "body":"VorgangManager: Build Failed. Stage: ${FAILED_STAGE} Build-ID: ${env.BUILD_NUMBER} Link: ${BLUE_OCEAN_URL}", \
                        "format": "org.matrix.custom.html", \
                        "formatted_body":"VorgangManager: Build Failed. Stage: ${FAILED_STAGE} Build-ID: <a href='${BLUE_OCEAN_URL}'>${env.BUILD_NUMBER}</a>"}"""
           
        if (env.BRANCH_NAME == 'master') {
            room = "!GjqhmouBtnDbwUkAjx: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
        }
    }