Merge pull request #77 from HRMPW/master

Adding Declarative Examples

Author: R. Tyler Croy

declarative-examples/README.md

@@ -0,0 +1,28 @@
+# Declarative Examples
+
+This folder is a home for snippets, tips and tricks and examples for writing Declarative Pipelines with the
+[Jenkins Pipeline plugin](https://github.com/jenkinsci/workflow-plugin/blob/master/README.md).
+
+# Layout
+
+The repository is broken up into two directories currently:
+
+* *simple-examples* - simple pipelines with one or two stages that illustrate or test a single part of Declarative Pipeline
+* *jenkinsfile-examples* - for examples of using `Jenkinsfile`s checked into repositories.
+
+
+When contributing new examples please put them into the appropriate directory above. Make sure your script is commented so that others can understand how it works, why it works, etc.
+
+# License
+
+All contributions are under the MIT license, like Jenkins itself.
+
+# Pull requests
+
+We want them!
+
+# External resources
+
+* [Pipeline scripts collection of the Docker team](https://github.com/docker/jenkins-pipeline-scripts)
+* [Pipeline scripts collection of the Fabric8 team](https://github.com/fabric8io/jenkins-pipeline-library)
+* [Pipeline scripts collection of the Funkwerk](https://github.com/funkwerk/jenkins-workflow)

declarative-examples/jenkinsfile-examples/README.md

@@ -0,0 +1,3 @@
+# Jenkinsfile examples
+
+This directory contains example Jenkinsfiles written in Declarative Pipeline Syntax. 

declarative-examples/jenkinsfile-examples/mavenDocker.groovy

@@ -0,0 +1,105 @@
+pipeline {
+
+  /*
+   * Run everything on an existing agent configured with a label 'docker'.
+   * This agent will need docker, git and a jdk installed at a minimum.
+   */
+  agent {
+    node {
+      label 'docker'
+    }
+  }
+
+  // using the Timestamper plugin we can add timestamps to the console log
+  options {
+    timestamps()
+  }
+
+  environment {
+    //Use Pipeline Utility Steps plugin to read information from pom.xml into env variables
+    IMAGE = readMavenPom().getArtifactId()
+    VERSION = readMavenPom().getVersion()
+  }
+
+  stages {
+    stage('Build') {
+      agent {
+        docker {
+          /*
+           * Reuse the workspace on the agent defined at top-level of Pipeline but run inside a container.
+           * In this case we are running a container with maven so we don't have to install specific versions
+           * of maven directly on the agent
+           */
+          reuseNode true
+          image 'maven:3.5.0-jdk-8'
+        }
+      }
+      steps {
+        // using the Pipeline Maven plugin we can set maven configuration settings, publish test results, and annotate the Jenkins console
+        withMaven(options: [findbugsPublisher(), junitPublisher(ignoreAttachments: false)]) {
+          sh 'mvn clean findbugs:findbugs package'
+        }
+      }
+      post {
+        success {
+          // we only worry about archiving the jar file if the build steps are successful
+          archiveArtifacts(artifacts: '**/target/*.jar', allowEmptyArchive: true)
+        }
+      }
+    }
+
+    stage('Quality Analysis') {
+      parallel {
+        // run Sonar Scan and Integration tests in parallel. This syntax requires Declarative Pipeline 1.2 or higher
+        stage ('Integration Test') {
+          agent any  //run this stage on any available agent
+          steps {
+            echo 'Run integration tests here...'
+          }
+        }
+        stage('Sonar Scan') {
+          agent {
+            docker {
+              // we can use the same image and workspace as we did previously
+              reuseNode true
+              image 'maven:3.5.0-jdk-8'
+            }
+          }
+          environment {
+            //use 'sonar' credentials scoped only to this stage
+            SONAR = credentials('sonar')
+          }
+          steps {
+            sh 'mvn sonar:sonar -Dsonar.login=$SONAR_PSW'
+          }
+        }
+      }
+    }
+
+    stage('Build and Publish Image') {
+      when {
+        branch 'master'  //only run these steps on the master branch
+      }
+      steps {
+        /*
+         * Multiline strings can be used for larger scripts. It is also possible to put scripts in your shared library
+         * and load them with 'libaryResource'
+         */
+        sh """
+          docker build -t ${IMAGE} .
+          docker tag ${IMAGE} ${IMAGE}:${VERSION}
+          docker push ${IMAGE}:${VERSION}
+        """
+      }
+    }
+  }
+
+  post {
+    failure {
+      // notify users when the Pipeline fails
+      mail to: '[email protected]',
+          subject: "Failed Pipeline: ${currentBuild.fullDisplayName}",
+          body: "Something is wrong with ${env.BUILD_URL}"
+    }
+  }
+}

declarative-examples/simple-examples/README.md

@@ -0,0 +1,6 @@
+# Simple Examples
+
+This folder contains simple Declarative Pipelines with one or two stages.
+The pipelines in this folder are examples of specific features or useful in testing.
+
+The naming convention is based on the primary feature being exhibited.

declarative-examples/simple-examples/credentialsMixedEnvironment.groovy

@@ -0,0 +1,31 @@
+pipeline {
+  environment {
+    // environment variables and credential retrieval can be interspersed
+    SOME_VAR = "SOME VALUE"
+    // this assumes that "cred1" has been created on Jenkins Credentials
+    CRED1 = credentials("cred1")
+    INBETWEEN = "Something in between"
+    // this assumes that "cred2" has been created in Jenkins Credentials
+    CRED2 = credentials("cred2")
+    // Env variables can refer to other variables as well
+    OTHER_VAR = "${SOME_VAR}"
+  }
+
+  agent any
+
+  stages {
+    stage("foo") {
+      steps {
+        // environment variables are not masked
+        sh 'echo "SOME_VAR is $SOME_VAR"'
+        sh 'echo "INBETWEEN is $INBETWEEN"'
+        sh 'echo "OTHER_VAR is $OTHER_VAR"'
+
+        // credential variables will be masked in console log but not in archived file
+        sh 'echo $CRED1 > cred1.txt'
+        sh 'echo $CRED2 > cred2.txt'
+        archive "**/*.txt"
+      }
+    }
+  }
+}

declarative-examples/simple-examples/credentialsUsernamePassword.groovy

@@ -0,0 +1,32 @@
+pipeline {
+    environment {
+      /*
+       * Uses a Jenkins credential called "FOOCredentials" and creates environment variables:
+       * "$FOO" will contain string "USR:PSW"
+       * "$FOO_USR" will contain string for Username
+       * "$FOO_PSW" will contain string for Password
+       */
+      FOO = credentials("FOOcredentials")
+    }
+
+    agent any
+
+    stages {
+        stage("foo") {
+            steps {
+                // all credential values are available for use but will be masked in console log
+                sh 'echo "FOO is $FOO"'
+                sh 'echo "FOO_USR is $FOO_USR"'
+                sh 'echo "FOO_PSW is $FOO_PSW"'
+
+                //Write to file
+                dir("combined") {
+                    sh 'echo $FOO > foo.txt'
+                }
+                sh 'echo $FOO_PSW > foo_psw.txt'
+                sh 'echo $FOO_USR > foo_usr.txt'
+                archive "**/*.txt"
+            }
+        }
+    }
+}

declarative-examples/simple-examples/dockerfileAlternativeName.groovy

@@ -0,0 +1,21 @@
+pipeline {
+  agent {
+    dockerfile {
+      /*
+        * The Default is "Dockerfile" but this can be changed.
+        * This will build a new container based on the contents of "Dockerfile.alternate"
+        * and run the pipline inside this container
+        */
+      filename "Dockerfile.alternate"
+      args "-v /tmp:/tmp -p 8000:8000"
+    }
+  }
+  stages {
+    stage("foo") {
+      steps {
+        sh 'cat /hi-there'
+        sh 'echo "The answer is 42"'
+      }
+    }
+  }
+}

declarative-examples/simple-examples/dockerfileDefault.groovy

@@ -0,0 +1,19 @@
+pipeline {
+  agent {
+    dockerfile {
+      /*
+       * This assumes that a "Dockerfile" is in the current workspace
+       * A new container will be build with the args below and the pipeline will run inside that container.
+       */
+      args "-v /tmp:/tmp -p 8000:8000"
+    }
+  }
+  stages {
+    stage("foo") {
+      steps {
+        sh 'cat /hi-there'
+        sh 'echo "The answer is 42"'
+      }
+    }
+  }
+}

declarative-examples/simple-examples/environmentInStage.groovy

@@ -0,0 +1,25 @@
+pipeline {
+  agent any
+
+  environment {
+    // FOO will be available in entire pipeline
+    FOO = "PIPELINE"
+  }
+
+  stages {
+    stage("local") {
+      environment {
+        // BAR will only be available in this stage
+        BAR = "STAGE"
+      }
+      steps {
+        sh 'echo "FOO is $FOO and BAR is $BAR"'
+      }
+    }
+    stage("global") {
+      steps {
+        sh 'echo "FOO is $FOO and BAR is $BAR"'
+      }
+    }
+  }
+}

declarative-examples/simple-examples/environmentNonLiteral.groovy

@@ -0,0 +1,40 @@
+pipeline {
+  /*
+   * The environment section is used for setting environment variables and will allow for
+   * expanding variable and other methods to set those values as long as the return type is a String.
+   * String escaping in Groovy can affect the behavior here. Please refer here for detailed explainations
+   * http://docs.groovy-lang.org/latest/html/documentation/#all-strings
+   * The 'readMavenPom()' method is provided by the Pipeline Utility Steps plugin
+   */
+  environment {
+    FOO = "BAR"
+    BUILD_NUM_ENV = currentBuild.getNumber()
+    ANOTHER_ENV = "${currentBuild.getNumber()}"
+    INHERITED_ENV = "\${BUILD_NUM_ENV} is inherited"
+    ACME_FUNC = readMavenPom().getArtifactId()
+  }
+
+  agent any
+
+  stages {
+    stage("Environment") {
+      steps {
+        sh 'echo "FOO is $FOO"'
+        // returns 'FOO is BAR'
+
+        sh 'echo "BUILD_NUM_ENV is $BUILD_NUM_ENV"'
+        // returns 'BUILD_NUM_ENV is 4' depending on the build number
+
+        sh 'echo "ANOTHER_ENV is $ANOTHER_ENV"'
+        // returns 'ANOTHER_ENV is 4' like the previous depending on the build number
+
+        sh 'echo "INHERITED_ENV is $INHERITED_ENV"'
+        // returns 'INHERITED_ENV is ${BUILD_NUM_ENV} is inherited'
+        // The \ escapes the $ so the variable is not expanded but becomes a literal
+
+        sh 'echo "ACME_FUNC is $ACME_FUNC"'
+        // returns 'ACME_FUNC is spring-petclinic' or the name of the artifact in the pom.xml
+      }
+    }
+  }
+}