Jenkins Pipelines and their dirty secrets 1.
Tags: jenkins, jobdsl, pipelines, ci
Published: 2017-07-24 10:46:41

---
title: Jenkins Pipelines and their dirty secrets 1.
published: true
description: Introducing my series about pipelines, and pipeline basics.
cover_image: https://thepracticaldev.s3.amazonaws.com/i/myh4a4tzvda1g83lyjpx.jpg
tags: jenkins, job-dsl, pipelines, ci
---
# Introduction:

I just had started my first job as a software developer, when the first news about the <a href="https://github.com/jenkinsci/job-dsl-plugin/wiki/Migration#migrating-to-162" target="_blank">deprecation of the Build Flow Plugin</a> came around. At that time the company had already had a huge, complex CI, with a lot of workflow organized Jenkins jobs. It was clear that a quick fix will be to simply *replace the build flow jobs with pipelines, and keep the party going as it is*. And of course who would be the best to fix this minor issue, if not the new intern! The stage was set, and I was sent to wrap the job up.
    ***...but there was a catch***
As I realized no one knew the syntax of this esoteric pipeline scripts yet, so I had to figure out how to use them to exactly replace the build flow scripts with it. There came a lot of interesting information about pipelines, that made me rethink how it has to be used to replace certain elements in build flows.
During my research, I had not found any comprehensive source on the web about specific use-cases of certain pipeline steps. Here I'm planning to collect and share all my findings. I will specifically concentrate on how to replace certain solutions done before by build flows, or other old deprecated plugins like Active Choice. 
***Anyway I know you didn't come for the story so let's see the code!***

---
## Pipeline Basics
The first thing you should do if you are getting started with pipelines is to read the <a href="https://jenkins.io/doc/book/pipeline/" target="_blank">official pipeline documentation.</a>
Here you can learn what a pipeline is, what the Jenkinsfile is, and all the basics, that I'm not going to explain in detail.
This documentation, however, has a dirty little secret, a piece of information you can easily disregard.  ***Pipeline scripts can be written in two ways: Declarative Style and Scripted Style.***
### Example of a Declarative Pipeline script
Luckily Declarative pipelines are well documented, you can find a lot of examples and documentation on <a href="https://jenkins.io/doc/book/pipeline/syntax/" target="_blank">this page</a>. Anyhow, here is an example by me. Notice that here **I specifically created a script which is implementing a job scheduling solution, just as a build flow scripts did before.**
Also notice that a Declarative Pipeline always has a `pipeline {}` block with an `agent any` part in it, and is separated into stages.
```groovy
#!/usr/bin/env groovy

pipeline {
    agent any
    stages {
        stage("build") {
            steps {
                retry(3) { build("build-job") }
            }
        }
        stage("tests") {
            steps {
                parallel (
                    "unit test" : {
                        build("unit-test-job")
                    },
                    "component test" : {
                        build("component-test-job")
                    }
                )
            }
        }
    }
}

```
### Example of a Scripted Pipeline script
Scripted Pipeline syntax, on the other hand, offers a general purpose DSL syntax. Scripted Pipelines always are enclosed within a `node {}` block.  Notice that I used a `stage` but it is not necessary. You can read about specific Scripted Pipeline steps, at the [documentations page](https://jenkins.io/doc/pipeline/steps/), but why would you do that? From any jenkins you can reach a pipeline [snippet generator](https://qa.nuxeo.org/jenkins/pipeline-syntax/), which helps you figure out the syntax. Anyway here is an example.
```groovy
#!/usr/bin/env groovy

node {
    def workspace = pwd()
    echo "Building Job at ${workspace}"
    build 'builder-job'
    
    stage('Shell') {
        try {
            sh returnStdout: true, script: 'demo.sh'
        }
        catch (exc) {
            echo 'Something failed!'
        }
    }
}
```

Usefull to know, that - ***yes!*** - You can have both syntaxes in a Jenkinsfile.

### Scripted Pipeline IN Declarative Pipeline
In case it is necessary you can actually create an embedded Scripted Pipeline block IN a Declarative Pipeline step! We use the `script{}` block for this. Here's how it is:
```groovy
#!/usr/bin/env groovy

pipeline {
    agent any
    stages {
        stage("robot test") {
            steps {
                script {
                    MYLIST = []
                    MYLIST += "param-one"
                    MYLIST += "param-two"
                    MYLIST += "param-three"
                    MYLIST += "param-four"
                    MYLIST += "param-five"

                    for (def element = 0; element < MYLIST.size(); element++) {
                        build(
                            job: 'parameterized-job',
                            parameters: [
                                [
                                    $class: 'StringParameterValue',
                                    name: 'MYLIST',
                                    value: MYLIST[element]
                                ]
                            ]
                        )
                    }
                }
            }
        }
    }
}
```
**Notice that here I used the scripted block to be able to use for loop.**
In the later chapters we will discover several other use cases as well.