path: root/jenkins/bisect.jpl

#!/usr/bin/env groovy

/*
  Copyright (C) 2017 Collabora Limited
  Author: Guillaume Tucker <guillaume.tucker@collabora.com>

  This module is free software; you can redistribute it and/or modify it under
  the terms of the GNU Lesser General Public License as published by the Free
  Software Foundation; either version 2.1 of the License, or (at your option)
  any later version.

  This library is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
  details.

  You should have received a copy of the GNU Lesser General Public License
  along with this library; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

def getSHA(kdir) {
    def sha

    dir(kdir) {
        sha = sh(script: "git rev-parse HEAD", returnStdout: true)
    }

    return sha
}

def gitDescribe(kdir) {
    def describe

    dir(kdir) {
        describe = sh(script: "git describe", returnStdout: true).trim()
    }

    return describe
}

def createTag(kdir, iteration) {
    def tag = gitDescribe(kdir)

    dir(kdir) {
        tag += "-${env.JOB_NAME}-${currentBuild.number}-${iteration}"
        sh(script: "git tag -a ${tag} -m ${tag} HEAD")
    }

    return tag
}

def removeTag(kdir, tag) {
    dir(kdir) {
        sh(script: "git tag -d ${tag}")
    }
}

def checkoutRevision(git_dir, git_rev) {
    dir(git_dir) {
        sh(script: """
git clean -fd && \
git checkout --detach ${git_rev}
""")
    }
}

def cloneKCIBuild(kci_build) {
    sh(script: "rm -rf ${kci_build}")
    dir("${kci_build}") {
        git(url: params.KCI_BUILD_URL,
            branch: params.KCI_BUILD_BRANCH,
            poll: false)
    }
}

def cloneLinux(kdir) {
    echo """
Initialising kernel tree
  url:    ${params.KERNEL_URL}
  branch: ${params.KERNEL_BRANCH}
  path:   ${kdir}"""
    sh """
if [ -d ${kdir}/.git ]; then
    cd ${kdir}
    if git remote | grep -e '^${params.TREE}\$'; then
        git remote set-url ${params.TREE} ${params.KERNEL_URL}
        git remote update ${params.TREE}
        git remote prune ${params.TREE}
    else
        git remote add ${params.TREE} ${params.KERNEL_URL}
        git remote update ${params.TREE}
    fi
else
    git clone ${params.KERNEL_URL} ${kdir} -b ${params.KERNEL_BRANCH} -o ${params.TREE}
    cd ${kdir}
fi
git reset --hard
echo 'build-*' > .git/info/exclude
git clean -fd
git bisect reset || echo
git checkout --detach HEAD
git branch -D ${params.KERNEL_BRANCH} || echo
for t in \$(git tag -l | grep ${env.JOB_NAME}); do git tag -d \$t; done
git fetch ${params.TREE} ${params.KERNEL_BRANCH} --tags
git checkout FETCH_HEAD -b ${params.KERNEL_BRANCH}
git symbolic-ref HEAD refs/heads/${params.KERNEL_BRANCH}
cd -
"""
}

def cloneLAVA_CI(lava_ci) {
    sh(script: "rm -rf ${lava_ci}")
    dir("${lava_ci}") {
        git(url: params.LAVA_CI_URL,
            branch: params.LAVA_CI_BRANCH,
            poll: false)
    }
}

/* Working around some seemingly broken Python set-up... */
def eggCache() {
    def egg_cache = env.WORKSPACE + "/python-egg-cache"
    sh(script: "mkdir -p ${egg_cache}")
    return egg_cache
}

def buildKernel(kdir, kci_build) {
    dir(kdir) {
        withCredentials([string(credentialsId: params.KCI_TOKEN_ID,
                                variable: 'SECRET')]) {
            sh(script: """
API=${params.API} \
TOKEN=${SECRET} \
TREE_NAME=${params.TREE} \
ARCH=${params.ARCH} \
BRANCH=${params.KERNEL_BRANCH} \
""" + kci_build + "/build.py -e -g -i -c ${params.DEFCONFIG}")
        }
    }
}

def buildRevision(kdir, kci_build, git_rev, name) {
    checkoutRevision(kdir, git_rev)
    def tag = createTag(kdir, name)
    buildKernel(kdir, kci_build)
    return tag
}

def submitJob(lava_ci, describe) {
    dir(lava_ci) {
        sh(script: "rm -rf data; mkdir data")

        withCredentials([string(credentialsId: params.KCI_TOKEN_ID,
                                variable: 'SECRET')]) {
            sh(script: """
./lava-v2-jobs-from-api.py \
--lab=${params.LAB} \
--token=${SECRET} \
--api=${params.API} \
--storage=${params.STORAGE} \
--plans=${params.PLAN} \
--jobs=data \
--arch=${params.ARCH} \
--tree=${params.TREE} \
--describe=${describe} \
--branch=${params.KERNEL_BRANCH} \
--defconfig_full=${params.DEFCONFIG} \
--priority=${params.LAVA_PRIORITY} \
--callback=${params.CALLBACK} \
--targets=${params.TARGET}
""")
        }

        def egg_cache = eggCache()
        def token = "LAVA XMLRPC Token for " + params.LAB.split('-dev')[0]

        withCredentials([string(credentialsId: token, variable: 'SECRET')]) {
            sh(script: """
PYTHON_EGG_CACHE=${egg_cache} \
./lava-v2-submit-jobs.py \
--username=kernel-ci \
--token=${SECRET} \
--lab=${params.LAB} \
--jobs=data \
--submitted=data/submitted.json
""")
        }

        stash(name: "job-data", includes: "data/**")
    }
}

def getResult(lava_ci) {
    def status

    dir(lava_ci) {
        sh(script: "rm -rf data")
        unstash("job-data")
        def egg_cache = eggCache()
        withCredentials([string(credentialsId: params.KCI_TOKEN_ID,
                                variable: 'SECRET')]) {
            status = sh(returnStatus: true, script: """
PYTHON_EGG_CACHE=${egg_cache} \
./lava-v2-get-boot-results.py \
--lab=${params.LAB} \
--token=${SECRET} \
--api=${params.API} \
--submitted=data/submitted.json \
--period=30 \
--output=data/boots.json
""")
        }
    }

    return status
}

def runTest(lava_ci, describe) {
    cloneLAVA_CI(lava_ci)
    submitJob(lava_ci, describe)
    return getResult(lava_ci)
}

def bisectStart(kdir) {
    def status

    dir(kdir) {
        status = sh(returnStatus: true, script: """
git bisect start
git bisect good ${params.GOOD_COMMIT}
git bisect bad ${params.BAD_COMMIT}
""")
    }

    return status
}

def bisectNext(kdir, status) {
    dir(kdir) {
        sh(script: "git clean -fd")

        switch (status) {
        case 0:
            sh(script: "git bisect good")
            break
        case 2:
            sh(script: "git bisect bad")
            break
        case 1:
            echo "Iteration failed, skipping"
            sh(script: "git bisect skip")
            break
        default:
            echo "Unexpected status, skipping"
            sh(script: "git bisect skip")
            break
        }
    }
}

node("bisection") {
    def kci_build = env.WORKSPACE + '/kernelci-build'
    def kdir = env.WORKSPACE + '/linux'
    def check = null

    echo """\
Lab:       ${params.LAB}
Target:    ${params.TARGET}
Tree:      ${params.TREE}
Branch:    ${params.KERNEL_BRANCH}
Defconfig: ${params.DEFCONFIG}
Plan:      ${params.PLAN}
Good:      ${params.GOOD_COMMIT}
Bad:       ${params.BAD_COMMIT}"""

    if ((params.PLAN != 'boot') && (params.PLAN != 'simple')) {
        echo "Only doing boot and simple plans for now, aborting."
        currentBuild.result = 'ABORTED'
        return
    }

    timeout(time: 30, unit: 'MINUTES') {
        stage("Init") {
            parallel(
                p1: { cloneKCIBuild(kci_build) },
                p2: { cloneLinux(kdir) },
            )
        }
    }

    stage("Check pass") {
        def tag = null

        lock("${env.NODE_NAME}-build-lock") {
            timeout(time: 60, unit: 'MINUTES') {
                try {
                    tag = buildRevision(kdir, kci_build, params.GOOD_COMMIT,
                                        'pass')
                    check = true
                } catch (error) {
                    check = false
                }
            }
        }

        if (!check)
            return

        def describe = gitDescribe(kdir)

        node("kernel-boot-v2") {
            timeout(time: 120, unit: 'MINUTES') {
                def lava_ci = env.WORKSPACE + '/lava-ci'
                def status = runTest(lava_ci, describe)
                check = (status == 0 ? true : false)
            }
        }

        removeTag(kdir, tag)
    }

    if (!check) {
        echo "Good revision check failed"
        currentBuild.result = 'ABORTED'
        return
    }

    stage("Check fail") {
        def tag = null

        lock("${env.NODE_NAME}-build-lock") {
            timeout(time: 60, unit: 'MINUTES') {
                try {
                    tag = buildRevision(kdir, kci_build, params.BAD_COMMIT,
                                        'fail')
                    check = true
                } catch (error) {
                    check = false
                }
            }
        }

        if (!check)
            return

        def describe = gitDescribe(kdir)

        node("kernel-boot-v2") {
            timeout(time: 120, unit: 'MINUTES') {
                def lava_ci = env.WORKSPACE + '/lava-ci'
                def status = runTest(lava_ci, describe)
                check = (status == 2 ? true : false)
            }
        }

        removeTag(kdir, tag)
    }

    if (!check) {
        echo "Bad revision check failed"
        currentBuild.result = 'ABORTED'
        return
    }

    timeout(time: 5, unit: 'MINUTES') {
        stage("Start") {
            def start_result = bisectStart(kdir)

            if (start_result) {
                echo "Failed to start bisection, commits range may be invalid."
                currentBuild.result = 'ABORTED'
                return
            }
        }
    }

    def previous = params.GOOD_COMMIT
    def current = getSHA(kdir)
    def iteration = 1

    while (previous != current) {
        def tag = createTag(kdir, iteration)
        def status = null

        echo "Iteration #${iteration}: ${tag}"

        lock("${env.NODE_NAME}-build-lock") {
            timeout(time: 60, unit: 'MINUTES') {
                stage("Build ${iteration}") {
                    try {
                        buildKernel(kdir, kci_build)
                        status = 0
                    } catch (error) {
                        status = 1
                    }
                }
            }
        }

        if (status == 0) {
            def describe = gitDescribe(kdir)

            node("kernel-boot-v2") {
                timeout(time: 120, unit: 'MINUTES') {
                    stage("Test ${iteration}") {
                        def lava_ci = env.WORKSPACE + '/lava-ci'
                        status = runTest(lava_ci, describe)
                    }
                }
            }
        }

        removeTag(kdir, tag)

        timeout(time: 5, unit: 'MINUTES') {
            stage("Next") {
                bisectNext(kdir, status)
            }
        }

        previous = current
        current = getSHA(kdir)
        iteration += 1
    }
}