a_single_job.groovy

    new BaseJobBuilder(
        name: "operations-jira-restart",
        description: "Restarts dev jira. To be used when Jira is not responding",
        emails: ["foo@example.com", "bar@example.com"]
    ).build(this).with {
        scm {
            git("https://[redacted]/SoftwareDevelopment/operations-jenkins-automation.git", "master")
        }
        steps {
            shell("fab restart_jira")
        }
    }

bdd_security_job_example.groovy

import jenkins.automation.builders.BddSecurityJobBuilder
new BddSecurityJobBuilder(
        name: "example-bdd-security-tests",
        description: "Sample bdd security job",
        baseUrl: "http:\\/\\/some-internal-url",
        bddSecurityRepo: "https://github.com/cfpb/some-repo"
).build(this)

configure_block.groovy

job {
    configure { project ->
        project / builders / 'com.checkmarx.jenkins.CxScanBuilder' {
            'serverUrl'('...')
            'username'('...')
            'password'('...')
            //.....
        }
    }
}

connectivity_check.groovy

def emails = "foo@example.com"
def repos = [
        [name: 'qu', url: "https://github.com/cfpb/qu"],
        [name: 'handbook', url: "https://internal-thing-here"]
]
new SiteMonitorJobBuilder(
        name: "jenkins-outbound-connectivity-check",
        description: "Ensure Jenkins can reach out to the world. Uses a mix of git pulls and HTTP requests. We need this because our network has been known to act a fool from time to time",
        emails: emails,
        cronSchedule: "@hourly",
        urls: ["http://google.com","https://other-stuff-here"]
).build(this).with {
    multiscm {
        ScmUtils.project_repos(delegate, repos, false)
    }
}

environment_specific_stuff.groovy

import jenkins.automation.builders.*
import jenkins.automation.utils.EnvironmentUtils

// the "JAC_ENVIRONMENT" global variable is set in all of our Jenkinses, to either "DEV", "STAGE", or "PROD"

def env = EnvironmentUtils.getInstance("${JAC_ENVIRONMENT}")

if (env.isDev()) {
    new BaseJobBuilder(
        name: "a-sample-job",
        ....
    ).build(this)
}

global_variables_config.groovy

environments {
    aws {
        dev {
            globals = """
               foo=bar
            """
        }
        prod {
            globals = """
                foo=bat
            """
        }
        all {}
    }
    azure {... same but different}
    heroku {... same but different}
}

job_repo_registration.groovy

environments {
    aws {
        dev {
            reposToAutomate = [
                [projectName: "ccdb-jenkins-automation", url: "https://git-internal/ccdb-jenkins-automation"],
                [projectName: "ghe-jenkins-automation", url: "https://git-internal/ops/ghe-jenkins-automation", viewName: "Ops", viewRegex: "ops-.*", emails: "webops@example.com"],
            ]
        }

        prod {
            reposToAutomate = [...]
        }
        all {
            reposToAutomate = [
                [projectName: "jks", url: "https://internal-git/jks/jenkins-management-automation", viewName: "jks", viewRegex: "jks-.*", emails: "webops@example.com"],
            ]
        }
    }
    azure {... same but different }
    heroku {... same but different }
}

mother_seed_job.groovy

import jenkins.automation.utils.ScmUtils
import jenkins.automation.utils.EnvironmentUtils

def registrationConfigFile = readFileFromWorkspace('config/registered-projects-config.groovy')
def environmentVarsConfigFile = readFileFromWorkspace('config/global-env-vars-config.groovy')
def defaultEmail = "foo@example.com"

def host = "${JAC_HOST}"
def env = EnvironmentUtils.getInstance("${JAC_ENVIRONMENT}").getEnv()
def registrationConfig = new ConfigSlurper(host.toLowerCase()).parse(registrationConfigFile)
def environmentVarsConfig = new ConfigSlurper(host.toLowerCase()).parse(environmentVarsConfigFile)

def globalVariables =environmentVarsConfig."${env}".globals

def path = "${JENKINS_HOME}/globals.properties"
File globalConfigs = new File(path)
if (globalVariables) {
    globalConfigs.write globalVariables
}

def sharedReposToAutomate = registrationConfig."all".reposToAutomate
def reposToAutomate = registrationConfig."${env}".reposToAutomate
reposToAutomate = reposToAutomate.plus(sharedReposToAutomate);

reposToAutomate.each { project ->
    def reposToInclude = [
            project,
            [name: "automation", url: 'https://github.com/cfpb/jenkins-automation', sub_directory: 'automation']
    ]


    if (project.viewName) {

        def viewRegex = project.viewRegex ? project.viewRegex : "${project.projectName}-.*"

        listView(project.viewName) {
            columns {
                status()
                weather()
                name()
                lastSuccess()
                lastFailure()
                lastDuration()
                buildButton()
            }
            filterBuildQueue()
            filterExecutors()
            jobs {
                regex(/(?i)(${viewRegex})/)
            }
        }
    }

    job(project.projectName + '-seed-job') {

        if (project.disabled) {
            disabled()
        }
        logRotator {
            daysToKeep(90)
        }

        multiscm {
            ScmUtils.project_repos(delegate, reposToInclude, false)
        }

        triggers {
            scm 'H/5 * * * *'
        }

        configure { node ->
            node / publishers << 'hudson.plugins.logparser.LogParserPublisher' {
                unstableOnWarning(true)
                failBuildOnError(false)
                useProjectRule(true)
                projectRulePath('automation/log-parser-rules.txt')
            }
        }

        steps {

            dsl {
                external "jobs/**/*.groovy"
                additionalClasspath "automation/src/main/groovy" + "\r\n" + "src/main/groovy"
                removeAction("DELETE")
                removeViewAction("DELETE")
            }

            shell('echo ${JENKINS_HOME}')
        }

        recipients = project.emails ?: defaultEmail
        publishers {
            extendedEmail {
                recipientList(recipients)
                triggers {
                    failure {
                        sendTo {
                            recipientList()
                        }
                    }
                    fixed {
                        sendTo {
                            recipientList()
                        }
                    }
                }
            }
        }
    }
}

pipeline_job_with_job_dsl.groovy

pipelineJob("pipeline-calls-other-pipeline") {
    logRotator{
        numToKeep 30
    }
    definition {
        cps {
            sandbox()
            script("""
                node {
                    stage 'Hello world'
                    echo 'Hello World 1'

                    stage "invoke another pipeline"
                    build 'pipeline-being-called'

                    stage 'Goodbye world'
                    echo "Goodbye world"
                }
            """.stripIndent())
        }
    }
}

qu_task_builder.groovy

import javaposse.jobdsl.dsl.DslFactory
import javaposse.jobdsl.dsl.Job
import jenkins.automation.builders.BaseJobBuilder
import jenkins.automation.utils.CommonUtils

class QuTaskBuilder {
    String name
    String description
    String shellCmd
    String cronSchedule
    String scmSchedule
    String gitUrl = Config.quDeployGitUrl
    List<String> emails = Config.emails

    Job build(DslFactory factory) {
        Job baseJob = new BaseJobBuilder(
                ...
        ).build(factory)

        baseJob.with{
            CommonUtils.addInjectGlobalPasswords(delegate)
            CommonUtils.addLogParserPublisher(delegate)

            scm {
                git(gitUrl, "master")
            }

            triggers { ... }

            steps {
                if (shellCmd) {
                    shell(shellCmd)
                }
            }
        }

        return baseJob
    }
}

simple_pipeline.groovy

node {
    stage "Hello world"
    echo "Hello World"

    stage "build"
    build "BuildJob"
    
    stage "test"
    build "TestJob"
    
    stage "deploy"
    build "DeployJob"

    stage 'Goodbye world'
    echo "Goodbye world"
}

some_more.groovy

new QuTaskBuilder(
        name: "qu-find-stuck-aggregations",
        description: """
            redacted
            """.stripIndent(),
        shellCmd: """
            mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} find_stuck_processing_aggregations -H $singleTargetHost
            mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} find_too_many_unprocessed_aggregations:how_many=3 -H $singleTargetHost
            mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} find_incomplete_processed_aggregations -H $singleTargetHost
            """.stripIndent(),
        cronSchedule: '@hourly'
).build(this).with {
    publishers {
        downstream('qu-restart-incomplete-processed-aggregations', 'FAILURE')
    }
}

new QuTaskBuilder(
        name: "qu-restart-incomplete-processed-aggregations",
        description: "restarts jobs marked as processsed but for which no output collection exists",
        shellCmd: "mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} restart_incomplete_processed_aggregations -H $singleTargetHost"
).build(this)

new QuTaskBuilder(
        name: "qu-delete-old-aggregations",
        description: "Deletes old, unused aggregations",
        shellCmd: "mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER}  fab -u deploy -i ${Config.sshKey(env)} evict_from_aggregation_cache -H $singleTargetHost",
        cronSchedule: '@daily'
).build(this)

new QuTaskBuilder(
        name: "qu-cache-aggregations-for-year",
        description: "Finds and restarts existing aggregations that should be rebuilt because they should contain records for a new year",
        shellCmd: """
            mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} cache_aggregations_for_year:year="\${YEAR}" -H $singleTargetHost
            mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} restart_aggregations_for_collection:collection_name=census_tracts -H $singleTargetHost
            mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} restart_aggregations_for_collection:collection_name=institutions -H $singleTargetHost
            """.stripIndent(),
).build(this).with {
    parameters {
        stringParam('YEAR', '2014', 'year of aggregation to cache')
    }
}

new QuMatrixJobBuilder(
        name: "qu-test-deploy-user",
        description: "Checks that the deploy user has access to the application servers",
        shellCmd: "fab -u deploy -i ${Config.sshKey(env)} test_deploy_user -H \$HOST",
).build(this).with {
    triggers {
        cron("H/15 * * * *")
    }
    axes {
        text("HOST", env.isDev() ? Config.quDevHosts : Config.quProdHosts)
    }
}

primeRamHosts = env.isDev() ? "\${qu_mongo_primary_domains}" : "\${qu_mongo_primary_domains},\${qu_mongo_secondary_domains}"
new QuTaskBuilder(
        name: "qu-mongod-prime-ram",
        description: "Ensures RAM is primed. On dev, we only prime primaries because the secondaries are too small to prime. On Prod, we prime primaries and secondaries",
        shellCmd: "mongo_username='agent' mongo_password=\${MONGO_AGENT_PASSWORD} fab -u deploy -i ${Config.sshKey(env)} prime_ram -H ${primeRamHosts}",
).build(this)

the_simplest_job_ever.groovy

job('example-job-from-job-dsl') {
    scm {
        github('jenkinsci/job-dsl-plugin', 'master')
    }
    triggers {
        cron("@hourly")
    }
    steps {
        shell("echo 'Hello World'")
    }
}

use_qu_task_builder.groovy

new QuTaskBuilder(
        name: "qu-restart-incomplete-processed-aggregations",
        description: "restarts jobs marked as processsed but for which no output collection exists",
        shellCmd: "mongo_username=aggregation_manager mongo_password=\${MONGO_AGGREGATION_MANAGER} fab -u deploy -i ${Config.sshKey(env)} restart_incomplete_processed_aggregations -H $singleTargetHost"
).build(this)