JenkinsfileBuildTrigger

#!groovy

def parseText(message) {
    if (!message) {
        return null
    }
    def parsed = readJSON text: message.replace("\n", "\\n")
    return parsed
}

timestamps {
    def libraries = ['upstream-fedora-pipeline': ['master', 'https://github.com/CentOS-PaaS-SIG/upstream-fedora-pipeline.git'],
                     'contra-lib'              : ['master', 'https://github.com/openshift/contra-lib.git']]

    libraries.each { name, repo ->
        library identifier: "${name}@${repo[0]}",
                retriever: modernSCM([$class: 'GitSCMSource',
                                      remote: repo[1]])

    }

    properties(
            [
                    buildDiscarder(logRotator(artifactDaysToKeepStr: '', artifactNumToKeepStr: '500', daysToKeepStr: '', numToKeepStr: '500')),
                    parameters(
                            [
                                    string(description: 'CI message', defaultValue: '{}', name: 'CI_MESSAGE')
                            ]
                    ),
                    pipelineTriggers(
                            [[$class: 'CIBuildTrigger',
                              noSquash: true,
                              providerData: [
                                  $class: 'RabbitMQSubscriberProviderData',
                                  name: 'FedoraMessaging',
                                  overrides: [
                                      topic: 'org.fedoraproject.prod.bodhi.update.status.testing.koji-build-group.build.complete',
                                      queue: 'osci-pipelines-queue-1'
                                  ]
                              ]
                            ]]
                    )
            ]
    )

    def TRIGGER_RETRY_COUNT = 3
    def stepName = null
    def validRelease = false

    node('master') {

        packagepipelineUtils.ciPipeline {
            try {
                stepName = 'upstream-fedora-pipeline-build-trigger'
                stage(stepName) {

                    packagepipelineUtils.handlePipelineStep(stepName: stepName, debug: true) {

                        print "CI_MESSAGE"
                        print CI_MESSAGE
                        parsedMsg = parseText(env.CI_MESSAGE)
                        packagepipelineUtils.setDefaultEnvVars()
                        env.fed_branch = parsedMsg['artifact']['release']
                        env.branch = parsedMsg['artifact']['release']
                        env.isScratch = false

                        if (env.branch =~ /f([0-9]+)$/) {
                            validRelease = true
                        }

                        def rawhide_release = packagepipelineUtils.getRawhideRelease()
                        if (env.fed_branch == "f${rawhide_release}") {
                            env.fed_branch = 'master'
                            env.branch = 'rawhide'
                        }

                    }

                }


                stepName = 'schedule build'
                stage(stepName) {
                    packagepipelineUtils.handlePipelineStep(stepName: stepName, debug: true) {
                        env.currentStage = stepName
                        if (validRelease) {
                            def builds = parsedMsg['artifact']['builds']
                            for (newbuild in builds) {

                                env.fed_repo = newbuild['component']
                                env.nvr = newbuild['nvr']
                                env.build_id = newbuild['id']
                                env.issuer = newbuild['issuer']
                                env.task_id = newbuild['task_id']

                                env.ADDITIONAL_TASK_IDS = ''
                                for (tmpbuild in builds) {
                                    if (tmpbuild['task_id'] != newbuild['task_id']) {
                                         env.ADDITIONAL_TASK_IDS += "${tmpbuild['task_id']} "
                                    }
                                }

                                testsExist = contraUtils.checkTests(env.fed_repo, env.fed_branch, 'classic')
                                if (testsExist) {
                                    currentBuild.displayName = "BUILD#: ${env.BUILD_NUMBER} - Release: ${env.branch} - Package: ${env.fed_repo}"

                                    // Send message org.centos.prod.ci.koji-build.test.queued on fedmsg
                                    messageFields = packagepipelineUtils.setMessageFields("queued", "koji-build", parsedMsg)
                                    contraUtils.sendMessage(messageFields['topic'], messageFields['properties'], messageFields['content'])

                                    retry(TRIGGER_RETRY_COUNT) {
                                            build job: "fedora-${env.branch}-build-pipeline",
                                                    parameters: [string(name: 'PROVIDED_KOJI_TASKID', value: env.task_id),
                                                                string(name: 'ADDITIONAL_TASK_IDS', value: env.ADDITIONAL_TASK_IDS),
                                                                string(name: 'CI_MESSAGE', value: env.CI_MESSAGE),
                                                                string(name: 'pipelineId', value: UUID.randomUUID().toString())],
                                                    wait: false
                                        }
                                } else {
                                    currentBuild.displayName = "Build#: ${env.BUILD_NUMBER} - Release: ${env.branch} - Package: ${env.fed_repo} - Skipped"
                                }

                            }
                        } else {
                            echo "INFO: Skipping unsupported release ${env.branch}"
                            currentBuild.displayName = "Build#: ${env.BUILD_NUMBER} - Release: ${env.branch} - Package: ${env.fed_repo} - Skipped"
                        }
                    }
                }
                currentBuild.result = 'SUCCESS'

            } catch (e) {
                currentBuild.result = 'FAILURE'
                throw e
            }
        }
    }
}