cjkay-tf-a-make/Jenkinsfile

pipeline {
    agent {
        kubernetes {
            defaultContainer 'builder'

            yaml """
                apiVersion: v1
                kind: Pod

                spec:
                  containers:
                    - name: builder
                      image: ${params.TF_A_SYSTEM}

                      resources:
                        requests:
                          cpu: '4'
                          memory: '4Gi'

                      command:
                        - cat

                      tty: true
            """
        }
    }

    parameters {
        string(name: 'TF_A_FLAGS',
            defaultValue: '-j',
            description: 'Arguments passed verbatim to make')

        choice(name: 'TF_A_TOOLCHAIN',
            description: 'Toolchain to build TF-A with.',
            choices: [
                'arm-gnu:aarch64-none-elf:12.3.rel1',
                'arm-gnu:aarch64-none-elf:13.2.rel1',
                'arm-gnu:aarch64-none-elf:13.3.rel1',
                'arm-gnu:aarch64-none-elf:14.2.rel1',
            ])

        choice(name: 'TF_A_SYSTEM',
            description: 'System Docker image to build TF-A within.',
            choices: [
                'ubuntu:20.04',
                'ubuntu:22.04',
                'ubuntu:24.04',
            ])

        string(name: 'TF_A_GIT_URL',
            description: 'Git repository URL.',
            defaultValue: 'https://review.trustedfirmware.org/TF-A/trusted-firmware-a')

        string(name: 'TF_A_GIT_REFSPEC',
            description: 'Git refspec used when fetching.',
            defaultValue: '+refs/heads/*:refs/remotes/origin/*')

        string(name: 'TF_A_GIT_REFNAME',
            description: 'Git refname to check out and build.',
            defaultValue: 'remotes/origin/master')
    }

    stages {
        stage('Prepare System') {
            when {
                expression {
                    params.TF_A_SYSTEM.startsWith('ubuntu:')
                }
            }

            steps {
                sh '''
                    set -eux

                    apt-get update
                    apt-get install -y --no-install-recommends \
                        build-essential ca-certificates curl device-tree-compiler
                '''
            }
        }

        stage('Install Arm GNU Toolchain') {
            when {
                expression {
                    params.TF_A_TOOLCHAIN.startsWith('arm-gnu:')
                }
            }

            steps {
                script {
                    def (_, target, version) = params.TF_A_TOOLCHAIN.split(':')

                    def path = "/opt/arm-gnu-${target}-${version}"
                    def tarball = "arm-gnu-toolchain-${version}-x86_64-${target}.tar.xz"
                    def url = "https://developer.arm.com/-/media/Files/downloads/gnu/${version}/binrel/${tarball}"

                    env.TF_A_TOOLCHAIN_PATH = "${path}/bin"
                }

                sh """
                    set -eux

                    mkdir -p '${path}'

                    curl -fsSL '${url}' |
                        tar -xJf - -C '${path}' --strip-components=1
                """
            }
        }

        stage('Checkout') {
            steps {
                checkout([ $class: 'GitSCM',
                    branches: [[name: params.TF_A_GIT_REFNAME]],

                    userRemoteConfigs: [[
                        url: params.TF_A_GIT_URL,
                        refspec: params.TF_A_GIT_REFSPEC,
                    ]],

                    extensions: [
                        [ $class: 'CloneOption', shallow: true, depth: 1 ],
                        [ $class: 'SubmoduleOption', recursiveSubmodules: true ],
                    ]
                ])
            }
        }

        stage('Build') {
            environment {
                PATH = "${env.TF_A_TOOLCHAIN_PATH}:${env.PATH}"
                TF_A_FLAGS = "${params.TF_A_FLAGS}"
            }

            steps {
                sh 'make ${TF_A_FLAGS} 2>&1 | tee build.log'
            }
        }
    }

    post {
        always {
            archiveArtifacts(artifacts: "build.log, build/**", fingerprint: true)
            cleanWs(deleteDirs: true)
        }
    }
}