Jenkinsfile

#!/usr/bin/env groovy
// Builds on a variety of platforms with a variety of options

pipeline {
    // Each of the build steps will define their own agents. We will use docker wherever
    // We can, but there is no Docker container available with either the Intel or PGI
    // compilers, so we'll have to make do with running on bare metal in those cases
    agent none

    options {
        skipDefaultCheckout()
        buildDiscarder(logRotator(numToKeepStr: "10"))
        timestamps()
        timeout time: 2, unit: 'HOURS'
    }

    stages {
        stage("Checkout and stash source code") {
            agent { label "linux" }

            steps {
                script {
                    env.GIT_COMMIT = checkout(scm).GIT_COMMIT
                }

                // We need to *not* exclude default excludes so we keep the .git
                // directory and its relevant information
                stash includes: "**", name: "source", useDefaultExcludes: false
            }
            post { cleanup { deleteDir() } }
        }

        stage("Build and test") {
            when {
                // Testing needs to be done as a merge gate. Since this is a
                // somewhat pricey operation in the number of executors used,
                // assume sufficient testing was already done for the master
                // branch
                not {
                    branch "master"
                }
            }
            parallel {
              stage("Linux GNU Unit Tests") {
                    agent {
                        docker {
                            image 'ambermd/cpu-build:latest'
                            alwaysPull true
                        }
                    }

                    steps {
                        unstash "source"
                        sh "./configure --with-netcdf --with-fftw3 gnu"
                        sh "cd unitTests && make test.all"
                    }

                    post { cleanup { deleteDir() } }
                }
                stage("Linux GNU serial build") {
                    agent {
                        docker {
                            image 'ambermd/cpu-build:latest'
                            alwaysPull true
                        }
                    }

                    steps {
                        unstash "source"
                        sh "./configure --with-netcdf --with-fftw3 gnu"
                        sh "make -j4 install"
                        sh "cd test && make test.showerrors"
                    }

                    post { cleanup { deleteDir() } }
                }
                //stage("Linux Intel Serial Build") {
                //    when { expression { return false } }
                //    agent {
                //        docker {
                //            image 'ambermd/cpu-build:latest'
                //            alwaysPull true
                //            label "docker && intel"
                //            // There's no way to have a docker container installed with a licensed
                //            // copy of the Intel compilers, so we need to mount it from the host
                //            // machine. This introduces the constraint that *all* of the Jenkins
                //            // slaves need to have the Intel compilers available at /opt/intel
                //            args "-v /opt/intel:/opt/intel"
                //        }
                //    }

                //    environment {
                //        MKL_HOME = "/opt/intel/compilers_and_libraries/linux/mkl"
                //    }

                //    steps {
                //        unstash "source"
                //        sh "./configure --with-netcdf -mkl intel"
                //        sh "make -j4 install"
                //        sh "cd test && make test.showerrors"
                //    }
                //    post { cleanup { deleteDir() } }
                //}
                //stage("Linux PGI serial build") {
                //    agent {
                //        docker {
                //            // Until we figure out why PGI compilers fail on the master Jenkins node,
                //            // force them to run on Intel CPU slaves
                //            label "pgi && intel-cpu"
                //            image 'ambermd/cpu-build:latest'
                //            alwaysPull true
                //            // Pull the licensed PGI compilers from the host machine (must have
                //            // the compilers installed in /opt/pgi)
                //            args "-v /opt/pgi:/opt/pgi"
                //        }
                //    }

                //    steps {
                //        unstash "source"
                //        script {
                //            try {
                //                sh """#!/bin/sh -ex
                //                unset CUDA_HOME
                //                ./configure --with-netcdf --with-fftw3 pgi
                //                make -j6 install
                //                cd test && make test.showerrors
                //                """
                //            } catch (error) {
                //                echo "PGI BUILD AND/OR TEST FAILED"
                //                try {
                //                    pullRequest.comment("The PGI build in Jenkins failed.")
                //                } catch (err2) {
                //                    echo "Could not post a PR comment: ${err2}"
                //                }
                //            }
                //        }
                //    }
                //    post { cleanup { deleteDir() } }
                //}
                stage("Linux GNU parallel build") {
                    agent {
                        docker {
                            image 'ambermd/cpu-build:latest'
                            alwaysPull true
                        }
                    }

                    steps {
                        unstash "source"
                        sh "./configure --with-netcdf --with-fftw3 -mpi --buildlibs gnu"
                        sh "make -j4 install"
                        sh "make -e DO_PARALLEL='mpiexec -n 2' verbosecheck"
                        sh "make -e DO_PARALLEL='mpiexec -n 4' verbosecheck"
                    }
                    post { cleanup { deleteDir() } }
                }
                stage("Linux CUDA build") {
                    agent {
                        docker {
                            image 'ambermd/gpu-build:latest'
                            alwaysPull true
                            label "docker && cuda"
                            args '--gpus all'
                        }
                    }

                    steps {
                        unstash "source"
                        sh "./configure --with-netcdf --with-fftw3 -cuda gnu"
                        sh "make -j4 install"
                        sh "make -e OPT=cuda verbosecheck"
                    }
                    post { cleanup { deleteDir() } }
                }
                stage("Linux GNU OpenMP build") {
                    agent {
                        docker {
                            image 'ambermd/cpu-build:latest'
                            alwaysPull true
                        }
                    }

                    steps {
                        unstash "source"
                        sh "./configure --with-netcdf --with-fftw3 -openmp gnu"
                        sh "make -j4 install"
                        sh "make -e OPT=openmp verbosecheck"
                    }
                    post { cleanup { deleteDir() } }
                }
            }
        }

        //stage("Post-test steps") {
        //    parallel {
        //        stage("Publish the manual") {
        //            stages {
        //                stage("Build the manual") {
        //                    agent {
        //                        docker {
        //                            image 'ambermd/lyx:latest'
        //                            alwaysPull true
        //                        }
        //                    }

        //                    steps {
        //                        unstash "source"
        //                        sh """#!/bin/sh -ex
        //                            make docs
        //                            cd doc
        //                            lyx -batch --export pdf2 CpptrajManual.lyx
        //                            lyx -batch --export pdf2 CpptrajDevelopmentGuide.lyx
        //                        """
        //                        stash includes: "doc/**", name: "documentation"
        //                    }

        //                    post { cleanup { deleteDir() } }
        //                }
        //                stage("Publish the manual") {
        //                    agent { label 'linux' }

        //                    steps {
        //                        unstash 'documentation'
        //                        // Eventually it would be nice to do something better than simply archive
        //                        // and make the artifacts available from Jenkins.
        //                        archiveArtifacts 'doc/CpptrajManual.pdf,doc/CpptrajDevelopmentGuide.pdf'
        //                        // It would be nice to get this in a better place, but for now this
        //                        // will suffice.
        //                        publishHTML([
        //                            allowMissing: false,
        //                            alwaysLinkToLastBuild: false,
        //                            keepAll: false,
        //                            reportDir: 'doc/html',
        //                            reportFiles: 'index.html',
        //                            reportName: 'Doxygen Documentation',
        //                            reportTitles: ''])
        //                    }

        //                    post { cleanup { deleteDir() } }
        //                }
        //            }
        //        }
        //    }
        //}
    }
}