kernelci.org

#!/bin/sh

# Tool to update the kernelci.org production instance

set -e

cmd_flush_kernel() {
    echo "Flushing all current kernel builds"
    python3 job.py --settings data/prod-jenkins.ini \
            disable kernel-tree-monitor
    python3 job.py --settings data/prod-jenkins.ini \
            wait kernel-build-trigger
}

cmd_abort_bisections() {
    echo "Aborting any on-going bisections"
    python3 job.py --settings data/prod-jenkins.ini \
            disable lava-bisection
    python3 job.py --settings data/prod-jenkins.ini \
            abort lava-bisection
}

cmd_core() {
    # First, manually push to kernelci-core/kernelci.org branch

    branch="${1:-kernelci.org}"
    echo "Getting $branch branch from kernelci-core"
    [ -d checkout/kernelci-core ] || {
        mkdir -p checkout
        git clone \
            https://github.com/kernelci/kernelci-core.git \
            checkout/kernelci-core \
            -b $branch
        cd checkout/kernelci-core
        git remote \
            set-url origin --push \
            git@github.com:kernelci/kernelci-core.git
        cd -
    }
    cd checkout/kernelci-core
    git remote update origin
    git checkout origin/$branch
    cd -

    python3 update.py \
            --branch $branch \
            --ssh-key=$PWD/keys/id_rsa_kernelci.org \
            --push \
            kernelci-core
}

cmd_jenkins() {
    # ToDo
    return 0
}

cmd_dsl() {
    echo "Running Jenkins DSL seed job"
    python3 job.py --settings data/prod-jenkins.ini \
            trigger job-dsl --no-params
}

cmd_rootfs_builds() {
    local version="$1"

    echo "Starting rootfs build jobs"
    [ -n "$version" ] && echo "Pipeline version: $version"

    echo "{\
\"PIPELINE_VERSION\": \"$version\",\
\"KCI_CORE_BRANCH\": \"main\",\
\"ROOTFS_TYPE\": \"buildroot debos\"\
}" > rootfs-build-trigger.json
    python3 job.py \
        --settings=data/prod-jenkins.ini \
        --json=rootfs-build-trigger.json \
        trigger \
        rootfs-build-trigger
    rm rootfs-build-trigger.json
}

cmd_rootfs_flush() {
    echo "Waiting for rootfs jobs to complete"
    python3 job.py --settings data/prod-jenkins.ini \
            wait rootfs-build-trigger
}

cmd_rootfs_update() {
    local version="$1"

    echo "Updating rootfs URLs to $version"

    cd checkout/kernelci-core
    git fetch origin main
    git checkout $FETCH_HEAD
    if ./kci_test update_rootfs_urls --release ${version} --output rootfs-images-${version}.yaml --verbose; then
        mv rootfs-images-${version}.yaml config/core/rootfs-images.yaml
        local branch=rootfs-$version
        git checkout -b $branch
        git commit -asm "rootfs-images.yaml: update rootfs URLs to $version"
        git push -u origin HEAD:$branch
        git checkout main
        git branch -D $branch
    else
        echo "Failed to update rootfs URLs"
        git reset --hard
        git checkout origin/main
    fi
    cd -
}

cmd_backend() {
    # First, manually update kernelci-backend kernelci.org branch

    rev="${1:-kernelci.org}"
    echo "Updating kernelci-backend to $rev"
    ./ansible \
        kernelci-backend \
        api.kernelci.org \
        $rev \
        main \
        $PWD/keys/id_rsa_kernelci.org
}

cmd_frontend() {
    # First, manually update kernelci-frontend kernelci.org branch

    rev="${1:-kernelci.org}"
    echo "Updating kernelci-frontend to $rev"
    ./ansible \
        kernelci-frontend \
        linux.kernelci.org \
        $rev \
        main \
        $PWD/keys/id_rsa_kernelci.org
}

cmd_website() {
    branch="${1:-kernelci.org}"

    [ -d checkout/kernelci-project ] || {
        echo "Cloning kernelci-project"
        mkdir -p checkout
        git clone \
            https://github.com/kernelci/kernelci-project.git \
            checkout/kernelci-project \
            -b $branch
        cd checkout/kernelci-project
        git remote \
            set-url origin --push \
            git@github.com:kernelci/kernelci-project.git
        cd -
    }

    echo "Updating sub-modules"
    cd checkout/kernelci-project
    git checkout main
    git pull --ff-only
    git submodule update --init --recursive
    cd - 2>&1 > /dev/null
    for mod in kernelci-core kernelci-api kcidb; do
        cd checkout/kernelci-project/kernelci.org/external/$mod
        git checkout main
        git pull --ff-only
        cd - 2>&1 > /dev/null
        cd checkout/kernelci-project
        git add kernelci.org/external/$mod
        cd - 2>&1 > /dev/null
    done
    cd checkout/kernelci-project
    if [ -n "$(git diff --cached | head -1)" ]; then
        git commit -asm "kernelci.org: update submodules"
        git push
    fi
    cd - 2>&1 > /dev/null

    python3 update.py \
            --branch $branch \
            --ssh-key=$PWD/keys/id_rsa_kernelci.org \
            --push \
            kernelci-project

    echo "Updating Git LFS and submodules"
    cd checkout/kernelci-project/kernelci.org
    git-lfs fetch
    git-lfs checkout
    git submodule update --init --recursive
    ./docker-hugo -D
    rm -rf /data/kernelci.org/*
    cp -R public/* /data/kernelci.org/
    cd -
}

cmd_docker() {
    echo "Re-building Docker images"

    cd checkout/kernelci-core

    core_rev=$(git show --pretty=format:%H -s origin/kernelci.org)
    base_args="build --build-arg core_rev=$core_rev"
    args="$base_args --prefix=kernelci/ --push --no-cache"

    # KernelCI tools
    ./kci docker $args kernelci
    ./kci docker $args k8s kernelci

    # Compiler toolchains
    for clang in clang-11 clang-12 clang-13 clang-14 clang-15 clang-16 clang-17; do
	./kci docker $args $clang
    done
    for clang in clang-11 clang-14 clang-15 clang-16 clang-17; do
        for arch in arm arm64 armv5 mips riscv64 x86; do
	    ./kci docker $base_args --push $clang kselftest kernelci --arch $arch
        done
    done
    for arch in arc arm armv5 arm64 mips riscv64 x86; do
	./kci docker $args gcc-10 kselftest kernelci --arch $arch
    done
    # missing -dev packages for sparc64
    ./kci docker $args gcc-10 kernelci --arch sparc
    # only x86 is useful for KUnit (for now)
    ./kci docker $args gcc-10 kunit kernelci --arch x86
    for rustc in rustc-1.62 rustc-1.66; do
        ./kci docker $args $rustc kselftest kernelci
        for arch in x86; do
            ./kci docker $args $rustc kselftest kernelci --arch $arch
        done
    done

    # rootfs
    ./kci docker $args buildroot kernelci
    ./kci docker $args debos kernelci

    # QEMU
    ./kci docker $args qemu

    # Other tools
    ./kci docker $args cvehound kernelci
    ./kci docker $args dt-validation # kernelci (PyYAML conflict)

    cd -
}

_rebase_upstream() {
    repo="$1"
    upstream_url="$2"
    branch="${3:-master}"

    if [ ! -d "checkout/$repo" ]; then
        git clone \
            https://github.com/kernelci/"$repo".git \
            checkout/"$repo"
        cd checkout/"$repo"
        git remote \
            set-url origin --push \
            git@github.com:kernelci/"$repo".git
        git remote \
            add upstream \
            "$upstream_url"
        git fetch --tags origin
        git fetch --tags upstream
        cd -
    fi

    python3 update.py \
            --ssh-key=$PWD/keys/id_rsa_kernelci.org \
            --branch=kernelci.org \
            --origin=upstream \
            --origin-branch="$branch" \
            --push \
            "$repo"
}

cmd_test_definitions() {
    _rebase_upstream \
        test-definitions \
        https://github.com/Linaro/test-definitions.git
    _rebase_upstream \
        iec-security \
        https://gitlab.com/cip-project/cip-testing/cip-security-tests.git
}

cmd_kernel() {
    echo "Pushing kernelci.org LTS kernel branch"
    python3 kernel.py \
        --from-url=git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git \
        --from-branch=linux-5.15.y \
        --branch=kernelci.org \
        --tag-prefix=kernelci- \
        --ssh-key=$PWD/keys/id_rsa_kernelci.org \
        --push
}

cmd_trigger() {
    echo "Starting Jenkins kernel-tree-monitor job"
    python3 job.py \
        --settings=data/prod-jenkins.ini \
        --json=data/prod-monitor.json \
        trigger \
        kernel-tree-monitor
}

# -----------------------------------------------------------------------------
# Main commands
#

cmd_checkout() {
    echo "Updating local repository"
    git remote update origin
    git checkout origin/main
}

cmd_rootfs() {
    local version=$(date +%Y%m%d).0
    cmd_rootfs_builds "$version"
    sleep 60
    cmd_rootfs_flush  # It takes a while for the jobs to start...
    cmd_rootfs_update "$version"
}

cmd_pause() {
    cmd_flush_kernel
    cmd_abort_bisections
    # ToDo: automate this step with SSH access to the nodes
    echo "Now restart Jenkins"
    # ToDo: automate waiting for Jenkins to be back online
}

cmd_update() {
    cmd_core
    cmd_dsl
    cmd_backend
    cmd_frontend
    cmd_website
    cmd_test_definitions
    cmd_docker
    cmd_kernel
    cmd_trigger
}

cmd="${1}"

if [ -n "$cmd" ]; then
    shift 1
# ToDo: fix issues mentioned in cmd_part1 and cmd_part2
#else
#    cmd="all"
fi

"cmd_"$cmd $@

exit 0