#!/usr/bin/env groovy

def initSourceTree(boardName, needsNative = false) {
    sh """
       apt-get update
       apt-get -y install make python curl git qemu-user-static sudo
       curl https://storage.googleapis.com/git-repo-downloads/repo > /usr/local/bin/repo
       chmod a+x /usr/local/bin/repo

       git clone https://gerrit.googlesource.com/gcompute-tools /tmp/gcompute-tools
       /tmp/gcompute-tools/git-cookie-authdaemon

       git config --global url.https://gerrit.googlesource.com/.insteadOf sso://gerrit.googlesource.com/

       mkdir -p .repo/local_manifests
       mkdir -p cache
       chmod 777 cache
       """

    timeout(time: 20, unit: 'MINUTES') {
        checkout([$class: 'RepoScm',
                  currentBranch: true,
                  jobs: 24,
                  manifestRepositoryUrl: 'http://coral.googlesource.com/manifest',
                  manifestBranch: 'master',
                  manifestFile: "${boardName}.xml",
                  manifestGroup: "default,internal",
                  localManifest: "https://coral.googlesource.com/gke-jenkins/+/refs/heads/master/local_manifest.xml",
                  depth: 1,
                  quiet: true])
    }

    // Bring in the pbuilder tarballs.
    //
    // archiveArtifacts includes the relative path to the
    // files we archive, so we don't have to specify cache/
    // here in the target.
    if (needsNative) {
        copyArtifacts(projectName: 'global.pbuilder.native', filter: '**/*.tgz')
    } else {
        copyArtifacts(projectName: 'global.pbuilder.cross', filter: '**/*.tgz')
    }
}

def buildTarget(targetName) {
    sh "bash -c 'source build/setup.sh; m prereqs ${targetName}; exit \$?'"
}

def nameFromRepoType(repoType, boardName) {
    if (repoType == "core") {
        return "core"
    } else if (repoType == "bsp") {
        return "bsp-${boardName}"
    } else {
        error 'Unknown repoType ${repoType}'
    }
}

def archiveAllGeneratedPackages(repoType, boardName) {
    def outPath = repoType
    def repoName = nameFromRepoType(repoType, boardName)

    sh """
       mkdir -p pool/${repoName}
       cp src/out/target/product/*/packages/${outPath}/* pool/${repoName}
       """

    archiveArtifacts([artifacts: "pool/${repoName}/*",
                      fingerprint: true])
}

def uploadAllGeneratedPackages(repoType, boardName) {
    def outPath = repoType
    def repoName = nameFromRepoType(repoType, boardName)

    sh """
       mkdir -p upload
       cp src/out/target/product/*/packages/${outPath}/* upload/
       """
    googleStorageUpload([bucket: "gs://mendel-linux-apt/pool/${repoName}/",
                         credentialsId: 'mendel-linux-cloud-infra',
                         pattern: "upload/*",
                         pathPrefix: "upload/",
                         sharedPublicly: true])
}

def buildPackagePipeline(boardName, repoType, packageName, needsNative = false) {
    def workspacePath = "/home/jenkins/workspace"
    def buildLabel = "${packageName}-${UUID.randomUUID().toString()}"
    def sourcePath = "${workspacePath}/src"

    // FIXME(jtgans): Get rid of privileged! This is a security risk!
    def jnlpContainer = containerTemplate(name: 'jnlp',
                                          image: 'jenkins/jnlp-slave:alpine')
    def debianContainer = containerTemplate(name: 'debian',
                                            image: 'debian:buster-slim',
                                            command: 'cat',
                                            args: '',
                                            ttyEnabled: true,
                                            privileged: true)

    podTemplate(label: buildLabel, containers: [jnlpContainer, debianContainer], envVars: []) {
        node(buildLabel) {
            dir(sourcePath) {
                stage('Init') {
                    container('debian') {
                        initSourceTree(boardName, needsNative)
                    }
                }

                stage('Build') {
                    container('debian') {
                        buildTarget(packageName)
                    }
                }
            }

            dir(workspacePath) {
                stage('Deploy') {
                    archiveAllGeneratedPackages(repoType, boardName)
                    uploadAllGeneratedPackages(repoType, boardName)
                }
            }
        }
    }
}