github.com/verrazzano/verrazzano@v1.7.1/ci/cron/Jenkinsfile

// Copyright (c) 2023, Oracle and/or its affiliates.
// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

import groovy.transform.Field

@Field
def GIT_COMMIT_TO_USE = ""
@Field
def LAST_CLEAN_PERIODIC_COMMIT = ""
@Field
def LAST_PERIODIC_RUN_COMMIT = ""
@Field
def VERRAZZANO_DEV_VERSION = ""
@Field
def periodicsUpToDate              = false // If true, indicates that the periodics already passed at the latest commit
@Field
def periodicsUpToDateFailed        = false // If true, indicates that the periodics already ran and failed at the latest commit

// Non Fields
def branchSpecificSchedule = getCronSchedule()

pipeline {
    options {
        timeout(time: 12, unit: 'HOURS')
        skipDefaultCheckout true
        disableConcurrentBuilds()
        timestamps ()
    }

    agent {
       docker {
            image "${RUNNER_DOCKER_IMAGE}"
            args "${RUNNER_DOCKER_ARGS}"
            registryUrl "${RUNNER_DOCKER_REGISTRY_URL}"
            registryCredentialsId 'ocir-pull-and-push-account'
            label "pipeline-job-large"
        }
    }

    triggers {
        cron(branchSpecificSchedule)
    }

    parameters {
            booleanParam (description: 'Skip test execution (for debugging)', name: 'DRY_RUN', defaultValue: false)
        }

    environment {
        OCI_CLI_AUTH = "instance_principal"
        OCI_OS_NAMESPACE = credentials('oci-os-namespace')

        CLEAN_BRANCH_NAME = "${env.BRANCH_NAME.replace("/", "%2F")}"

        STABLE_COMMIT_OS_LOCATION = "${CLEAN_BRANCH_NAME}/last-stable-commit.txt"
        LAST_PERIODIC_OS_LOCATION = "${CLEAN_BRANCH_NAME}/last-periodic-run-commit.txt"
        CLEAN_PERIODIC_OS_LOCATION = "${CLEAN_BRANCH_NAME}-last-clean-periodic-test/verrazzano_periodic-commit.txt"

        STABLE_COMMIT_LOCATION = "${WORKSPACE}/last-stable-commit.txt"
        LAST_PERIODIC_LOCATION = "${WORKSPACE}/last-periodic-run-commit.txt"
        CLEAN_PERIODIC_LOCATION = "${WORKSPACE}/last-clean-periodic-commit.txt"

        OCI_OS_REGION = "us-phoenix-1"
    }

    stages {
        stage('Check last clean periodic') {
            steps {
                sh """
                    oci --region us-phoenix-1 os object get --namespace ${OCI_OS_NAMESPACE} -bn ${OCI_OS_BUCKET} --name ${STABLE_COMMIT_OS_LOCATION} --file ${STABLE_COMMIT_LOCATION}
                """

                script {
                    // Check if there is already a clean periodic run at this commit already, and set the display name if
                    // it already is tested, or if doing a special run type (dry run, etc...)
                    preliminaryChecks()
                }
            }
        }

        stage('Clean workspace and checkout') {
            when {
                allOf {
                    expression { return runPipeline() }
                }
            }
                steps {
                    script {
                        cleanWorkspaceAndCheckout()
                    }
                }
        }

        stage ('Run Periodic Test Suite') {
            when {
                allOf {
                    expression { return runPipeline() }
                }
            }

            steps {
                script {
                    echo("Running periodics with commit ${GIT_COMMIT_TO_USE}")
                    build job: "/verrazzano-periodic-triggered-tests/${CLEAN_BRANCH_NAME}", wait: true
                }
            }
        }
    }
}

def cleanWorkspaceAndCheckout() {
    scmCheckout()
    def props = readProperties file: '.verrazzano-development-version'
    VERRAZZANO_DEV_VERSION = props['verrazzano-development-version']
    TIMESTAMP = sh(returnStdout: true, script: "date +%Y%m%d%H%M%S").trim()
    SHORT_COMMIT_HASH = sh(returnStdout: true, script: "git rev-parse --short=8 HEAD").trim()
    // update the description with some meaningful info
    currentBuild.description = SHORT_COMMIT_HASH + " : " + env.GIT_COMMIT
}

// Preliminary job checks and display updates
def preliminaryChecks() {
    // Get the last stable commit ID to pass the triggered tests
    def stableCommitProps = readProperties file: "${STABLE_COMMIT_LOCATION}"
    GIT_COMMIT_TO_USE = stableCommitProps['git-commit']
    echo "Last stable commit: ${GIT_COMMIT_TO_USE}"

    LAST_CLEAN_PERIODIC_COMMIT=getLastPeriodicRunCommit()
    echo "Last clean periodics commit: ${LAST_CLEAN_PERIODIC_COMMIT}"

    if (LAST_CLEAN_PERIODIC_COMMIT == GIT_COMMIT_TO_USE) {
        // If we had a clean periodic run and the commit hasn't changed
        periodicsUpToDate = true
    } else {
        // Check if we are still at the same commit previously run (if so we know it wasn't clean and it failed in some way)
        LAST_PERIODIC_RUN_COMMIT=getLastPeriodicRunCommit()
        if (LAST_PERIODIC_RUN_COMMIT != null && LAST_PERIODIC_RUN_COMMIT == GIT_COMMIT_TO_USE) {
            periodicsUpToDateFailed = true
        }
    }
}

// Returns the last run commit for the periodics, or null if the commit file does not exist yet.
// - fails the pipeline if any error other than 404 is returned by the OCI CLI
def getLastPeriodicRunCommit() {
    lastPeriodicCommitCommandOutput = sh (
        label: "Get last clean periodic commit ID",
        script: "oci --region us-phoenix-1 os object get --namespace ${OCI_OS_NAMESPACE} -bn ${OCI_OS_BUCKET} --name ${LAST_PERIODIC_OS_LOCATION} --file ${LAST_PERIODIC_LOCATION} 2>&1 || true",
        returnStdout: true
        ).trim()
    echo "command out: ${lastPeriodicCommitCommandOutput}"
    if (lastPeriodicCommitCommandOutput.length() > 0) {
        // We can get warning messages here as well even when the command succeeded, so be more precise on the checking
        if (lastPeriodicCommitCommandOutput =~ /(.*)status(.*)\d{1,4}(.*)/) {
            // If we think we had a status: NNN, we ignore 404 and fail for others
            assert lastPeriodicCommitCommandOutput =~ /(.*)status(.*)404(.*)/ : "An unexpected error occurred getting last periodic commit from ObjectStore: ${lastPeriodicCommitCommandOutput}"
        } else {
            // If we got here, we have some message that may or may not be an error. If we don't see the file, we assume it was an error
            sh """
                if [ ! -f ${LAST_PERIODIC_LOCATION} ]; then
                    echo "An unexpected error occurred getting last periodic run commit from ObjectStore: ${lastPeriodicCommitCommandOutput}"
                    exit 1
                fi
            """
        }
    }
    // Get the commit ID for the last known clean pass of the Periodic tests
    def lastPeriodicsCommitProps = readProperties file: "${LAST_PERIODIC_LOCATION}"
    return lastPeriodicsCommitProps['git-commit']
}

def scmCheckout() {
    echo "${NODE_LABELS}"
    echo "Specific GIT commit was not specified, use current head"
    def scmInfo = checkout([
        $class: 'GitSCM',
        branches: [[name: env.BRANCH_NAME]],
        doGenerateSubmoduleConfigurations: false,
        extensions: [],
        submoduleCfg: [],
        userRemoteConfigs: [[url: env.SCM_VERRAZZANO_GIT_URL]]])
    env.GIT_COMMIT = scmInfo.GIT_COMMIT
    env.GIT_BRANCH = scmInfo.GIT_BRANCH
    echo "SCM checkout of ${env.GIT_BRANCH} at ${env.GIT_COMMIT}"
}

// Checks all the conditions gating test execution and collates the result
def runPipeline() {
  return ! periodicsUpToDate && ! periodicsUpToDateFailed && ! params.DRY_RUN
}

def getCronSchedule() {
    if (env.BRANCH_NAME.equals("master")) {
        // scheduled for every 6 hours
        return "H */6 * * *"
    } else if (env.BRANCH_NAME.startsWith("release-")) {
        return "H */6 * * *"
    }
    return ""
}