Jenkinsfile.multibranch

#!/bin/env groovy

@Library('cliqz-shared-library@v1.2') _

properties([
    // Allow only one job to run at a time
    [$class: 'JobRestrictionProperty'],
    disableConcurrentBuilds(),
])

currentBuild.description = ''

def isIntegrationBranch = env.BRANCH_NAME == 'master'

def matrix = [
    'react-native': [
        'config': 'react-native.json',
    ],
    'ghostery': [
        'config': 'ghostery.js',
    ],
    'cliqzs': [
        'config': 'experiments/cliqzs.json',
    ],
    'webextension': [
        'config': 'webextension.js',
    ],
    'cliqz-android': [
        'config': 'cliqz-android.js',
        'cert_credentials_id': '86407680-3a2a-42ea-9bd8-d42c0c75ed96',
        'cert_pass_credentials_id': 'cae4ee4b-bb2c-4aec-99b0-040919318d87',
    ],
    'worldcup': [
        'config': 'worldcup.js',
    ],
    /*
    'anolysis': [
        'config': 'experiments/anolysis.js',
    ],
    */
]

if (isIntegrationBranch) {
    matrix['browser'] = [
      'config': 'browser.js',
      'cert_credentials_id': '766bbf53-83c2-4917-a837-ee612afcbb87',
      'cert_pass_credentials_id': '9983e1f3-9c73-42e7-8036-3b34a592dd52',
    ]
    matrix['amo'] = [
      'config': 'amo.js',
      'cert_credentials_id': '766bbf53-83c2-4917-a837-ee612afcbb87',
      'cert_pass_credentials_id': '9983e1f3-9c73-42e7-8036-3b34a592dd52',
    ]
}

def baseImage
def codeImage
def triggeringCommitHash
def version

node('master') {

    stage('checkout') {
        checkout scm
        // TODO: use return value from checkout, when pipeline plugin will be updated
        triggeringCommitHash = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
    }

    stage('checkout xpi-sign') {
        // TODO: this repository does not have to be private
        checkout([
            $class: 'GitSCM',
            branches: [[name: '*/cliqz-ci']],
            doGenerateSubmoduleConfigurations: false,
            extensions: [[
                $class: 'RelativeTargetDirectory',
                relativeTargetDir: 'xpi-sign',
            ]],
            submoduleCfg: [],
            userRemoteConfigs: [[
                credentialsId: '41572f9c-06aa-46f0-9c3b-b7f4f78e9caa',
                url: 'git@github.com:cliqz/xpi-sign.git'
            ]],
        ])
    }

    def baseImageName = 'navigation-extension/base'
    def codeImageName = 'navigation-extension/code';

    stage('docker build base') {
        ansiColor('xterm') {
            baseImage = docker.build(
                baseImageName,
                '--build-arg UID=`id -u` --build-arg GID=`id -g` -f Dockerfile.publish .',
            )
        }
    }

    stage('docker build code') {
        writeFile file: 'Dockerfile.code', text: """
            FROM ${baseImageName}
            USER root
            ADD . /app/
            RUN chown jenkins:jenkins -R /app
            USER jenkins
        """

        codeImage = docker.build(
            codeImageName,
            '-f Dockerfile.code .',
        )
    }

    stage('get version') {
        codeImage.inside() {
            def environment = isIntegrationBranch ? 'development' : 'production'
            version = sh(returnStdout: true, script: "/app/fern.js version --environment ${environment}").trim()
        }
    }
}

def build(Map m) {
    def channel = m.channel
    def config = m.config
    def certCredentialsId = m.certCredentialsId  ? m.certCredentialsId : '766bbf53-83c2-4917-a837-ee612afcbb87'
    def certPassCredentialsId = m.certPassCredentialsId ? m.certPassCredentialsId : '9983e1f3-9c73-42e7-8036-3b34a592dd52'
    def getImage = m.getImage
    def getCommitId = m.getCommitId
    def getVersion = m.getVersion
    def getIsIntegrationBranch = m.getIsIntegrationBranch

    return {
        node('master') {
            getImage().inside() {
                def isIntegrationBranch = getIsIntegrationBranch();
                withEnv([
                    "CLIQZ_BETA=${isIntegrationBranch ? 'True' : 'False'}",
                    "CLIQZ_PRE_RELEASE=${isIntegrationBranch ? 'False' : 'True'}",
                    "CLIQZ_CHANNEL=${channel}",
                    "CLIQZ_CONFIG_PATH=./configs/${config}",
                    "GIT_COMMIT=${getCommitId()}",
                    "VERSION=${getVersion()}",
                ]) {
                    sh "cd /app && ./fern.js build --environment=production ${isIntegrationBranch ? '' : '--no-debug'}"

                    sh 'cd /app && ./fern.js pack'

                    withCredentials([
                        [
                            $class: 'UsernamePasswordMultiBinding',
                            credentialsId: '06ec4a34-9d01-46df-9ff8-64c79eda8b14',
                            passwordVariable: 'AWS_SECRET_ACCESS_KEY',
                            usernameVariable: 'AWS_ACCESS_KEY_ID',
                        ],
                        usernamePassword(
                            credentialsId: '774bccf1-ae66-41e1-9f2e-f8efb4bedc21',
                            passwordVariable: 'BALROG_PASSWORD',
                            usernameVariable: 'BALROG_ADMIN',
                        ),
                        file(
                            credentialsId: certCredentialsId,
                            variable: 'CLIQZ_CERT_PATH',
                        ),
                        file(
                            credentialsId: certPassCredentialsId,
                            variable: 'CLIQZ_CERT_PASS_PATH',
                        ),
                    ]) {
                        def signOutput = sh(
                            returnStdout: true,
                            script: 'cd /app && ./fern.js sign',
                        ).trim()

                        echo signOutput

                        def output = sh(
                            returnStdout: true,
                            script: 'cd /app && ./fern.js publish',
                        ).trim()

                        echo output

                        def urls = output.split('\n')

                        for (url in urls) {
                            currentBuild.description += "${url}\n"
                        }
                    }
                }
            }
        }
    }
}

def stepsForParallel = helpers.entries(matrix).collectEntries {
    [(it[0]): build(
        channel: it[0],
        config: it[1]['config'],
        certCredentialsId: it[1]['cert_credentials_id'],
        certPassCredentialsId: it[1]['cert_pass_credentials_id'],
        getImage: { codeImage },
        getCommitId: { triggeringCommitHash },
        getVersion: { version },
        getIsIntegrationBranch: { isIntegrationBranch },
    )]
}

stage('build and publish') {
    parallel stepsForParallel
}

stage('send email') {
    def bodytxt = '$PROJECT_NAME - Build # $BUILD_NUMBER'
    bodytxt += '\n\nCheck console output at ' + env.BUILD_URL + ' to view the results.'
    bodytxt += '\n\nArtifacts:\n\n'
    bodytxt += currentBuild.description
    bodytxt += '\n\n\n\n\n $CHANGES_SINCE_LAST_SUCCESS'
    bodytxt += '\n\n Don\' worry, be happy :-)'

    emailext(
        to: 'browser-core@cliqz.com',
        subject: '$PROJECT_NAME - Build # $BUILD_NUMBER',
        body: bodytxt,
    )
}

stage('update jira') {
    if (isIntegrationBranch) {
        withEnv(['JIRA_SITE=cliqztix']) {
            def issueIds = getIssueList(/EX-[0-9]+/)
            def transitionInput = [
                transition: [
                    id: '121',
                ],
            ]

            if (issueIds.size() > 0) {
                echo 'Detected JIRA tickets'
                echo issueIds.toString()
            } else {
                echo 'No JIRA tickets detected'
            }

            for (id in issueIds) {
                try {
                    def issue = jiraGetIssue idOrKey: id

                    if (issue.data.fields.status.name == "Resolved") {
                        jiraTransitionIssue idOrKey: id, input: transitionInput
                    }
                } catch (Error e) {
                    echo e
                }
            }
        }
    }
}

stage('upload docs') {
    if (isIntegrationBranch) {
        node('master') {
            codeImage.inside() {
                sh 'cd /app && npm run doc'

                withCredentials([[
                    $class: 'UsernamePasswordMultiBinding',
                    credentialsId: '06ec4a34-9d01-46df-9ff8-64c79eda8b14',
                    passwordVariable: 'AWS_SECRET_ACCESS_KEY',
                    usernameVariable: 'AWS_ACCESS_KEY_ID',
                ]]) {
                    def s3DocPath = 's3://internal.clyqz.com/docs/browser-core'

                    sh "cd /app/docs && aws s3 sync . $s3DocPath --delete"
                }
            }
        }
    }
}

@NonCPS
def getChangeString() {
    def MAX_MSG_LEN = 100
    def changeString = ""
    def changeLogSets = currentBuild.changeSets

    for (int i = 0; i < changeLogSets.size(); i++) {
        def entries = changeLogSets[i].items
        for (int j = 0; j < entries.length; j++) {
            def entry = entries[j]
            truncated_msg = entry.msg.take(MAX_MSG_LEN)
            changeString += " - ${truncated_msg} [${entry.author}]\n"
        }
    }
    if (!changeString) {
        changeString = " - No new changes"
    }
    return changeString
}

@NonCPS
def getIssueList(re) {
    def list = []
    def changes = getChangeString()
    def y = changes =~ re
    while (y) {
        list.add(y.group().toString())
    }
    return list
}