2.Jenkins进阶之流水线pipeline语法入门学习

Pipeline 命令行接口 杂项 代理启动器和控制器 构建触发器  2.6 	2 年 3 月 ago 
# 说明：一套插件，让您编排自动化，简单或复杂。更多细节请参阅Jenkins的 Pipeline代码。

(root)
+- src                     # Groovy source files
|   +- org
|     +- foo
|       +- Bar.groovy      # for org.foo.Bar class
+- vars
|   +- foo.groovy          # for global 'foo' variable
|   +- foo.txt             # help for 'foo' variable
+- resources               # resource files (external libraries only)
|   +- org
|       +- foo
|           +- bar.json    # static helper data for org.foo.Bar

def x="abc"
def y=1

System.out.println x
println t

def var = """
This is Variable!
<br>
Test defiend
"""

def getSecure(String Ticket_Token) {
  def token = "Ticket Token is " + Ticket_Token
  return token
}

println getSecure("weiyigeek")  //Ticket Token is weiyigeek

// # 闭包的定义方法：
def codeBlock = {print "hello world!"}
// codeBlock() //

// # 闭包的另类用法:
// 定义一个stage函数
def stage(String name, closue) {
  println name
  def closue() {
    println "闭包调用的 closue function!"
  }
}
stage("stage name",{println "closue"})

class Greet {
  def name
  Greet(who) { name = who[0].toUpperCase() + who[1..-1] }
  def salute() { println "Hello " + name + "!" }
}
 
g = new Greet('world')  // create object
g.salute()   // Hello World!

// Jenkinsfile (Scripted Pipeline)
// #结构1
node {
    // @变量定义
    def mvnHome
    // #结构2
    stage('Preparation') {
      // # 结构3 - 它就是 Step 基本操作单元
      echo "Scripted Pipeline"
    }
}

# Scripted Pipeline 脚本式
node {
  stage('Clone') {
    echo "1.Clone Stage"
  }
  stage('Test') {
    echo "2.Test Stage"
  }
  stage('Build') {
    echo "3.Build Stage"
  }
  stage('Deploy') {
    echo "4. Deploy Stage"
  }
}

Started by user admin
Running in Durability level: MAX_SURVIVABILITY
[Pipeline] Start of Pipeline
[Pipeline] node
Running on Jenkins in /var/lib/jenkins/workspace/simple-pipeline-demo
[Pipeline] {
[Pipeline] stage
[Pipeline] { (Clone)
[Pipeline] echo
1.Clone Stage
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (Test)
[Pipeline] echo
2.Test Stage
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (Build)
[Pipeline] echo
3.Build Stage
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (Deploy)
[Pipeline] echo
4. Deploy Stage
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS

def name
def item3
def with_underscore
def $dollarStart

def 3tier // 不能以数字开始
def a+b // "+"号是非法字符
def a#b // #号也不是可用的字符

foo.as
foo.assert
foo.break
foo.case
foo.catch

def name = 'yjiyjgie'
println name.class // class java.lang.String

def strippedFirstNewline = '''line one
line two
line three
'''

// 可以写成下面这种形式，可读性更好

def strippedFirstNewline = '''\
line one
line two
line three
'''

def normalStr = "yjiyjige" // 这是一个java.lang.String

def interpolatedStr = "my name is ${normalStr}" // 这是一个groovy.lang.GString

def name = 'Guillaume'          // a plain string
def greeting = "Hello ${name}" // name变量的值会被替换进去
assert greeting.toString()  == 'Hello Guillaume'

//当使用点号表达式时，可以只用$代替${}：
def person = [name: 'Guillaume', age: 36]
println "$person.name is $person.age years old"

// 插值占位符中还支持闭包，而闭包的一个好处是惰性求值（lazy evaluation）：
def number = 1
def eagerGString = "value == ${number}" // 普通形式
def lazyGString = "value == ${-> number}" // 这是一个闭包

println eagerGString // == "value == 1"
println lazyGString  // == "value == 1"

number = 2
println eagerGString // == "value == 1" // eagerGString已经被固定下来了
println lazyGString  // == "value == 2" // lazyGString的值会被重新计算

// 当一个方法的需要一个java.lang.String变量，而我们传递的是一个groovy.lang.GString实例时，GString的toString方法会被自动调用，看起来像我们可以直接将一个GString赋值给一个String变量一样。

def key = "a"
def m = ["${key}": "letter ${key}"] // key类型是一个GString
assert m["a"] // == null // 用一个普通String类型的key去取值取代的值为null 而并非 letter a

def number = 3.14
println "$number.toString()" // 这里会报异常,因为相当于"${number.toString}()"
println "${number.toString()} -- Other String、" // 这样就正常了

// 如果要强制指明一个数字的字面量类型，可以给字面量加上类型后缀：
BigInteger 使用G或g
Long 使用L或l
Integer 使用I或i
BigDecimal 使用G或g
Double 使用D或d
Float 使用F或f

def a = 1
assert a instanceof Integer

// Integer.MAX_VALUE
def b = 2147483647
assert b instanceof Integer


// Integer.MAX_VALUE + 1
def c = 2147483648
assert c instanceof Long


// Long.MAX_VALUE
def d = 9223372036854775807
assert d instanceof Long

// Long.MAX_VALUE + 1
def e = 9223372036854775808
assert e instanceof BigInteger

def decimal = 123.456
println decimal.getClass() // class java.math.BigDecimal

#  定义一个 list 隐式
def numbers = [1, 2, 3]
println numbers.getClass() # // class java.util.ArrayList

def arrayList = [1, 2, 3]  # // 默认类型
# assert arrayList instanceof java.util.ArrayList

# 如果要使用其它类型的列表（如：LinkedList）可以使用as操作符或显式分配给一个指定类型的变量：
def linkedList = [2, 3, 4] as LinkedList # // 使用as操作符
# assert linkedList instanceof java.util.LinkedList

LinkedList otherLinked = [3, 4, 5]         # // 显式指明类型
# assert otherLinked instanceof java.util.LinkedList

// 定义一个list
def letters = ['a', 'b', 'c', 'd']
assert letters[0]  //  == 'a'
assert letters[1]  // == 'b'
assert letters[-1] // == 'd' 从后面访问 倒数第一个
assert letters[-2] // == 'c' // 从后面访问 倒数第二个

// 元素修改
letters[2] = 'C'    
assert letters[2]   //  == 'C'

letters << 'e' // 往最后面添加元素
assert letters[4] == 'e'
assert letters[-1] == 'e'
assert letters[1, 3] == ['b', 'd']      // 提取指定元素
assert letters[2..4] == ['C', 'd', 'e'] // 支持范围（ranges）操作

// 二维列表
def multi = [[0, 1], [2, 3]]
assert multi[1][0] == 2

def mylist = [1,2,3,4,5,"weiyigeek.top","devops","jenkins"]
 
// 通过索引获取列表元素
println(numList[5])  // weiyigeek.top

// 列表的长度
println(mylist.size())

// 计算列表中元素出现的次数
println(numList.count(4))

// 判断元素是否为空
println(mylist.isEmpty())

// 列表元素增删
// + 操作符性能比较低,从而建议使用<<
def newlist = mylist.add("gitlab")
println(mylist + "jenkins")
println(mylist - "devops")
println(mylist << "java")

// 列表元素移除
println(mylist.remove("java")) // 移除指定元素,成功则返回True
println(mylist.removeAll())

// 整数取最值、求和
println(mylist.min())
println(mylist.max())
println(mylist.sum())

// 列表去重
println(mylist.unique())
 
// 列表反转
println(mylist.reverse())
 
// 列表排序
println(mylist.sort())
 
// 取交集、判断是否有交集
println(mylist.intersect([2,3]))
println(mylist.disjoint([2,3]))

// 判断列表是否包含元素
println(mylist.contains("devops"))
// 或者使用in关键字
def isContains = 'devops' in strList
println(isContains)

// 列表拼接插入到中间
println(mylist.join("geek"))

// 列表克隆
def list = ['a', 'b', 'c']
def newlist = list.clone()

// 合并嵌套列表
def mylist = [1,2,3,[4,5],5,"weiyigeek.top","devops","jenkins"]
println(mylist.flatten())

//扩展列表定义方式
String[] stus = ["Weiyi", "Geek","Top"]
def numList = [1,2,3,4,5,6,6] as int[]

// 将list集合通过调用collect()把list中的值*2构成一个新的集合，构成的新集合是[2,4,6]
def list = [1, 2, 3]
def newList = list.collect { it * 2 }
def newList = list*.multiply(2)

// 把元素重复的复制几次
def list = [1,2,3]
def newList = list*3
def newList = list.multiply(2)

// 使用findAll()找到所有匹配的元素
println(list.findAll{ it > 1 })  // [2,3]

// 判断集合中的值是否都小于5(与)
def isTrue = list.every { it < 5 }

// 判断集合中的值是否存在小于5(或)
def isTrue = list.any { it < 5 }

// 使用inject(index) 方法 集合中元素相加后再加index
def list = [1,2,4]
def num = list.inject(93){ count, item -> count + item }
println (num) // 100

// 使用findIndexOf()查找第一个元素匹配标准的索引
def strList =  ['a', 'b', 'c', 'd', 'e']
def index =  strList.findIndexOf {
  it in ['c', 'e', 'g']
}
println(index)  // 2

// 使用indexOf()查找集合某个值对应的下标值
def index =  strList.indexOf('c')  
println(index)  // 如果没有找到就返回-1否则返回下标值

// key部分其实是字符串
def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']
assert colors['red'] == '#FF0000' // 使用中括号访问
assert colors.green == '#00FF00' // 使用点表达式访问

// 两种方式
colors['pink'] = '#FF00FF'
colors.yellow = '#FFFF00'

assert colors.pink      // == '#FF00FF'
assert colors['yellow'] // == '#FFFF00'
assert colors instanceof java.util.LinkedHashMap // 默认使用LinkedHashMap类型

def keyVal = 'name'
def persons = [keyVal: 'Guillaume'] // 非常注意: 此处的key是字符串keyVal而不是name

assert !persons.containsKey('name')
assert persons.containsKey('keyVal')

// 如果要使用一个变量作为key，需要用括号括住：
def keyVal = 'name'
def persons = [(keyVal): 'Guillaume'] // 相当于[ 'name' : 'Guillaume' ]

assert persons.containsKey('name')
assert !persons.containsKey('keyVal')

// # syntax
if(condition) {
  statement #1
  statement #2
  ...
}

//@ 流程控制Groovy表达式如if/else条件语句
if (env.BRANCH_NAME == 'master') {
  echo 'I only execute on the master branch'
} else {
  echo 'I execute elsewhere'
}

for(variable declaration;expression;Increment) {
  statement #1
  statement #2
  …
}

// 常规
for(int i = 0;i<5;i++) {
  println(i);
}
// List 循环迭代
def mylist = [1,2,3,"weiyigeek.top","devops","jenkins"]
mylist.each{ println(it) }
// 'it'是当前元素，而'i'是索引
mylist.eachWithIndex { it, i ->  println "$i: $it" }
mylist.eachWithIndex { count, count -> count + item }

switch () {
  case '1':
    echo 1
    break
  case '2':
    echo 2
    break
  default:

}

try {
      helloWorld()  // == Scripted Pipeline - Hello Wrold - STARTED - 1024!
      dir("place") {
          sh 'id'  // == uid=112(jenkins) gid=117(jenkins) groups=117(jenkins)
      }
  } catch (e) {
      // If there was an exception thrown, the build failed
      currentBuild.result = "FAILED"
      throw e
  } finally {
      println "success or failure, always send notifications"   // == Success or failure, always send notifications 
  }

// 1.函数命令以及函数参数
def methodName(String param){
  println param  //Method code
}
// 2.支持函数重载，当参数个数不同时，函数名称可以同名
def methodName(String param = 'default1',int number = 1024) {
  println "Hello Wrold function - ${param} - ${age}!" 
  println param+" "+age
  // 如果没有显式地使用return关键字，则返回函数最后一行语句的运行结果。
  return "Hello Wrold function - ${param} - ${age}!"
}
// 3.Groovy支持不定长参数
def methodName(... param){
  println param[0]
}
// 4.函数可以赋值给其它函数，使用语法标记&将函数赋予新的函数。
def printHello=this.&methodName

node { 
  stage('函数调用') { 
    res00 = methodName("WeiyiGeek")
    res01 = methodName("WeiyiGeek",1024)
    res02 = printHello("WeiyiGeek")
  } 
}

// # 闭包格式
def xxx = { params -> code }
def xxx={code} //或者

// 1.闭包可访问外部变量
def str="hello world"
def closure={
  println str
}
closure()  //hello world

// 2.闭包调用的两种方式
def closure = {
  param -> println param
}
closure("hello world")
closure "hello world"
closure.call("hell call")

// 3.闭包是有返回值的，默认最后一行语句就是该闭包的返回值，如果最后一行语句没有不输入任何类型，闭包将返回null
def noReturn={
    println "hello world"
}
println noReturn()
//hello world
//null

// 4.闭包可预定参数，如没有预定则有一个隐式的默认参数it，值得非常注意闭包中参数名称不能与闭包内或闭包外的参数名重名。
def closure={
  println "hello $it"
}
closure("admin")
 
def closure={
  param01,param02,param03->println param01+param02+param03
}
closure "hello","world","ok"
 
def closure={
  println it
}
closure "hello world"

// 5.闭包可以作为一个参数传递给另一个闭包，也可以在闭包中返回一个闭包。
def toTriple = { n -> n * 3 }
def runTwice = { a, c -> c(c(a)) }
println runTwice(5, toTriple)  // 15 * 3 =  45
 
def times = { x -> { y -> x * y } }
println times(3)(4)//12

// 6.当闭包作为闭包或方法的最后一个参数，可以将闭包从参数圆括号中提取出来接在最后。
def runTwice = { a, c -> c(c(a)) }
println runTwice(5, { it * 3 }) //45 usual syntax
//当多个闭包作为最后一个参数时
def runTwoClosures = { a, c1, c2 -> c1(c2(a)) }
assert runTwoClosures(5, { it * 3 }, { it * 4 }) == 60 //usual syntax

// 7.闭包接受参数的规则，会将参数列表中所有有键值关系的参数，作为一个map组装，传入闭包作为调用闭包的第一个参数。
def f= {m, i, j-> i + j + m.x + m.y }
println f(6, x:4, y:3, 7)//20


// 8.如果闭包的参数声明中没有list，那么传入参数可以设置为list，里面的参数将分别传入闭包参数。
def c = { a, b, c -> a + b + c }
def list = [1, 2, 3]
println c(list) // 6

class Book{
  def title
  String author
  private int price
  // 是否与Java的类差不多
  public Book(title){
    this.title=title
  }
  // 默认public
  boolean order(int isbn){
    true
  }
  def title(){
    "Booke Title"
  }
}

// 实例化对象
Book book=new Book("Hello Groovy")
book.order(1001)

// 使用说明
book.title   //获取属性
book.title() //访问方法

// 例如 title 属性的 getter 与 setter 方法。
Book book=new Book("Hello Groovy")
println book.getTitle() // Hello Groovy
 
book.setTitle("New Groovy")
println book.getTitle() // New Groovy
println book.title      // New Groovy

// Hello 类中有一个的公共静态 hello 方法
class Hello{
  public static String hello(){
      return "hello"
  }
}
class World{
  public static String world(){
    return "world"
  }
}
 
println Hello.hello()+World.world()
 
def helloWorld(){
return "hello world"
}

def demo_string = "Hello WeiyiGeek"
out1 = demo_string.split("l")       # [He, , o WeiyiGeek]
out2 = demo_string.tokenize("l")    # [He, o WeiyiGeek]

out3 = demo_string.split('lo')      # [Hel, WeiyiGeek]
out4 = demo_string.tokenize('li')   # [Hel, We, y, Geek]

out5 = demo_string.split(/We\w{3}/) # [Hello , Geek]

node {
  // 变量定义
  def foo
  // 字符串
  def project="HelloWorld"
  // 单引号字符串（Single quoted string）不能解析变量
  def name='weiyigeek - ${project}'
  // 三单引号字符串（Triple single quoted string）不能解析变量
  def line='''\
  Line one
  Line ${project}
  '''
  // 定义字典Maps
  def person = [name: 'WeiyiGeek', age: 96]  

  
  stage('Scripted Pipeline Syntax') {
    // (1) 变量声明
    foo="Identifiers"
    // (2) 变量调用
    echo "${foo} -- ${project}" // == Identifiers -- HelloWorld
    // (3) 字符串输出
    echo "my name is ${name}" // == my name is weiyigeek - ${project}
    // (4) 多行字符串输出
    echo "${line}" /* ==
    Line one
    Line ${project}
    */
    
    // (5) 变量对象属性输出
    echo "$person.name is $person.age years old" // == WeiyiGeek is 96 years old
    
    name = 'WeiyiGeek'         
    project = "my name is ${name}"
    def greeting = "Hello ${name}" // name变量的值会被替换进去
    
    // (6) 字符串格式化声明
    assert greeting.toString()
    println "${project.toString()}" //调用方法后直接输出 ==  my name is  WeiyiGeek
    
    // 闭包
    def number = 1
    def eagerGString = "value == ${number}"   // 普通形式
    def lazyGString = "value == ${-> number}" // 这是一个闭包
    println eagerGString // == value == 1
    println lazyGString  // 此处输出为空 (value == 1)
    number=1024
    echo "-----------------"
    println eagerGString // == value == 1
    println lazyGString  // 此处输出为空 (value == 1024)


    // (7) 变量类型输出
    println "变量name类型："+name.class+", \n 变量project类型: "+project.class+", \n 变量greeting类型: "+greeting.class 
    /* == 变量name类型：class java.lang.String, 
          变量project类型: class org.codehaus.groovy.runtime.GStringImpl, 
          变量greeting类型: class org.codehaus.groovy.runtime.GStringImpl */
    
    
    // (8) 数值类型与类型强转
    def decimal = 123.456
    println "${decimal.getClass()} -- ${decimal} " // ==  class java.math.BigDecimal -- 123.456
    //assert decimal instanceof BigDecimal
    
    // (9) 数组列表
    def arrayList = [1,2,3,"number"]
    println arrayList[0]   // == 1
    arrayList << '5' 
    echo "assert ${arrayList[0]} ---  ${arrayList[-2]} --- ${arrayList[-1]}"   // == assert 1 ---  number --- 5
    
    def multi = [[0, 1], [2, 3]]  // 二维数组
    echo "assert ${multi[1][0]}"  // == 2
    
    // (10) 字典Map
    def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']
    colors['pink'] = '#FF00FF'  
    colors.yellow = '#FFFF00'
    println "colors 类型 : "+ colors.pink.class + ", assert colors.pink : " + colors.pink + ",assert colors['yellow'] : " + colors['yellow']
    /*       colors 类型 : class java.lang.String, assert colors.pink : #FF00FF,assert colors['yellow'] : #FFFF00     */
    
    // 如果要使用一个变量作为key（缺省为字符串），需要用括号括住：
    def keyVal = 'name'
    def persons = [(keyVal): 'WeiyiGeek'] // 相当于[ 'name' : 'WeiyiGeek' ]
    println "key is name: " + persons.containsKey('name') + " , Key not is KeyVal : " + !persons.containsKey('keyVal')
    /* key is name: true , Key is  KeyVal : true */
    
    // (11) 条件语句 - if - for - switch
    if ( keyVal == 'name' ) {
      echo "keyVal value is name"   // == keyVal value is name
    } else {
      echo "keyVal value is not name"
    }
    
    if (env.BRANCH_NAME == 'master') {
      echo 'I only execute on the master branch'
    } else {
      echo 'I execute elsewhere'
    }

    for (int i=0; i < 5; i++) {
      println arrayList[i]  // 如果越界显示则 `null` // == 1,2,3,number,5
    }
    
    def option = "deploy"
    switch ("${option}") {
      case 'deploy':
          echo "deploy"   // == deploy
          break
      case 'rollback':
          echo "rollback"
          break
      default:
          echo "default"
    }
      
    // (12) 异常捕获
    try {
        helloWorld()  // == Scripted Pipeline - Hello Wrold - STARTED - 1024!
        dir("place") {
            sh 'id'  // == uid=112(jenkins) gid=117(jenkins) groups=117(jenkins)
        }
    } catch (e) {
        // If there was an exception thrown, the build failed
        currentBuild.result = "FAILED"
        throw e
    } finally {
        println "success or failure, always send notifications"   // == Success or failure, always send notifications 
    }  
      
    // （13）函数调用 
    helloWorld("weiyigeek")  /* Scripted Pipeline - Hello Wrold - weiyigeek - 1024! */
  }
}

// (13) 函数声明定义时 不能包括在node中
def helloWorld (String username = 'STARTED',int age = 1024) {
    println "Scripted Pipeline - Hello Wrold - ${username} - ${age}!" 
}

// (1) 所有代码包裹在 Pipeline 块之中
pipeline {
  // (2) 定义任务在那台主机上运行可以是any、none(可以实现分布式的构建)等
  agent any
  // (3) 定义的环境变量比如PATH路径
  environment {
    hostname='Jenkins Pipeline'
  }
  // (4) 其类似一个大项目任务的集合主要包含所有stage子项目
  stages {
    // (5) 其类似一个项目中的单个任务主要来包含所有stage子任务
    stage ('clone') {
      // (6) 用来实现具体的执行的动作
      steps {
        // (7) 内置命令执行(信息打印)
        echo "git Clone Stage!"
      }
    }
    stage ('build') {
      steps {
        // (8) shell 命令执行 (Shell Script)
        sh "echo $hostname"
      }
    }
  }
  // (9) 消息通知
  post {
    always {
      echo "构建成功"
    }
  } 
}

必须: YES
参数：any / none / label /　node / docker / dockerfile / kubernetes
  - 1.在任何可用的 agent 上执行Pipeline或stage
  - 2.在pipeline块的顶层应用时，不会为整个 Pipeline运行分配全局代理，并且每个stage部分都需要包含自己的agent部分。
  - 3.使用提供的标签在Jenkins环境中可用的代理上执行 Pipeline或阶段, 注意标签条件也可以使用。
  - 4.node使用与lable类似
  - 5.执行Pipeline或stage时会动态供应一个docker节点去接受Docker-based的Pipelines。
  - 6.使用从Dockerfile源存储库中包含的容器构建的容器执行 Pipeline或阶段，Jenkinsfile 必须从多分支 Pipeline或 SCM Pipeline加载。
  - 7.在Kubernetes集群上部署的Pod内执行 Pipeline或阶段，同样Jenkinsfile 必须从多分支 Pipeline或 SCM Pipeline加载，Pod模板在kubernetes {} 块内定义。
允许：在顶层pipeline块和每个stage块中。

pipeline {
  agent any

  agent none

  agent { 
    label 'my-label1 && my-label2' 
  }

  agent { node { label 'labelName' } }  // 等同于 agent { label 'labelName' }

  // docker 还可以接受一个args直接传递给`docker run`调用以及一个 alwaysPull 选项
  // registryUrl和registryCredentialsId参数 有助于指定要使用的Docker注册表及其凭据
  agent {
    docker {
      image 'maven:3-alpine'
      label 'my-defined-label'
      args  '-v /tmp:/tmp'
      registryUrl 'https://myregistry.com/'
      registryCredentialsId 'myPredefinedCredentialsInJenkins'
    }
  }

  // dockerfile
  agent {
    // 等同于 to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/
    dockerfile {
        filename 'Dockerfile.build'
        // 如果要Dockerfile在另一个目录中构建，请使用以下dir选项
        dir 'build'
        label 'my-defined-label'
        additionalBuildArgs  '--build-arg version=1.0.2'
        args '-v /tmp:/tmp'
        // 同样也接受registryUrl和registryCredentialsId参数
        registryUrl 'https://myregistry.com/'
        registryCredentialsId 'myPredefinedCredentialsInJenkins'
    }
  }

  // kubernetes: 例如如果要在其中装有Kaniko容器的容器
  agent {
    kubernetes {
      label podlabel
      yaml """
  kind: Pod
  metadata:
    name: jenkins-agent
  spec:
    containers:
    - name: kaniko
      image: gcr.io/kaniko-project/executor:debug
      imagePullPolicy: Always
      command:
      - /busybox/cat
      tty: true
      volumeMounts:
        - name: aws-secret
          mountPath: /root/.aws/
        - name: docker-registry-config
          mountPath: /kaniko/.docker
    restartPolicy: Never
    volumes:
      - name: aws-secret
        secret:
          secretName: aws-secret
      - name: docker-registry-config
        configMap:
          name: docker-registry-config
  """
  }
}

// 示例1. Docker代理，声明性 Pipeline
pipeline {
  // V.在具有给定名称和标签（maven:3-alpine）的新创建容器中执行此 Pipeline中定义的所有步骤。
  agent { docker 'maven:3-alpine' } 
  stages {
      stage('Example Build') {
          steps {
              sh 'mvn -B clean verify'
          }
      }
  }
}

// 例子2.阶段级代理部分
pipeline {
  /* agent none在 Pipeline的顶层进行定义可确保 不会不必要地分配执行程序。使用agent none还会强制每个stage部分包含其自己的agent部分。 */
  agent none 
  stages {
    stage('Example Build') {
      /* 使用此映像在新创建的容器中执行此阶段中的步骤。*/
      agent { docker 'maven:3-alpine' } 
      steps {
          echo 'Hello, Maven'
          sh 'mvn --version'
      }
    }
    stage('Example Test') {
      /* 使用与上一阶段不同的图像在新创建的容器中执行此阶段中的步骤。 */
      agent { docker 'openjdk:8-jre' } 
      steps {
          echo 'Hello, JDK'
          sh 'java -version'
      }
    }
  }
}

必须: YES
参数：NONE
允许：pipeline块内只有一次

pipeline {
    agent any
    // stages部分将典型地遵循指令，例如agent， options等
    stages { 
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

必须: YES
参数：None
允许：每个Stage块之中

pipeline {
    agent any
    stages {
        stage('Example') {
          // 步骤部分必须包含一个或多个步骤。
          steps { 
              echo 'Hello World'
              // 执行 Scripted Pipeline (实际上就是直接执行并采用Groovy原生语法)
              script {
                def browsers = ['chrome', 'firefox']
                for (int i = 0; i < browsers.size(); ++i) {
                    echo "Testing the ${browsers[i]} browser"
                }
              }
          }
        }
    }
}

sh '<shell command>'

//第一种
result = sh returnStdout: true ,script: "<shell command>"
result = result.trim()
//第二种
result = sh(script: "<shell command>", returnStdout: true).trim()
//第三种
sh "<shell command> > commandResult"
result = readFile('commandResult').trim()

//第一种
result = sh returnStatus: true ,script: "<shell command>"
result = result.trim()

//第二种
result = sh(script: "<shell command>", returnStatus: true).trim()

//第三种
sh '<shell command>; echo $? > status'
def r = readFile('status').trim() //值得学习

//第四种
sh label: 'release', returnStdout: true, script:"""
sudo apk add jq && \
if ( \$(curl -s --header 'PRIVATE-TOKEN: ${private_token}' ${GITLAB_REL} | jq .[].tag_name | grep -c '${params.RELEASE_VERSION}') != 0 );then echo -n 1 > result.txt;else echo -n 0 > result.txt;fi
"""
def r = readFile('result.txt').trim() //值得学习

// 注意使用'但引号也可以解析变量
sh(returnStatus: true, script: "sudo apk add jq && curl -s --header 'PRIVATE-TOKEN: ${private_token}' ${GITLAB_REL} | jq .[].tag_name | grep -c '${params.RELEASE_VERSION}'")

// # (1) 命令拼接
sh ' $SonarScannerHome/bin/sonar-scanner ' +
    '-Dsonar.sources=src/main ' +
    '-Dsonar.projectKey="test" ' +
    '-Dsonar.projectName="test" '
  
// # (2) 值传递到参数
stage ("测试") {
  steps {
    timeout(time: 1, unit: 'MINUTES') {
        script {
          def RELEASE=sh returnStdout: true, script: 'git tag -l --column'   // # git show --oneline --ignore-all-space --text | head -n 1
          env.DEPLOY_ENV = input message: "选择部署的环境的版本", ok: 'deploy',
              parameters: [string(name: 'DEPLOY_ENV',defaultValue: "${RELEASE}",description: "可选项选择的版本 ${RELEASE}")]
         }
      }
  }
}

// # (3) 多行命令执行(值得注意在sh中得 $符号 需要采用 \$ 进行转义)
stage ("测试") {
  steps {
      timeout(time: 1, unit: 'MINUTES') {
      script {
          def RELEASE=sh returnStdout: true, script: 'git tag -l --column'
          def RELE=sh returnStdout: true, script: """\
          git tag -l --column | tr -d ' '  > tag ;
          export a="\$(sed "s#v#,'v#g" tag)'";
          echo [\${a#,*}];
          """
          // env.DEPLOY_ENV = input message: "选择部署的环境的版本1", ok: 'deploy',
          //     parameters: [string(name: 'DEPLOY_ENV',defaultValue: "${RELEASE}",description: "可选项选择的版本 ${RELEASE}")]
          // }
          println RELE // ['v1.1,'v1.10,'v1.11,'v1.2,'v1.3,'v1.6,'v1.7,'v1.8,'v1.9']
          // 选择部署的环境的版本 ['v1.1,'v1.10,'v1.11,'v1.2,'v1.3,'v1.6,'v1.7,'v1.8,'v1.9']
          env.DEPLOY_RELEASE = input message: "选择部署的环境的版本 ${RELE}", ok: 'deploy',   
          parameters: [choice(name: 'PREJECT_OPERATION', choices: ["ss","s"], description: 'Message: 选择项目版本? ${RELE}')]
    }
  }
}

必须: NO

参数：`always，changed，fixed，regression，aborted，failure，success， unstable，unsuccessful，和cleanup`
  - always ：post不管 Pipeline运行或阶段运行的完成状态如何，都运行本节中的步骤。
  - changed ：仅post当当前 Pipeline或阶段的运行与之前的运行具有不同的完成状态时，才运行步骤。
  - fixed ：仅post在当前 Pipeline或阶段的运行成功并且前一运行失败或不稳定的情况下运行步骤。
  - regression ：仅post当当前 Pipeline或阶段的运行状态为失败，不稳定或中止并且上一次运行成功时，才运行步骤。
  - aborted ：仅post在当前 Pipeline或阶段的运行状态为“中止”时才运行步骤，通常是由于手动中止了 Pipeline。通常在网络用户界面中用灰色表示。
  - failure ：仅post当当前 Pipeline或阶段的运行具有“失败”状态时才运行这些步骤，通常在Web UI中用红色表示。
  - success ：仅post当当前 Pipeline或阶段的运行具有“成功”状态时才运行步骤，通常在Web UI中用蓝色或绿色表示。
  - unstable ：仅post在当前 Pipeline或阶段的运行状态为“不稳定”（通常由测试失败，代码冲突等引起）的情况下，才运行步骤。通常在Web UI中以黄色表示。
  - unsuccessful ：仅post当当前 Pipeline或阶段的运行状态不是“成功”时才运行步骤。这通常根据前面提到的状态在Web UI中表示。
  - cleanup ： 在评估post所有其他条件之后post，无论 Pipeline或阶段的状态如何，都在此条件下运行步骤。

允许位置：在顶层pipeline块和每个stage块中。

pipeline {
  agent any
  stages {
    stage('Example') {
      steps {
          echo 'Hello World'
      }
    }
  }
  post { 
    always { 
      echo 'I will always say Hello again!'
    }
  }
}

必须: No
参数：Yes
允许：在pipeline块内，或在stage指令内。

pipeline {
  agent any
  // (1) 由于在pipeline下一层，则使用的指令将应用于 Pipeline中的所有步骤。
  environment { 
    CC = 'clang'
  }
  stages {
    stage('Example') {
      // (2) 在 stage 中定义的 environment指令只会将给定的环境变量应用于Example内的步骤。
        environment { 
          // 在environment块中credentials('凭据名称')定义的帮助程序方法通过其在Jenkins环境中的标识符来访问预定义的凭据
          AN_ACCESS_KEY = credentials('my-predefined-secret-text') 
        }
        steps {
          sh 'printenv'
          echo "${env.AN_ACCESS_KEY}"
          echo "${env.CC}"
        }
    }
  }
}

pipeline {
  agent any
  stages {
    stage('Example Username/Password') {
      environment {
        // 变量 = 将用户密码凭证赋予变量
        SERVICE_CREDS = credentials('my-predefined-username-password')
      }
      steps {
        // 注意点: defined: MYVARNAME_USR and MYVARNAME_PSW respectively.
        sh 'echo "Service user is $SERVICE_CREDS_USR"'
        sh 'echo "Service password is $SERVICE_CREDS_PSW"'
        sh 'curl -u $SERVICE_CREDS https://myservice.example.com'
      }
    }
    stage('Example SSH Username with private key') {
      environment {
        // 变量 = 将 `ssh private` 公密钥进行赋予变量
        SSH_CREDS = credentials('my-predefined-ssh-creds')
      }
      steps {
        // 注意点: defined: MYVARNAME_USR and MYVARNAME_PSW (holding the passphrase).
        sh 'echo "SSH private key is located at $SSH_CREDS"'
        sh 'echo "SSH user is $SSH_CREDS_USR"'
        sh 'echo "SSH passphrase is $SSH_CREDS_PSW"'

        // 调用内置变量 (如果变量不存在则输出null) - 值得学习注意。
        echo "${JOB_NAME}"
        echo env.'JOB_NAME'
        println(env.'JOB_NAME')  

        // 自定义全局变量方式(写入文件中再读取)
        script {
          def projectProduct = sh returnStdout: true, script: "find ${APP_NAME}"
          if ( projectProduct != '' ){
            echo "${projectProduct}"
            writeFile file: 'abc.sh', text: "${projectProduct}"
            change_id = readFile 'abc.sh'
            print(change_id)
          } else {
            error "[-Error] : projectProduct 不能为空!"
          }
        }
        
      }
    }
  }
}

必须: No
参数：None
允许：pipeline块内只有一次。

options { buildDiscarder(logRotator(numToKeepStr: '1')) }

options { disableConcurrentBuilds() }

options { checkoutToSubdirectory('foo') }

options { disableResume() }

# 仅为该作业启用分支索引触发器
options { overrideIndexTriggers(true) } 

# 仅为此作业禁用分支索引触发器
options { overrideIndexTriggers(false) }

# 保存构建
options { preserveStashes() } 

# 保存最近5次构建
options { preserveStashes(buildCount: 5) }

options { quietPeriod(30) }

options { retry(3) }

options { skipDefaultCheckout() }

options { skipStagesAfterUnstable() }

options { timestamps() }

options { parallelsAlwaysFailFast() }

# 操守时间一个小时(HOURS/Minute)
options { timeout(time: 1, unit: 'HOURS') }

# Global Timeout, Declarative Pipeline
pipeline {
    agent any
    options {
      // 将全局执行超时指定为一小时，然后Jenkins将中止 Pipeline运行。
      timeout(time: 1, unit: 'HOURS') 
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

pipeline {
    agent any
    stages {
        stage('Example') {
            // 关键单
            options {
                timeout(time: 1, unit: 'HOURS') 
            }
            steps {
                echo 'Hello World'
            }
        }
    }
}

必须: No
参数: None
允许: 在`Pipeline`块内仅一次。

Parameters, Declarative Pipeline
pipeline {
    agent any

    // Jenkins -> 原生 Build With Parameters 支持
    parameters {
      gitParameter name: 'RELEASE_VERSION', 
                      type: 'PT_BRANCH_TAG',
                      branchFilter: 'origin/(.*)',
                      defaultValue: 'master',
                      selectedValue: 'DEFAULT',
                      sortMode: 'DESCENDING_SMART',
            description: 'Message: 请选择部署的Tags版本?'
      choice(name: 'SONARQUBE', choices: ['False','True'], description: 'Message: 是否进行代码质量检测?')				 
 
      //  Jenkins -> 原生 Build With Parameters 支持 和 BlueOcean 都支持
      string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')

      text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')

      booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')

      choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')

      password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')
    }
    stages {
        stage('Example') {
            steps {
                // 调用
                echo "Hello ${params.PERSON}"

                echo "Biography: ${params.BIOGRAPHY}"

                echo "Toggle: ${params.TOGGLE}"

                echo "Choice: ${params.CHOICE}"

                echo "Password: ${params.PASSWORD}"
            }
        }
    }
}

必须: No
参数: None
允许: 在Pipeline块内

triggers { cron('H */4 * * 1-5') }

triggers { pollSCM('H */4 * * 1-5') }

triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }

* * * * * 
MINUTE - Minutes within the hour (0–59)

HOUR   - The hour of the day (0–23)

DAY	   - The day of the month (1–31)

MONTH  - The month (1–12)

WEEK   - The day of the week (0–7) where 0 and 7 are Sunday.

*   specifies all valid values  (指定所有有效值)

M-N specifies a range of values (指定值范围)

M-N/X or */X steps by intervals of X through the specified range or whole valid range (在指定范围或整个有效范围内按X的间隔步进)

A,B,…​,Z enumerates multiple values (枚举多个值)

// (1) Jenkins cron语法示例
// 每十五分钟执行触发
triggers{ cron('H/15 * * * *') }

// 每小时（1~30分钟）内每十分钟一次
triggers{ cron('H(0-29)/10 * * * *') }

// 每隔一个小时的45分钟，每两小时一次，从上午9:45开始，到每个工作日的下午3:45结束。
triggers{ cron('45 9-16/2 * * 1-5') }

// 每个工作日的上午9点至下午5点之间每两小时一次
triggers{ cron('H H(9-16)/2 * * 1-5') }

// 每月12月1日和15日每天一次
triggers{ cron('H H 1,15 1-11 *') }

//(2) Declarative Pipeline
pipeline {
    agent any
    triggers {
      cron('H */4 * * 1-5')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

必须: YES
参数: 步骤名称(字符串、必填)
允许: 在 Pipeline块 -> stages部分 内

// Declarative 
pipeline {
  agent any
  stages {
    stage('Example') {
      steps {
        echo 'Hello World'
      }
    }
  }
}

必须: No
参数: None
允许: 在 Pipeline 块 或者 stage 部分 内

pipeline {
    agent any
    tools {
      // 工具名称必须在Jenkins中的 Manage Jenkins → Global Tool Configuration 下预先配置。
      maven 'apache-maven-3.0.1' 
    }
    stages {
      stage('Example') {
        steps {
          sh 'mvn --version'
          script {
            // 无指定名称时可用采用tool指定设置的全局工具名称，这里这个tool是直接根据名称，获取自动安装的插件的路径
            def scannerHome = tool 'sonarqubescanner'
          }
          withSonarQubeEnv('SonarQube') {
            sh "${scannerHome}/bin/sonar-scanner -Dsonar.projectKey=YourProjectKey -Dsonar.sources=."
          }
        }
      }
    }
}

必须: No
参数: message 、id 、ok、submitter、submitterParameter、parameters
允许: 在 Pipeline块 -> stages 块内 （注意不是在stage中）

pipeline {
  agent any
  stages {
    stage('Example') {
      // 方式1.此种方式只能该块有效
      input {
        message "Title : 个人信息输入"
        ok "完成提交"
        submitter "alice,bob"
        parameters {
          string(name: 'INPUT_PERSON', defaultValue: 'WeiyiGeek', description: 'Message: 请输入您的姓名?')
          string(name: 'INPUT_AGE', defaultValue: 'WeiyiGeek', description: 'Message: 请输入您的年龄?')
          choice(name: 'INPUT_SEX', choices: ['Male','Female'], description: 'Message: 请选择你的性别?')
          booleanParam(name: 'INPUT_AGREE', defaultValue: true, description: 'Message: 是否确定协议?')
        }
      }

      steps {
        // 方式2: 注意script必须包含在 steps 块之中(此种方式可以全局传递参数)
        script {
          env.git_version=input message: 'Titel: 版本', ok: '通过',parameters: [string ( name: 'git_version', trim: true, description: 'Message : 请选择要操作的应用版本?')];

          env.deploy_option = input message: 'Titel: 操作', ok: 'deploy', parameters: [choice(name: 'deploy_option', choices: ['deploy', 'rollback', 'redeploy'], description: 'Message : 请选择操作流程?')];
        }

        // 12.input 输出示例
        echo "局部可用 输出示例1: 姓名：${INPUT_PERSON}, 年龄：${INPUT_AGE}, 性别：${INPUT_SEX}, 是否同意协议: ${INPUT_AGREE}"

        echo "全局可用 输出示例(script) -> 版本 : ${env.git_version}"
        echo "全局可用 输出示例(script) -> 版本 : ${env.deploy_option}"
    }
  }

  // 采用script块中定义input可以调用不同stage中得参数值
  stage ('调用') {
    steps {
      echo "调用1 : ${env.git_version}"
      echo "调用2 : ${env.deploy_option}"
    }
  }

}

// 1.不匹配分支
when { not { branch 'master' } }

// 2.分别满足分支为master并且DEPLOY_TO环境变量值为production是继续执行
when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }

// 3.满足分支为master或者分支为staging都可以继续执行.
when { anyOf { branch 'master'; branch 'staging' } }

必须: No
参数: Express
允许: 在 Pipeline块 -> stage 块内

when { branch 'master' }

when { expression { return params.DEBUG_BUILD } }

when { equals expected: 2, actual: currentBuild.number }

when { expression { return params.DEBUG_BUILD } }

when { tag "release-*" }

when { buildingTag() }

when { changelog '.*^\\[DEPENDENCY\\] .+$' }

when { changeset "**/*.js" }
when { changeset pattern: ".TEST\\.java", comparator: "REGEXP" }  // 正则表达式匹配
when { changeset pattern: "*/*TEST.java", caseSensitive: true }   // 区分大小写ANT样式路径

when { changeRequest() }.
// # Possible attributes are `id, target, branch, fork, url, title, author, authorDisplayName, and authorEmail`

// 每一个都对应一个CHANGE_*环境变量，
when { changeRequest target: 'master' }.

// comparator 参数后指导属性，以指定匹配时如何计算任何模式:
// * EQUALS用于简单的字符串比较(默认值)，
// * GLOB用于ANT风格的路径GLOB(与例如changeset相同)，
// * REGEXP用于正则表达式匹配
when { changeRequest authorEmail: "[\\w_-.]+@example.com", comparator: 'REGEXP' }

when { triggeredBy 'SCMTrigger' }

when { triggeredBy 'TimerTrigger' }

when { triggeredBy 'UpstreamCause' }

when { triggeredBy cause: "UserIdCause", detail: "vlinde" }

pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                beforeInput true    // 关键点
                branch 'production'
            }
            input {
                message "Deploy to production?"
                id "simple-input"
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

pipeline {
    agent none
    stages {
      stage('Example Build') {
          steps {
              echo 'Hello World'
          }
      }
      stage('Example Deploy') {
          when {
              beforeOptions true   // 关键点
              branch 'testing'
          }
          options {
              lock label: 'testing-deploy-envs', quantity: 1, variable: 'deployEnv'
          }
          steps {
              echo "Deploying to ${deployEnv}"
          }
      }
  }
}

pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            agent {
                label "some-label"
            }
            when {
                beforeAgent true
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

pipeline {
    agent none  // beforeAgent
    stages {
      stage('Example Build') {
        steps {
          echo 'Hello World'
        }
      }
      stage('Example Deploy') {
        // Single Condition - 单一条件
        when {
          branch 'production'
        }

        // Multiple Condition - 多重条件
        when {
          branch 'production'
          environment name: 'DEPLOY_TO', value: 'production'
        }

        // Nested condition - 嵌套条件
        when {
          allOf {
            branch 'production'
            environment name: 'DEPLOY_TO', value: 'production'
          }
        }

        // Multiple condition and nested condition - 注意点
        when {
            branch 'production'
            anyOf {
                environment name: 'DEPLOY_TO', value: 'production'
                environment name: 'DEPLOY_TO', value: 'staging'
            }
         }
        
        // Expression condition and nested condition  - 表达式条件和嵌套条件
        when {
          expression { BRANCH_NAME ==~ /(production|staging)/ }
          anyOf {
              environment name: 'DEPLOY_TO', value: 'production'
              environment name: 'DEPLOY_TO', value: 'staging'
          }
        }

        // triggeredBy
        when {
          triggeredBy "TimerTrigger"  // 当前Job设置的触发器名称进行监控
        }

        // 当前面的when都满足时采用执行该阶段步骤，否则丢弃
        steps {
            echo 'Deploying'
        }
      }
    }
}

pipeline {
    agent none
    stages {
        // 非时序的阶段
        stage('Non-Sequential Stage') {
            agent {
                label 'for-non-sequential'
            }
            steps {
                echo "On Non-Sequential Stage"
            }
        }
        // 顺序阶段
        stage('Sequential Stage') {
            agent {
                label 'for-sequential'
            }
            environment {
                FOR_SEQUENTIAL = "some-value"
            }
            // 注意点1:
            stages {
                stage('In Sequential 1') {
                    steps {
                        echo "In Sequential 1"
                    }
                }
                stage('In Sequential 2') {
                    steps {
                        echo "In Sequential 2"
                    }
                }
                // 注意点2:可以使用stage的所有其他功能，包括代理、工具、when等
                stage('Parallel In Sequential') {
                    // 并行执行上面已讲述
                    parallel {
                        stage('In Parallel 1') {
                            steps {
                                echo "In Parallel 1"
                            }
                        }
                        stage('In Parallel 2') {
                            steps {
                                echo "In Parallel 2"
                            }
                        }
                    }
                }
            }
        }
    }
}

pipeline {
    agent any
    //方式1.parallelsAlwaysFailFast
    options {
        parallelsAlwaysFailFast()
    } 
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            // 方式2.在任何一个阶段失败时强制终止所有并行阶段
            failFast true
            // 并行构建值得学习
            parallel {
                stage('Branch A') {
                    agent {
                        label "for-branch-a"
                    }
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent {
                        label "for-branch-b"
                    }
                    steps {
                        echo "On Branch B"
                    }
                }
                stage('Branch C') {
                    agent {
                        label "for-branch-c"
                    }
                    stages {
                        stage('Nested 1') {
                            steps {
                                echo "In stage Nested 1 within Branch C"
                            }
                        }
                        stage('Nested 2') {
                            steps {
                                echo "In stage Nested 2 within Branch C"
                            }
                        }
                    }
                }
            }
        }
    }
}

// One-axis with 3 cells, each cell runs three stages - "build", "test", and "deploy"
matrix {
    axes {
      axis {
        name 'PLATFORM'
        values 'linux', 'mac', 'windows'
      }
    }
    stages {
        stage('build') {
            // ...
        }
        stage('test') {
            // ...
        }
        stage('deploy') {
            // ...
        }
    }
}


// Three-axis matrix with 24 cells (three by four by two)
// 即 24 种组合方式: 例如 linux -> 32-bit -> chrome , mac -> 32-bit -> chrome 
matrix {
  axes {
    axis {
        name 'PLATFORM'
        values 'linux', 'mac', 'windows'
    }
    axis {
        name 'BROWSER'
        values 'chrome', 'edge', 'firefox', 'safari'
    }
    axis {
        name 'ARCHITECTURE'
        values '32-bit', '64-bit'
    }
  }
    // ...
}

matrix {
  axes {
      axis {
          name 'PLATFORM'
          values 'linux', 'mac', 'windows'
      }
      axis {
          name 'BROWSER'
          values 'chrome', 'edge', 'firefox', 'safari'
      }
      axis {
          name 'ARCHITECTURE'
          values '32-bit', '64-bit'
      }
  }
  excludes {
      exclude {
          axis {
              name 'PLATFORM'
              values 'mac'
          }
          axis {
              name 'ARCHITECTURE'
              values '32-bit'
          }
      }

      //排除linux和safari组合，并排除使用edge浏览器的任何非windows平台。
       exclude {
          // 2 cells
          axis {
              name 'PLATFORM'
              values 'linux'
          }
          axis {
              name 'BROWSER'
              values 'safari'
          }
        }
        exclude {
          // 3 more cells and '32-bit, mac' (already excluded)
          axis {
              name 'PLATFORM'
              notValues 'windows' // 注意点 norValues
          }
          axis {
              name 'BROWSER'
              values 'edge'
          }
        }
  }
    // ...
}

pipeline {
    // 参数选择
    parameters {
        choice(name: 'PLATFORM_FILTER', choices: ['all', 'linux', 'windows', 'mac'], description: 'Run on specific platform')
    }
    agent none
    stages {
        stage('BuildAndTest') {
            matrix {
                agent {
                    label "${PLATFORM}-agent"
                }
                when { anyOf {
                    // 参数选择不为空时继续执行
                    expression { params.PLATFORM_FILTER == 'all' }
                    expression { params.PLATFORM_FILTER == env.PLATFORM }
                } }
                // 2 轴 (3 x 4) 十二格组合方式
                axes {
                    axis {
                        name 'PLATFORM'
                        values 'linux', 'windows', 'mac'
                    }
                    axis {
                        name 'BROWSER'
                        values 'firefox', 'chrome', 'safari', 'edge'
                    }
                }
                // 排除指定Matrix矩阵中的值 (排除linux和safari组合，并排除使用edge浏览器的任何非windows平台。) 
                // 即 排除 (linux,safari) , (linux,edge) , (mac,edge) 三种情况
                excludes {
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'linux'
                        }
                        axis {
                            name 'BROWSER'
                            values 'safari'
                        }
                    }
                    exclude {
                        axis {
                            name 'PLATFORM'
                            notValues 'windows'
                        }
                        axis {
                            name 'BROWSER'
                            values 'edge'
                        }
                    }
                }
                stages {
                    stage('Build') {
                        steps {
                            echo "Do Build for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                    stage('Test') {
                        steps {
                            echo "Do Test for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                }
            }
        }
    }
}

// Declarative Pipeline Syntax Composite sample
pipeline {
  // 1.由于此处没有其它jenkins slave 分布式机器则采用any进行替代
  agent any
  // 7.全局环境变量
  environment { 
    global_env = 'Jenkins global environment'
    global_when = 'true'
  }
  // 8.全局选项
  options { 
    // 如果失败重试整个 Pipeline指定次数
    retry(3)
    // 在任何一个阶段失败时强制终止所有并行阶段
    parallelsAlwaysFailFast()

  }
  // 9.全局参数
  parameters {
    // 参数声明定义
    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
    booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')
    text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')
    choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')
    password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')
  }
  
  // 11.触发器 (每两分钟执行一次)
  triggers{ cron('H/2 * * * *') }
  
  // 12.工具路径并放置环境变量到PATH
  // Dashboard -> 全局工具配置
  tools {
    maven 'maven_env'
    jdk   'jdk_1.8.0_211'
  }
  // 2.多阶段唯一入口
  stages {
    // 3.指定的单阶段（init-初始化阶段）
    stage ('init') {
      // 4.单阶段中的只有一个步骤steps
      steps {
        // 5.内置指令例如 echo 、println进行输出
        echo "init - steps one - built-in functions echo"
        println "init - steps one - built-in functions println "

        // 6.采用script指令来执行Scripted Pipeline中的一些脚本
        script {
          def browsers = ['chrome', 'firefox', 'edge']
          for (int i = 0; i < browsers.size(); ++i) {
              echo "Testing the ${browsers[i]} browser"
          }
        }
      }
    }

   stage ('one-stage') {
      // 7.局部环境变量
      environment { 
        // 变量定义
        local_env = "Jenkins local environment"
        // 将在Jenkins中设置的用户密码凭证赋予local_creds变量, 注意括号中为凭据名称
        // Dashboard -> 凭据 -> 系统 -> 全局凭据 (unrestricted) -> 添加凭据
        // Username with password	: 43287e62-ce5b-489a-9c11-cedf38e16e92	weiyigeek/****** (Pipeline 测试 credentials 读取)	Username with password	Pipeline 测试 credentials 读取
        Local_userpass_creds = credentials('43287e62-ce5b-489a-9c11-cedf38e16e92')
        // SSH Username with private key : b4c8b4e9-2777-44a1-a1ed-e9dc21d37f4f	weiyigeek (myself-gitlab-weiyigeek)	SSH Username with private key	myself-gitlab-weiyigeek
        Local_ssh_creds = credentials('b4c8b4e9-2777-44a1-a1ed-e9dc21d37f4f')
      }

      steps {
        println "全局变量: " + global_env +", 局部变量: " + local_env 
        /* == 全局变量: Jenkins global environment, 局部变量: Jenkins local environment*/
        // 注意点: defined: MYVARNAME_USR and MYVARNAME_PSW respectively. (输出的字符串已经经过转义)
        sh 'echo "user is $Local_userpass_creds_USR"'      /* = user is **** */
        sh 'echo "password is $Local_userpass_creds_PSW"'  /* = password is **** */
        // 注意点: defined: MYVARNAME_USR and MYVARNAME_PSW (holding the passphrase).
        sh 'echo "SSH private key is located at $Local_ssh_creds"'
        sh 'echo "SSH user is $Local_ssh_creds_USR"'

        // 12.额外第三方工具插件路径调用方式
        script {
          scannerHome = tool 'sonarqubescanner'
          //这里这个tool是直接根据名称，获取自动安装的插件的路径
        }
        // withSonarQubeEnv('SonarQube') {
        //   sh "${scannerHome}/bin/sonar-scanner -Dsonar.projectKey=YourProjectKey -Dsonar.sources=."
        // }
      }


   }

    stage ('two-stage') {
      // 13.当任一满足以下条件时执行
      when {   
        beforeInput true 
        anyOf { branch 'master'; environment name: 'global_when', value: 'true' }
      }

      // 8.局部选项
      options {
        // 可设置全局(局部阶段)执行超时指定为一分钟，然后Jenkins将中止 Pipeline运行。
        timeout(time: 5, unit: 'MINUTES') 
      }

      // 12.Input指令输入参数到变量中
      // 方式1
      input {
          message "Title : 个人信息输入"
          ok "完成提交"
          submitter "alice,bob"
          parameters {
            string(name: 'INPUT_PERSON', defaultValue: 'WeiyiGeek', description: 'Message: 请输入您的姓名?')
            text(name: 'INPUT_AGE', defaultValue: 'WeiyiGeek', description: 'Message: 请输入您的年龄?')
            choice(name: 'INPUT_SEX', choices: ['Male','Female'], description: 'Message: 请选择你的性别?')
            password(name: 'INPUT_PASSWORD', defaultValue: 'SECRET', description: 'Message: 请输入您注册密码?')
            booleanParam(name: 'INPUT_AGREE', defaultValue: true, description: 'Message: 是否确定协议?')
          }
      }

      steps {
          // 方式2：注意script必须包含在 steps 块之中
          script {
            env.git_version=input message: 'Titel: 版本', ok: '通过',parameters: [string ( name: 'git_version', trim: true, description: 'Message : 请选择要操作的应用版本?')];
            env.deploy_option = input message: 'Titel: 操作', ok: 'deploy', parameters: [choice(name: 'deploy_option', choices: ['deploy', 'rollback', 'redeploy'], description: 'Message : 请选择操作流程?')];
          }

        // 10.Parameters 参数调用
        echo "全局 - Hello ${params.PERSON}"
        echo "全局 - Toggle: ${params.TOGGLE}"
        echo "全局 - Choice: ${params.CHOICE}"
        echo "全局 - Password: ${params.PASSWORD}"
        echo "全局 - Biography: ${params.BIOGRAPHY}"

        // 12.input 输出示例
        echo "input 输出示例1: 姓名：${INPUT_PERSON}, 年龄：${INPUT_AGE}, 性别：${INPUT_SEX}, 是否同意协议: ${INPUT_AGREE}"
        echo "input 输出示例(script) -> 版本 : ${env.git_version}"
        echo "input 输出示例(script) -> 版本 : ${env.deploy_option}"
      }
    }

    stage ('three-stage') {
      // 14.Parallel Stages 并行执行
      // 方式2.failFast true 在任何一个阶段失败时强制终止所有并行阶段
      parallel {
        stage('parallel-Branch A') {
            steps {
                echo "On Branch A"
            }
        }
        stage('parallel-Branch B') {
            steps {
                echo "On Branch B"
            }
        }
        stage('parallel-Branch C') {
          stages {
              stage('嵌套Nested 1') {
                  steps {
                      echo "In stage Nested 1 within Branch C"
                  }
              }
              stage('嵌套Nested 2') {
                  steps {
                      echo "In stage Nested 2 within Branch C"
                  }
              }
          }
        }
      }
    }

    // 15.Matrix 矩阵模型实践
    stage ('four-stage') {
      input {
        message "Title : 部署平台"
        ok "完成提交"
        submitter "alice,bob"
        parameters {
          choice(name: 'PLATFORM_FILTER', choices: ['all', 'linux', 'windows', 'mac'], description: 'Run on specific platform')
        }
      }
      matrix { 
        when { anyOf {
                // 参数选择不为空时继续执行
                expression { params.PLATFORM_FILTER == 'all' }
                expression { params.PLATFORM_FILTER == env.PLATFORM }
              } 
        }
        // 16.2 轴 (3 x 2) 6种组合方式的模型
        axes {
          axis {
            name 'PLATFORM'
            values 'linux', 'windows', 'mac'
          }
          axis {
            name 'ARCHITECTURE'
            values '32-bit','64-bit'
          }
        }
        // 17.排除指定模型例如非64-bit的在windows平台的将被剔除
        excludes {
          exclude {
              axis {
                name 'PLATFORM'
                values 'windows'
              }
              axis {
                name 'ARCHITECTURE'
                notValues '64-bit'
              }
          }
        }
        // 18.还有5种情况依次进行构建
        stages {
          stage('Build') {
            steps {
              echo "matrix - Do Build for ${PLATFORM} - ${BROWSER}"
            }
          }
        }
      }
    }
  }

  // 6.消息通知
  post { 
    // # 总是执行的步骤
    always { 
      echo 'I will always say Hello again!' /* == I will always say Hello again!— Print Message */
    }
  }
}

## init - stage
maven_env— Use a tool from a predefined Tool Installation  <1s
# Fetches the environment variables for a given tool in a list of 'FOO=bar' strings suitable for the withEnv step.<1s
jdk_k1.8.0_211— Use a tool from a predefined Tool Installation  <1s
# Fetches the environment variables for a given tool in a list of 'FOO=bar' strings suitable for the withEnv step.<1s
maven_env— Use a tool from a predefined Tool Installation  <1s
# Fetches the environment variables for a given tool in a list of 'FOO=bar' strings suitable for the withEnv step.<1s
jdk_k1.8.0_211— Use a tool from a predefined Tool Installation <1s
# Fetches the environment variables for a given tool in a list of 'FOO=bar' strings suitable for the withEnv step.<1s
init - steps one - built-in functions echo— Print Message <1s
init - steps one - built-in functions println — Print Message <1s
Testing the chrome browser— Print Messag e<1s
Testing the firefox browser— Print Message 1s
Testing the edge browser— Print Message <1s


## one - stage
全局变量: Jenkins global environment, 局部变量: Jenkins local environment
+ echo user is ****
user is ****
+ echo **** is ****
**** is ****
+ echo SSH private key is located at ****
SSH private key is located at ****
+ echo SSH user is ****
SSH user is ****


## two-stage
全局 - Hello Mr Jenkins— Print Message<1s
全局 - Toggle: true— Print Message<1s
全局 - Choice: One— Print Message<1s
全局 - Password: SECRET— Print Message<1s
全局 - Biography: — Print Message<1s
input 输出示例1: 姓名：WeiyiGeek, 年龄：185, 性别：Male, 是否同意协议: true— Print Message<1s
input 输出示例(script) -> 版本 : v1.2— Print Message<1s
input 输出示例(script) -> 版本 : deploy— Print Message

## three-stage
On Branch A— Print Message
On Branch B— Print Message
In stage Nested 1 within Branch C
In stage Nested 2 within Branch C

## four-stage
I will always say Hello again!— Print Message<1s

echo "Hello"
println "World!"

script {
  // 测试的字符串
  sourceStr = "这是要替换的值：#value1, 这是要替换的值：#value2"
  // 替换 #value1 与 #value2 两个值
  afterStr = sourceStr.replaceAll("#value1","AAA").replaceAll("#value2","BBB")
  // 输出替换后的字符串
  print "${afterStr}"
  // 这是要替换的值：AAA，这是要替换的值：BBB
}

dir("./delete_dir")
deleteDir()

# 工作空间中文件的相对(/分隔)路径，以验证文件是否存在。
fileExists file: "./pom.xml"

writeFile encoding: 'utf-8', file: 'file', text: '测试写入'

name
Name of a stash. Should be a simple identifier akin to a job name.
    Type: String

allowEmpty (optional)
    Type: boolean

excludes (optional)
Optional set of Ant-style exclude patterns.
Use a comma separated list to add more than one expression.
If blank, no files will be excluded.
    Type: String

includes (optional)
Optional set of Ant-style include patterns.
Use a comma separated list to add more than one expression.
If blank, treated like **: all files.
The current working directory is the base directory for the saved files, which will later be restored in the same relative locations, so if you want to use a subdirectory wrap this in dir.
    Type: String

useDefaultExcludes (optional)
If selected, use the default excludes from Ant - see here for the list.
    Type: boolean

# name: 以前保存的仓库的名称。
unstash 'repo'

wrap([$class: 'AnsiColorBuildWrapper']).

# 参数: String includes, optional: excludes 
archive
# 参数: Type: java.util.Map<java.lang.String, java.lang.String> mapping 
unarchive
# 参数: 
# artifacts: 用于存档的文件(支持通配符)
# excludes: 不包含的文件(支持通配符)
# allowEmptyArchive: 归档为空时不引起构建失败
# onlyIfSuccessful: 只有构建成功时归档
# fingerprint: 记录所有归档成品的指纹
# Follow symbolic links: 通过禁用此选项，工作空间中找到的所有符号链接都将被忽略。
archiveArtifacts artifacts: './target/*.jar', excludes: './target/test/*', fingerprint: true, onlyIfSuccessful: true, allowEmptyArchive: true

node {
  withEnv(['MYTOOL_HOME=/usr/local/mytool']) {
    sh '$MYTOOL_HOME/bin/start'
  }
}

# 方式1.采用 $? 判断命令执行成功与否。
# 方式2.采用echo命令输出到文件时加上 -n 选项。

// 简单示例
try {
  sh 'might fail && whoami'
  echo 'Succeeded!'
} catch (err) {
  echo "Failed: ${err} - " + err.toString() 
  error "[-Error] : 项目部署失败 \n[-Msg] : ${err.getMessage()} "
} finally {
  sh './tear-down.sh'
}

catchError {
  sh 'might fail'
}

unstable '阶段结果为不稳定'
unstable {
  echo "阶段结果为不稳定"
}

subject
Email subject line.
    Type: String
body
Email body.
    Type: String
bcc (optional)
BCC email address list. Comma separated list of email addresses.
    Type: String
cc (optional)
CC email address list. Comma separated list of email addresses.
    Type: String
charset (optional)
Email body character encoding. Defaults to UTF-8
    Type: String
from (optional)
From email address. Defaults to the admin address globally configured for the Jenkins instance.
    Type: String
mimeType (optional)
Email body MIME type. Defaults to text/plain.
    Type: String
replyTo (optional)
Reploy-To email address. Defaults to the admin address globally configured for the Jenkins instance.
    Type: String
to (optional)
To email address list. Comma separated list of email addresses. 
    Type: String

# 参数: int count
retry(count: 5)  # 重试5次

# 参数: int time, optional unit ( Values: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS)
sleep(time: 60,unit: SECONDS  # 休眠60s

# 参数: int time, optional activity, optional unit 
# Values: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS
timeout(time: 10,unit: MINUTES) # 超时10分钟 

# 参数: optional initialRecurrencePeriod, optional quiet 
# initialRecurrencePeriod: 设置重试之间的初始等待周期(以毫秒为单位)默认为250 ms。每次失败都将降低尝试之间的延迟最多可达15秒。
# quiet: 如果为true，则该步骤不会在每次检查条件时记录消息。默认值为false。
waitUntil(initialRecurrencePeriod: 250, quiet: false){
  sh "./monitor.sh"
}

tool name: 'Sonar-Scanner', type: 'hudson.plugins.sonar.SonarRunnerInstallation'
tool name: 'docker', type: 'dockerTool'

# 参数: 用于受信任的代码，如全局库，它可以操作内部Jenkins api。
# Type: java.lang.Class<?>
# 例子:接受单个类型参数
getContext hudson.FilePath

# 例子:接受一个context参数和一个block。
# 在ConsoleLogFilter、LauncherDecorator和EnvironmentExpander的情况下，自动将其参数与上下文对象合并。
withContext(new MyConsoleLogFilter()) {
  sh 'process'
}

timeout(time: 1, unit: 'MINUTES') {
  script {
    env.deploy_option = input message: '选择操作', ok: 'deploy',
    parameters: [choice(name: 'deploy_option', choices: ['deploy', 'rollback', 'redeploy'], description: '选择部署环境')]
    switch("${env.deploy_option}"){
        case 'deploy':
            println('1.deploy prd env')
            break;
        case 'rollback':
            println('2.rollback env')
            break;
        case 'redeploy':
            println('3.redeploy env')
            break;
        default:
            println('error env')
    }
  }
}

checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'b4c8b4e9-2777-44a1-a1ed-e9dc21d37f4f', url: 'git@gitlab.weiyigeek.top:ci-cd/java-maven.git']]])

/usr/local/bin/sonar-scanner -Dsonar.projectName=${JOB_NAME} -Dsonar.projectKey=Hello-World -Dsonar.sources=.

// # 生成的流水线
sh label: 'sonar', returnStatus: true, script: '''/usr/local/bin/sonar-scanner -Dsonar.projectName=${JOB_NAME} -Dsonar.projectKey=Hello-World -Dsonar.sources=.'''

// # Scripted Pipeline
podTemplate(label: 'jenkins-jnlp-slave', cloud: 'k8s_115') {
  node ('jenkins-jnlp-slave') {
    stage ('dynamic-checkout') {
      checkout([$class: 'GitSCM', branches: [[name: '*/master']], userRemoteConfigs: [[credentialsId: '69c0dbf0-f786-4aa0-975a-76528f10de8b', url: 'http://127.0.0.1/xxx/devops_test.git']]])
    }
  }
}