zproject_jenkins.gsl

#   Generate Jenkinsfile for project, to test automatically on Jenkins v2.x+
#
#   This is a code generator built using the iMatix GSL code generation
#   language. See https://github.com/imatix/gsl for details.
#
#   Copyright (c) the Contributors as noted in the AUTHORS file.
#   This file is part of zproject.
#
#   This Source Code Form is subject to the terms of the Mozilla Public
#   License, v. 2.0. If a copy of the MPL was not distributed with this
#   file, You can obtain one at http://mozilla.org/MPL/2.0/.

register_target ("jenkins", "pipeline CI script for jenkins")

.function isSingle_jenkins_agent (project, global_agent)
.# See details below in jenkins_agent()
.# The default if agent_single is not defined is to treat it as "true" mostly
.# due to https://issues.jenkins-ci.org/browse/JENKINS-48168 instability so far
.   if ( ( (project.jenkins_agent_single ?= 0) & (my.global_agent ?= 0) ) | ( (my.global_agent ?= 1) & ( !(defined (project.jenkins_agent_single)) | project.jenkins_agent_single ?= 1 ) ) )
.       return 1
.   endif
.   return 0
.endfunction

.function jenkins_agent (project, global_agent)
.# An "agent_single" setup defines one of the choices from project.xml
.# in the head of Jenkinsfile, and no more agents in individual steps.
.# The opposite setup (default) uses "agent none" at the top and sets
.# the agents in each step of the build and test, to spread the load.
.# The "global_agent" option is "1" in header and "0" in steps, to
.# specify whether we want anything to be printed at that position.
.   if ( isSingle_jenkins_agent(project, my.global_agent) )
.# Project can be built and tested in a single agent, or can spread
.# the load across executors or even different agents
.     if defined (project.jenkins_agent_docker)
>                   agent \{ docker \{ image '$(project.jenkins_agent_docker:)' } }
.     elsif defined (project.jenkins_docker)
.# Legacy naming for the variable
>                    agent \{ docker \{ image '$(project.jenkins_docker:)' } }
.     elsif defined (project.jenkins_agent_label)
>                    agent \{ label "$(project.jenkins_agent_label:)" }
.     else
>                    agent any
.     endif
.     return 1
.   else
.     if ( (my.global_agent ?= 1) | (project.jenkins_agent_single ?= 0) )
.# This option only happens in the header of the file, not in steps
>    agent none
.     return 1
.     endif
.   endif
.   return 0
.endfunction

.macro target_jenkins
. if defined (project.jenkins_file)
.   jenkinsfile = project.jenkins_file
. else
.   jenkinsfile = 'Jenkinsfile'
. endif
. if file.exists (jenkinsfile)
.    echo "NOT regenerating an existing Jenkins file '$(jenkinsfile:)'; you might want to move yours out of the way and re-generate the project again to get updated settings"
. else
.    output jenkinsfile
/*
    $(project.name) - $(project.description?'':)

.   for project.license
    $(string.trim (license.):block                                         )
.   endfor
*/

pipeline {
.  jenkins_agent (project, 1)
    parameters {
        // Use DEFAULT_DEPLOY_BRANCH_PATTERN and DEFAULT_DEPLOY_JOB_NAME if
        // defined in this jenkins setup -- in Jenkins Management Web-GUI
        // see Configure System / Global properties / Environment variables
        // Default (if unset) is empty => no deployment attempt after good test
        // See zproject Jenkinsfile-deploy.example for an example deploy job.
        // TODO: Try to marry MultiBranchPipeline support with pre-set defaults
        // directly in MultiBranchPipeline plugin, or mechanism like Credentials,
        // or a config file uploaded to master for all jobs or this job, see
        // https://jenkins.io/doc/pipeline/examples/#configfile-provider-plugin
        string (
            defaultValue: '\$\{DEFAULT_DEPLOY_BRANCH_PATTERN}',
            description: 'Regular expression of branch names for which a deploy action would be attempted after a successful build and test; leave empty to not deploy. Reasonable value is ^(master|release/.*|feature/*)$',
            name : 'DEPLOY_BRANCH_PATTERN')
        string (
            defaultValue: '\$\{DEFAULT_DEPLOY_JOB_NAME}',
            description: 'Name of your job that handles deployments and should accept arguments: DEPLOY_GIT_URL DEPLOY_GIT_BRANCH DEPLOY_GIT_COMMIT -- and it is up to that job what to do with this knowledge (e.g. git archive + push to packaging); leave empty to not deploy',
            name : 'DEPLOY_JOB_NAME')
        booleanParam (
            defaultValue: true,
            description: 'If the deployment is done, should THIS job wait for it to complete and include its success or failure as the build result (true), or should it schedule the job and exit quickly to free up the executor (false)',
            name: 'DEPLOY_REPORT_RESULT')
        booleanParam (
.  if ( ( project.jenkins_build_without_draft_api ?= 0 ) | !(project.stable) )
.# NOTE: If "!project.stable" then there is no support for --enable-drafts in
.# the generated configure.ac script, drafts are always on. So we can skip the
.# non-draft test for young experimental projects.
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt stable build without DRAFT API in this run?',
            name: 'DO_BUILD_WITHOUT_DRAFT_API')
        booleanParam (
.  if project.jenkins_build_with_draft_api ?= 0
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt build with DRAFT API in this run?',
            name: 'DO_BUILD_WITH_DRAFT_API')
        booleanParam (
.  if ( !(defined(project.jenkins_build_docs)) | (project.jenkins_build_docs ?= 0) )
. # asciidoc and xmlto are external tools that may be not installed in general case
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt a build with docs in this run? (Note: corresponding tools are required in the build environment)',
            name: 'DO_BUILD_DOCS')
        booleanParam (
.  if project.jenkins_test_check ?= 0
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt "make check" in this run?',
            name: 'DO_TEST_CHECK')
        booleanParam (
.  if project.jenkins_test_memcheck ?= 0
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt "make memcheck" in this run?',
            name: 'DO_TEST_MEMCHECK')
        booleanParam (
.  if ( project.jenkins_test_distcheck ?= 0 | project.jenkins_distcheck ?= 0 )
.# "distcheck" option is a legacy artifact; use test_distcheck=0 in practice
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt "make distcheck" in this run?',
            name: 'DO_TEST_DISTCHECK')
        booleanParam (
.  if project.jenkins_test_install ?= 0
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt a "make install" check in this run?',
            name: 'DO_TEST_INSTALL')
        string (
.  if ( !(defined(project.jenkins_test_install_DESTDIR)) | project.jenkins_test_install_DESTDIR ?= "" )
            defaultValue: "`pwd`/tmp/_inst",
.  else
            defaultValue: "$(project.jenkins_test_install_DESTDIR)",
.  endif
            description: 'If attempting a "make install" check in this run, what DESTDIR to specify? (absolute path, defaults to "BUILD_DIR/tmp/_inst")',
            name: 'USE_TEST_INSTALL_DESTDIR')
        booleanParam (
.  if ( !(defined(project.jenkins_test_cppcheck)) | (project.jenkins_test_cppcheck ?= 0) )
. # cppcheck is an external tool that may be not installed in general case
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Attempt "cppcheck" analysis before this run? (Note: corresponding tools are required in the build environment)',
            name: 'DO_CPPCHECK')
        booleanParam (
.  if project.jenkins_require_gitignore ?= 0
            defaultValue: false,
.  else
            defaultValue: true,
.  endif
            description: 'Require that there are no files not discovered changed/untracked via .gitignore after builds and tests?',
            name: 'REQUIRE_GOOD_GITIGNORE')
.  if !(isSingle_jenkins_agent (project, 0))
        booleanParam (
            defaultValue: true,
            description: 'When using temporary subdirs in build/test workspaces, wipe them after successful builds?',
            name: 'DO_CLEANUP_AFTER_BUILD')
.  endif
    }
.  if !(defined(project.jenkins_triggers_pollSCM))
    triggers {
        pollSCM 'H/5 * * * *'
    }
.  else
.   if project.jenkins_triggers_pollSCM ?= ""
.       # Explicit skip of polling setup
.   else
    triggers {
        pollSCM '$(project.jenkins_triggers_pollSCM)'
    }
.   endif
.  endif
.# TODO: Add a --enable-address-sanitizer=yes matrix
// Note: your Jenkins setup may benefit from similar setup on side of agents:
//        PATH="/usr/lib64/ccache:/usr/lib/ccache:/usr/bin:/bin:\$\{PATH}"
    stages {
        stage ('cppcheck') {
                    when { expression { return ( params.DO_CPPCHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
                        dir("tmp") {
                            deleteDir()
                        }
                        sh 'cppcheck --std=c++11 --enable=all --inconclusive --xml --xml-version=2 . 2>cppcheck.xml'
                        archiveArtifacts artifacts: '**/cppcheck.xml'
                        sh 'rm -f cppcheck.xml'
                    }
        }
        stage ('prepare') {
.       jenkins_agent (project, 0)
                    steps {
                        dir("tmp") {
                            deleteDir()
                        }
                        sh './autogen.sh'
                        stash (name: 'prepped', includes: '**/*', excludes: '**/cppcheck.xml')
                    }
        }
        stage ('compile') {
            parallel {
                stage ('build with DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITH_DRAFT_API ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/build-withDRAFT") {
                        deleteDir()
.       endif
                        unstash 'prepped'
                        sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; ./configure --enable-drafts=yes --with-docs=no'
                        sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; make -k -j4 || make'
                        sh 'echo "Are GitIgnores good after make with drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
                        stash (name: 'built-draft', includes: '**/*', excludes: '**/cppcheck.xml')
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('build without DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITHOUT_DRAFT_API ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/build-withoutDRAFT") {
                        deleteDir()
.       endif
                        unstash 'prepped'
                        sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; ./configure --enable-drafts=no --with-docs=no'
                        sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; make -k -j4 || make'
                        sh 'echo "Are GitIgnores good after make without drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
                        stash (name: 'built-nondraft', includes: '**/*', excludes: '**/cppcheck.xml')
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('build with DOCS') {
                    when { expression { return ( params.DO_BUILD_DOCS ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/build-DOCS") {
                        deleteDir()
.       endif
                        unstash 'prepped'
                        sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; ./configure --enable-drafts=yes --with-docs=yes'
                        sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; make -k -j4 || make'
                        sh 'echo "Are GitIgnores good after make with docs? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
                        stash (name: 'built-docs', includes: '**/*', excludes: '**/cppcheck.xml')
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
            }
        }
.       if ( project.jenkins_check_sequential ?= 1 )
        // Self-test stages below should be run sequentially, as decreed by
        // project authors for the time being (e.g. port conflicts, etc.)
        // You can uncomment the closures below experimentally, but proper
        // fix belongs in the project.xml (e.g. use separate agents if your
        // infrastructure is set up to only schedule one build on the agent
        // at a time) and better yet - in the project sources, to not have
        // the conflicts at all.
//        stage ('check') {
//            parallel {
.       else
        stage ('check') {
            parallel {
.       endif
                stage ('check with DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITH_DRAFT_API && params.DO_TEST_CHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-check-withDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-draft'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\$LD_LIBRARY_PATH"; export LD_LIBRARY_PATH; make check'
                        }
                        sh 'echo "Are GitIgnores good after make check with drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('check without DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITHOUT_DRAFT_API && params.DO_TEST_CHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-check-withoutDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-nondraft'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\$LD_LIBRARY_PATH"; export LD_LIBRARY_PATH; make check'
                        }
                        sh 'echo "Are GitIgnores good after make check without drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('memcheck with DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITH_DRAFT_API && params.DO_TEST_MEMCHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-memcheck-withDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-draft'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\$LD_LIBRARY_PATH"; export LD_LIBRARY_PATH; make memcheck && exit 0 ; echo "Re-running failed ($?) memcheck with greater verbosity" >&2 ; make VERBOSE=1 memcheck-verbose'
                        }
                        sh 'echo "Are GitIgnores good after make memcheck with drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('memcheck without DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITHOUT_DRAFT_API && params.DO_TEST_MEMCHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-memcheck-withoutDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-nondraft'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\$LD_LIBRARY_PATH"; export LD_LIBRARY_PATH; make memcheck && exit 0 ; echo "Re-running failed ($?) memcheck with greater verbosity" >&2 ; make VERBOSE=1 memcheck-verbose'
                        }
                        sh 'echo "Are GitIgnores good after make memcheck without drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('distcheck with DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITH_DRAFT_API && params.DO_TEST_DISTCHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-distcheck-withDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-draft'
                        timeout (time: 10, unit: 'MINUTES') {
                            sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\$LD_LIBRARY_PATH"; export LD_LIBRARY_PATH; make distcheck'
                        }
                        sh 'echo "Are GitIgnores good after make distcheck with drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('distcheck without DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITHOUT_DRAFT_API && params.DO_TEST_DISTCHECK ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-distcheck-withoutDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-nondraft'
                        timeout (time: 10, unit: 'MINUTES') {
                            sh 'CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\$LD_LIBRARY_PATH"; export LD_LIBRARY_PATH; make distcheck'
                        }
                        sh 'echo "Are GitIgnores good after make distcheck without drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('install with DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITH_DRAFT_API && params.DO_TEST_INSTALL ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-install-withDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-draft'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh """CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\\$\{LD_LIBRARY_PATH\}"; export LD_LIBRARY_PATH; make DESTDIR="${params.USE_TEST_INSTALL_DESTDIR}/withDRAFT" install"""
                        }
                        sh """cd "${params.USE_TEST_INSTALL_DESTDIR}/withDRAFT" && find . -ls"""
                        sh 'echo "Are GitIgnores good after make install with drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('install without DRAFT') {
                    when { expression { return ( params.DO_BUILD_WITHOUT_DRAFT_API && params.DO_TEST_INSTALL ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-install-withoutDRAFT") {
                        deleteDir()
.       endif
                        unstash 'built-nondraft'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh """CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\\$\{LD_LIBRARY_PATH\}"; export LD_LIBRARY_PATH; make DESTDIR="${params.USE_TEST_INSTALL_DESTDIR}/withoutDRAFT" install"""
                        }
                        sh """cd "${params.USE_TEST_INSTALL_DESTDIR}/withoutDRAFT" && find . -ls"""
                        sh 'echo "Are GitIgnores good after make install without drafts? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
                stage ('install with DOCS') {
                    when { expression { return ( params.DO_BUILD_DOCS && params.DO_TEST_INSTALL ) } }
.       jenkins_agent (project, 0)
                    steps {
.       if !(isSingle_jenkins_agent (project, 0))
                      dir("tmp/test-install-withDOCS") {
                        deleteDir()
.       endif
                        unstash 'built-docs'
                        timeout (time: 5, unit: 'MINUTES') {
                            sh """CCACHE_BASEDIR="`pwd`" ; export CCACHE_BASEDIR; LD_LIBRARY_PATH="`pwd`/src/.libs:\\$\{LD_LIBRARY_PATH\}"; export LD_LIBRARY_PATH; make DESTDIR="${params.USE_TEST_INSTALL_DESTDIR}/withDOCS" install"""
                        }
                        sh """cd "${params.USE_TEST_INSTALL_DESTDIR}/withDOCS" && find . -ls"""
                        sh 'echo "Are GitIgnores good after make install with Docs? (should have no output below)"; git status -s || if [ "${params.REQUIRE_GOOD_GITIGNORE}" = false ]; then echo "WARNING GitIgnore tests found newly changed or untracked files" >&2 ; exit 0 ; else echo "FAILED GitIgnore tests" >&2 ; exit 1; fi'
.       if !(isSingle_jenkins_agent (project, 0))
                        script {
                            if ( params.DO_CLEANUP_AFTER_BUILD ) {
                                deleteDir()
                            }
                        }
                      }
.       endif
                    }
                }
.       if ( project.jenkins_check_sequential ?= 1 )
        // Sequential block of self-tests end here
//            }
//        }
.       else
            }
        }
.       endif
        stage ('deploy if appropriate') {
            steps {
                script {
                    def myDEPLOY_JOB_NAME = sh(returnStdout: true, script: """echo "\$\{params["DEPLOY_JOB_NAME"]}" """).trim();
                    def myDEPLOY_BRANCH_PATTERN = sh(returnStdout: true, script: """echo "\$\{params["DEPLOY_BRANCH_PATTERN"]}" """).trim();
                    def myDEPLOY_REPORT_RESULT = sh(returnStdout: true, script: """echo "\$\{params["DEPLOY_REPORT_RESULT"]}" """).trim().toBoolean();
                    echo "Original: DEPLOY_JOB_NAME : \$\{params["DEPLOY_JOB_NAME"]} DEPLOY_BRANCH_PATTERN : \$\{params["DEPLOY_BRANCH_PATTERN"]} DEPLOY_REPORT_RESULT : \$\{params["DEPLOY_REPORT_RESULT"]}"
                    echo "Used:     myDEPLOY_JOB_NAME:\$\{myDEPLOY_JOB_NAME} myDEPLOY_BRANCH_PATTERN:\$\{myDEPLOY_BRANCH_PATTERN} myDEPLOY_REPORT_RESULT:\$\{myDEPLOY_REPORT_RESULT}"
                    if ( (myDEPLOY_JOB_NAME != "") && (myDEPLOY_BRANCH_PATTERN != "") ) {
                        if ( env.BRANCH_NAME =~ myDEPLOY_BRANCH_PATTERN ) {
                            def GIT_URL = sh(returnStdout: true, script: """git remote -v | egrep '^origin' | awk '{print \\$2}' | head -1""").trim()
                            def GIT_COMMIT = sh(returnStdout: true, script: 'git rev-parse --verify HEAD').trim()
                            build job: "\$\{myDEPLOY_JOB_NAME}", parameters: [
                                string(name: 'DEPLOY_GIT_URL', value: "\$\{GIT_URL}"),
                                string(name: 'DEPLOY_GIT_BRANCH', value: env.BRANCH_NAME),
                                string(name: 'DEPLOY_GIT_COMMIT', value: "\$\{GIT_COMMIT}")
                                ], quietPeriod: 0, wait: myDEPLOY_REPORT_RESULT, propagate: myDEPLOY_REPORT_RESULT
                        } else {
                            echo "Not deploying because branch '\$\{env.BRANCH_NAME}' did not match filter '\$\{myDEPLOY_BRANCH_PATTERN}'"
                        }
                    } else {
                        echo "Not deploying because deploy-job parameters are not set"
                    }
                }
            }
        }
    }
    post {
        success {
            script {
                if (currentBuild.getPreviousBuild()?.result != 'SUCCESS') {
                    // Uncomment desired notification

                    //slackSend (color: "#008800", message: "Build \$\{env.JOB_NAME} is back to normal.")
                    //emailext (to: "qa@example.com", subject: "Build \$\{env.JOB_NAME} is back to normal.", body: "Build \$\{env.JOB_NAME} is back to normal.")
                }
            }
        }
        failure {
            // Uncomment desired notification
            // Section must not be empty, you can delete the sleep once you set notification
            sleep 1
            //slackSend (color: "#AA0000", message: "Build \$\{env.BUILD_NUMBER} of \$\{env.JOB_NAME} \$\{currentBuild.result} (<\$\{env.BUILD_URL}|Open>)")
            //emailext (to: "qa@example.com", subject: "Build \$\{env.JOB_NAME} failed!", body: "Build \$\{env.BUILD_NUMBER} of \$\{env.JOB_NAME} \$\{currentBuild.result}\\nSee \$\{env.BUILD_URL}")
        }
    }
}
. endif
.endmacro