jenkins-pipeline语法总结(最全)

1、jenkins总结之pipeline语法

1.1必要的Groovy知识

• 习惯定义变量使用def关键字 def x=“abc” def y=1。
• Groovy语句最后的分号是不必须的
• 方法调用可以省略括号
• 方法 调用支持命名参数

​

def createName(String givenName, String familyName){
  return givenName + " " familyName
}

//调用
createName(familyNmae = "Lee",givenName = "Bruce")
1
2
3
4
5
6

• 支持默认传参

​

def createName(String givenName = "nicai"){
  return givenName + " " familyName
}

//调用
createName()
1
2
3
4
5
6

• 支持单引号、双引号。双引号支持插值，单引号不支持

def name = 'world'
print "hello ${name}" // 结果hello world
print 'hello ${name}'	// 结果hello ${name}
1
2
3

• 支持三引号。三引号分为三单引号和三双引号。都支持换行，区别同上双引号支持插值。
• 支持闭包。

//支持闭包
def codeBlock = {print "hello closure"}
//闭包可以直接被当成函数调用
codeBlock()   //闭包就是函数名可以作为参数传递。
1
2
3
4

1.2pipeline的组成

1.2.1pipeline最简结构

jenkins的必须部分有以下五个，少一个都不行都会报错。

• pipeline

  代表整条流水线，包含整条流水线的逻辑。

• stage

​ 阶段，代表流水线的阶段。每个阶段都必须有名称。

• stages

​ 流水线中多个stage的容器。stages部分至少包含一个stage。

• steps

​ 代表阶段中的一个或多个具体步骤（step）的容器。steps部分至少包含一个步骤

• agent部分

​ 指定流水线的执行位置（Jenkins agent）

1.3post部分

post部分包含的是在整个pipeline或阶段完成后一些附加的步骤。post部分是可选的，所以并不包含在pipeline最简结构中。但这并不代表它作用不大。根据pipeline或阶段的完成状态，post部分分成多种条件块，包括：

• • always：不论当前完成状态是什么，都执行。

• • changed：只要当前完成状态与上一次完成状态不同就执行。

• • fixed：上一次完成状态为失败或不稳定（unstable），当前完成状态为成功时执行。

• • regression：上一次完成状态为成功，当前完成状态为失败、不稳定或中止（aborted）时执行。

• • aborted：当前执行结果是中止状态时（一般为人为中止）执行。

• • failure：当前完成状态为失败时执行。

• • success：当前完成状态为成功时执行。

• • unstable：当前完成状态为不稳定时执行。

• • cleanup：清理条件块。不论当前完成状态是什么，在其他所有条件块执行完成后都执行

1.4pipeline支持的指令

Jenkins pipeline支持的指令有：

• environment：

​ 用于设置环境变量，可定义在stage或pipeline部分。

该environment指令指定一系列键值对，这些对值将被定义为所有步骤的环境变量或阶段特定步骤，具体取决于environment指令位于pipeline中的位置。

该指令支持一种特殊的帮助方法credentials()，可以通过其在Jenkins环境中的标识符来访问预定义的凭据。对于类型为Secret Text的凭据，该credentials()方法将确保指定的环境变量包含Secret Text内容。对于“标准用户名和密码”类型的凭证，指定的环境变量将被设置为，username:password并且将自动定义两个附加的环境变量：MYVARNAME_USR和MYVARNAME_PSW相应的。

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    environment { 
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment { 
                AN_ACCESS_KEY = credentials('my-prefined-secret-text') 
            }
            steps {
                sh 'printenv'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Jenkins内置变量:

下面我们简单介绍几个在实际工作中经常用到的变量。

• BUILD_NUMBER：构建号，累加的数字。在打包时，它可作为制品名称的一部分，比如server-2.jar。

• BRANCH_NAME：多分支pipeline项目支持。当需要根据不同的分支做不同的事情时就会用到，比如通过代码将release分支发布到生产环境中、master分支发布到测试环境中。

• BUILD_URL：当前构建的页面URL。如果构建失败，则需要将失败的构建链接放在邮件通知中，这个链接就可以是BUILD_URL。

• GIT_BRANCH：通过git拉取的源码构建的项目才会有此变量。

• tools：

​ 可定义在pipeline或stage部分。它会自动下载并安装我们指定的工具，并将其加入PATH变量中。

定义自动安装并放在上的工具的部分PATH。如果agent none指定，则将其忽略。

pipeline {
    agent any
    tools {
        maven 'apache-maven-3.0.1' 
    }
    stages {
        stage('Example') {
            steps {
                sh 'mvn --version'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• input：

​ 定义在stage部分，会暂停pipeline，提示你输入内容。

input指令stage允许使用inputstep提示输入。在stage将暂停任何后options已被应用，并在进入前agent块为stage或评估when的条件stage。如果input批准，stage则将继续。作为input提交的一部分提供的任何参数将在其余的环境中可用stage。

可选项

• message 必需的，这将在用户提交时显示给用户input
• id 可选标识符input，默认为stage名称
• ok input表单上“确定”按钮的可选文本
• submitter 可选的逗号分隔列表，这些列表允许用户提交此用户或外部组名input。默认为允许任何用户。
• submitterParameter 环境变量的可选名称，用该submitter名称设置（如果存在）
• parameters 提示提交者提供的可选参数列表。请参阅parameters以获取更多信息

pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "alice,bob"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• options：

用于配置Jenkins pipeline本身的选项，比如options {retry（3）}指当pipeline失败时再重试2次。options指令可定义在stage或pipeline部分。

该options指令允许在Pipeline本身内配置Pipeline专用选项。Pipeline提供了许多这些选项，例如buildDiscarder，但它们也可能由插件提供，例如timestamps。

可用选项

• buildDiscarder 持久化工件和控制台输出，用于最近Pipeline运行的具体数量。例如：options { buildDiscarder(logRotator(numToKeepStr: '1')) }

• disableConcurrentBuilds 不允许并行执行Pipeline。可用于防止同时访问共享资源等。例如：options { disableConcurrentBuilds() }

• overrideIndexTriggers 允许覆盖分支索引触发器的默认处理。 如果分支索引触发器在多分支或组织标签中禁用, options { overrideIndexTriggers(true) }将只允许它们用于促工作。否则, options { overrideIndexTriggers(false) }只会禁用改作业的分支索引触发器。

• skipDefaultCheckout 在agent指令中默认跳过来自源代码控制的代码。例如：options { skipDefaultCheckout() }

• skipStagesAfterUnstable 一旦构建状态进入了“不稳定”状态，就跳过阶段。例如：options { skipStagesAfterUnstable() }

• checkoutToSubdirectory 在工作空间的子目录中自动地执行源代码控制检出。例如: options { checkoutToSubdirectory('foo') }

• timeout 设置Pipeline运行的超时时间，之后Jenkins应该中止Pipeline。

如果 pipeline 执行时间过长，超出了我们设置的 timeout 时间，Jenkins 将中止pipeline。以下例子中以小时为单位，还可以以 SECONDS（秒）、MINUTES（分钟）为单位。当使用timeout选项时，options可以被放在stage块中。例如：

options { timeout(time: 1, unit: 'HOURS') }
1

• retry 失败后，重试整个Pipeline指定的次数。例如：options { retry(3) }

• timestamps 预处理由Pipeline生成的所有控制台输出运行时间与发射线的时间。例如：options { timestamps() }

pipeline {
    agent any
  	//增加时间戳
    options { timestamps() }
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "alice,bob"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• parallel：

​ 并行执行多个step。在pipeline插件1.2版本后，parallel开始支持对多个阶段进行并行执行。

​ 声明性管道中的阶段可能有一个parallel部分，其中包含要并行运行的嵌套阶段的列表。需要注意的是一个阶段都必须有且只有一个steps，stages，parallel，或matrix。这是不可能的嵌套parallel或matrix块内stage，如果该指令stage指令嵌套在一个parallel或matrix阻塞本身。然而，stage一个内指令parallel或matrix块可以使用的所有其它的功能stage，包括agent，tools，when等。

此外，你可以parallel阶段时，它们中的任何一个发生故障，所有被中止，加入failFast true到stage含有parallel。添加的另一个选项failfast是在管道定义中添加一个选项：parallelsAlwaysFailFast()

pipeline {
    environment {
        name1="这是name1"
    }

    agent any

    stages {
        stage('Build') {

            input {
               message '请选择版本号'
               ok '提交'
               submitter 'devops'
               parameters {
               choice choices: ['1.1.1', '1.1.2'], description: '', name: 'VERSION'
                }
            }

            steps {
                echo 'Building..'
                echo "${name1}"
            }
        }
        stage('Test') {
            //parallel test
            parallel {
                stage('parallel测试1'){
                    steps {
                        echo "parallel test 1"
                    }
                }
                
                stage('parallel测试2'){
                    steps {
                        echo "parallel test 2"
                    }
                }
                
                stage('parallel测试3'){
                    steps {
                        echo "parallel test 3"
                    }
                }
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying....'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

• parameters：

​ 与input不同，parameters是执行pipeline前传入的一些参数。

• string 字符串类型的参数，例如：

parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }
1

• text 文本参数，可以包含多行，例如：

parameters { text(name: 'DEPLOY_TEXT', defaultValue: 'One\nTwo\nThree\n', description: '') }
1

• booleanParam 布尔参数，例如：

parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }
1

• choice 选择参数，例如：

parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') }
1

• password 密码参数，例如：

parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'A secret password') }
1

pipeline {
    agent any
    parameters {
        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}"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• triggers：

用于定义执行pipeline的触发器。• when：当满足when定义的条件时，阶段才执行。

该triggers指令定义了应重新触发的自动化方式。对于与GitHub或BitBucket之类的源集成的管道，triggers由于基于Webhooks的集成可能已经存在，因此可能没有必要。目前可用的触发器 cron，pollSCM和upstream。

• cron 接受cron样式的字符串来定义应重新触发管道的常规间隔，例如：triggers { cron('H */4 * * 1-5') }
• pollSCM 接受cron样式的字符串以定义Jenkins应检查新源更改的定期间隔。如果存在新的更改，则将重新触发管道。例如：triggers { pollSCM('H */4 * * 1-5') }
• upstream 接受以逗号分隔的作业字符串和阈值。当字符串中的任何作业以最小阈值结束时，将重新触发管道。例如： triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }

// Declarative //
pipeline {
    agent any
    triggers {
        cron('H */4 * * 1-5')
      	'''
      	每15分钟构建一次：H/15 * * * * 或*/5 * * * *
				每天8点构建一次：H 8 * * *
				每天8点~17点，两小时构建一次：H 8-17/2 * * *
				周一到周五，8点~17点，两小时构建一次：H 8-17/2 * * 1-5
				每月1号、15号各构建一次，除12月：H H 1,15 1-11 *

				第1列分钟1～59
				第2列小时0～23
				第3列日1～31
				第4列月1～12
				第5列星期0～7(0和7表示星期日)
      	'''
    }
    stages {
        stage('Example') {
            steps {	
                echo 'Hello World'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.5配置pipeline本身

options指令用于配置整个Jenkins pipeline本身的选项。

用于配置Jenkins pipeline本身的选项，比如options {retry（3）}指当pipeline失败时再重试2次。options指令可定义在stage或pipeline部分。

该options指令允许在Pipeline本身内配置Pipeline专用选项。Pipeline提供了许多这些选项，例如buildDiscarder，但它们也可能由插件提供，例如timestamps。

可用选项

• buildDiscarder 持久化工件和控制台输出，用于最近Pipeline运行的具体数量。例如：options { buildDiscarder(logRotator(numToKeepStr: '1')) }

• disableConcurrentBuilds 不允许并行执行Pipeline。可用于防止同时访问共享资源等。例如：options { disableConcurrentBuilds() }

• overrideIndexTriggers 允许覆盖分支索引触发器的默认处理。 如果分支索引触发器在多分支或组织标签中禁用, options { overrideIndexTriggers(true) }将只允许它们用于促工作。否则, options { overrideIndexTriggers(false) }只会禁用改作业的分支索引触发器。

• skipDefaultCheckout 在agent指令中默认跳过来自源代码控制的代码。例如：options { skipDefaultCheckout() }

• skipStagesAfterUnstable 一旦构建状态进入了“不稳定”状态，就跳过阶段。例如：options { skipStagesAfterUnstable() }

• checkoutToSubdirectory 在工作空间的子目录中自动地执行源代码控制检出。例如: options { checkoutToSubdirectory('foo') }

• timeout 设置Pipeline运行的超时时间，之后Jenkins应该中止Pipeline。

如果 pipeline 执行时间过长，超出了我们设置的 timeout 时间，Jenkins 将中止pipeline。以下例子中以小时为单位，还可以以 SECONDS（秒）、MINUTES（分钟）为单位。当使用timeout选项时，options可以被放在stage块中。例如：

options { timeout(time: 1, unit: 'HOURS') }
1

• retry 失败后，重试整个Pipeline指定的次数。例如：options { retry(3) }

• timestamps 预处理由Pipeline生成的所有控制台输出运行时间与发射线的时间。例如：options { timestamps() }

pipeline {
    agent any
  	//增加时间戳
    options { timestamps() }
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "alice,bob"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.6在声明式pipeline中使用脚本

Jenkins pipeline专门提供了一个script步骤，你能在script步骤中像写代码一样写pipeline逻辑

在script块中的其实就是Groovy代码。大多数时候，我们是不需要使用script步骤的。如果在script步骤中写了大量的逻辑，则说明你应该把这些逻辑拆分到不同的阶段，或者放到共享库中。共享库是一种扩展Jenkins pipeline的技术。

1.7pipeline内置基础步骤

1.7.1 文件目录相关步骤

deleteDir：删除当前目录

deleteDir是一个无参步骤，删除的是当前工作目录。通常它与dir步骤一起使用，用于删除指定目录下的内容。

dir：切换到目录

默认pipeline工作在工作空间目录下，dir步骤可以让我们切换到其他目录

fileExists：判断文件是否存在

fileExists（‘/tmp/a.jar’）判断/tmp/a.jar文件是否存在。如果参数是相对路径，则判断在相对当前工作目录下，该文件是否存在。结果返回布尔类型。

pwd：确认当前目录

pwd与Linux的pwd命令一样，返回当前所在目录。它有一个布尔类型的可选参数：tmp，如果参数值为true，则返回与当前工作空间关联的临时目录。

writeFile：将内容写入指定文件中

writeFile支持的参数有：

• • file：文件路径，可以是绝对路径，也可以是相对路径。

• • text：要写入的文件内容。

• • encoding（可选）：目标文件的编码。如果留空，则使用操作系统默认的编码。如果写的是Base64的数据，则可以使用Base64编码

readFile：

读取文件内容读取指定文件的内容，以文本返回。

readFile支持的参数有：

• • file：路径，可以是绝对路径，也可以是相对路径。

• • encoding（可选）：读取文件时使用的编码。示例如下：

// Declarative //
pipeline {
    agent any
    triggers {
        cron('H */4 * * 1-5')
    }
    stages {
        stage('Example') {
            steps {
                script{
                    echo 'Hello World'
                    dir("/Volumes/MyPassport/jenkins/var"){
                        deleteDir()
                    }
                    json_file = "/Volumes/MyPassport/jenkins/te/test.txt"
                    if(fileExists(json_file) == true) {
                      echo("${json_file} file is exists")  // 打印
                    }else {
                      error("here haven't find json file")  // 打印错误信息
                    }
                    // 读文件
                    file_contents = readFile json_file
                    println file:"${file_contents}",encoding: 'UTF-8'

                    // 写入文件的路径
                    write_file_path  = "/Volumes/MyPassport/jenkins/te/test1.txt"
                    // 写入的内容
                    file_contents_wr = 'Hell, 我是大海！'
                    // 写入操作
                    writeFile file: write_file_path, text: file_contents_wr, encoding: "UTF-8"
                    // 读取写入的文件
                    fileContents_wr = readFile file:"${write_file_path }",encoding: 'UTF-8'
                    println fileContents_wr

                    println pwd()

                }
                
            }
            
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

执行结果

Started by user liwei
[Pipeline] Start of Pipeline
[Pipeline] node
Running on Jenkins in /Users/liwei/.jenkins/workspace/triggersTest
[Pipeline] {
[Pipeline] stage
[Pipeline] { (Example)
[Pipeline] script
[Pipeline] {
[Pipeline] echo
Hello World
[Pipeline] dir
Running in /Volumes/MyPassport/jenkins/var
[Pipeline] {
[Pipeline] deleteDir
[Pipeline] }
[Pipeline] // dir
[Pipeline] fileExists
[Pipeline] echo
/Volumes/MyPassport/jenkins/te/test.txt file is exists
[Pipeline] readFile
[Pipeline] echo
{file=abcdefg
, encoding=UTF-8}
[Pipeline] writeFile
[Pipeline] readFile
[Pipeline] echo
Hell, 我是大海！
[Pipeline] pwd
[Pipeline] echo
/Users/liwei/.jenkins/workspace/triggersTest
[Pipeline] }
[Pipeline] // script
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

1.7.2 制品相关步骤

stash：保存临时文件

stash步骤可以将一些文件保存起来，以便被同一次构建的其他步骤或阶段使用。如果整个pipeline的所有阶段在同一台机器上执行，则stash步骤是多余的。所以，通常需要stash的文件都是要跨Jenkins node使用的。当文件大小为5∼100MB时，应该考虑使用其他替代方案。

stash步骤的参数列表如下：

• name：字符串类型，保存文件的集合的唯一标识。

• allowEmpty：布尔类型，允许stash内容为空。

• excludes：字符串类型，将哪些文件排除。如果排除多个文件，则使用逗号分隔。留空代表不排除任何文件。

• includes：字符串类型，stash哪些文件，留空代表当前文件夹下的所有文件。

• useDefaultExcludes：布尔类型，如果为true，则代表使用Ant风格路径默认排除文件列表。除了name参数，其他参数都是可选的。excludes和includes使用的是Ant风格路径表达式。

unstash：取出之前stash的文件

unstash步骤只有一个name参数，即stash时的唯一标识。通常stash与unstash步骤同时使用。以下是完整示例。

pipeline {

    agent any
    stages{

        stage('stash') {
            steps {
                echo "$BUILD_NUMBER"
                writeFile file: "a.txt", text: "$BUILD_NUMBER", encoding: "UTF-8"
                stash(name: "abc", includes: "a.txt")
            }
        }
        
        stage('unstash') {
            steps {
                script{
                    unstash("abc")
                    content = readFile("a.txt") 
                    echo "${content}"
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Started by user liwei
[Pipeline] Start of Pipeline
[Pipeline] node
Running on Jenkins in /Users/liwei/.jenkins/workspace/stashTest
[Pipeline] {
[Pipeline] stage
[Pipeline] { (stash)
[Pipeline] echo
7
[Pipeline] writeFile
[Pipeline] stash
Stashed 1 file(s)
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (unstash) (hide)
[Pipeline] script
[Pipeline] {
[Pipeline] unstash
[Pipeline] readFile
[Pipeline] echo
7
[Pipeline] }
[Pipeline] // script
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1.7.3 命令相关步骤

与命令相关的步骤其实是Pipeline：Nodes and Processes插件提供的步骤。由于它是Pipeline插件的一个组件，所以基本不需要单独安装。

sh：执行shell命令

sh步骤支持的参数有：

• • script：将要执行的shell脚本，通常在类UNIX系统上可以是多行脚本。

• • encoding：脚本执行后输出日志的编码，默认值为脚本运行所在系统的编码。

• • returnStatus：布尔类型，默认脚本返回的是状态码，如果是一个非零的状态码，则会引发pipeline执行失败。如果returnStatus参数为true，则不论状态码是什么，pipeline的执行都不会受影响。

• • returnStdout：布尔类型，如果为true，则任务的标准输出将作为步骤的返回值，而不是打印到构建日志中（如果有错误，则依然会打印到日志中）。除了script参数，其他参数都是可选的。returnStatus与returnStdout参数一般不会同时使用，因为返回值只能有一个。如果同时使用，则只有returnStatus参数生效。

pipeline {

    agent any
    stages{
        
        stage('unstash') {
            steps {
                script{
                    dir("/Volumes/MyPassport/jenkins"){
                        println pwd()
                        abc = sh script: "/Volumes/MyPassport/jenkins/te.sh" ,returnStdout: true
                        echo "${abc}"
                    }
                    
                }
            }
        }
    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Started by user liwei
[Pipeline] Start of Pipeline (hide)
[Pipeline] node
Running on Jenkins in /Users/liwei/.jenkins/workspace/shTest
[Pipeline] {
[Pipeline] stage
[Pipeline] { (unstash)
[Pipeline] script
[Pipeline] {
[Pipeline] dir
Running in /Volumes/MyPassport/jenkins
[Pipeline] {
[Pipeline] pwd
[Pipeline] echo
/Volumes/MyPassport/jenkins
[Pipeline] sh
+ /Volumes/MyPassport/jenkins/te.sh
[Pipeline] echo
test for sh ...

[Pipeline] }
[Pipeline] // dir
[Pipeline] }
[Pipeline] // script
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1.7.4 其他步骤

error：主动报错，中止当前pipeline

error 步骤的执行类似于抛出一个异常。它只有一个必需参数：message。通常省略参数：error（“there’s an error”）。

tool：使用预定义的工具

如果在Global Tool Configuration（全局工具配置）中配置了工具，如图3-4所示，比如配置了Docker，那么可以通过tool步骤得到工具路径。

tool步骤支持的参数有：

• • name：工具名称。

• • type（可选）：工具类型，指该工具安装类的全路径类名。

每个插件的type值都不一样，而且绝大多数插件的文档根本不写type值。除了到该插件的源码中查找，还有一种方法可以让我们快速找到type值，就是前往Jenkins pipeline代码片段生成器中生成该tool步骤的代码即可，

timeout：代码块超时时间

为timeout步骤闭包内运行的代码设置超时时间限制。如果超时，将抛出一个org.jenkinsci.plugins.workflow.steps.FlowInterruptedException异常。

timeout步骤支持如下参数：

• • time：整型，超时时间。

• • unit（可选）：时间单位，支持的值有NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS、MINUTES（默认）、HOURS、DAYS。

• • activity（可选）：布尔类型，如果值为true，则只有当日志没有活动后，才真正算作超时。

waitUntil：等待条件满足

不断重复waitUntil块内的代码，直到条件为true。waitUntil不负责处理块内代码的异常，遇到异常时直接向外抛出。waitUntil步骤最好与timeout步骤共同使用，避免死循环。

pipeline {

    agent any
    stages{
        
        stage('unstash') {
            steps {
                script{
                    dir("/Volumes/MyPassport/jenkins"){
                    
                        println pwd()
                        timeout(50){
                            waitUntil{
                                abc = sh script: "/Volumes/MyPassport/jenkins/te.sh" ,returnStdout: true
                                echo "${abc}"
                                return true
                            }
                        }
                    }
                    
                }
            }
        }
    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

retry：重复执行块

执行N 次闭包内的脚本。如果其中某次执行抛出异常，则只中止本次执行，并不会中止整个retry的执行。同时，在执行retry的过程中，用户是无法中止pipeline的。

1

sleep：让pipeline休眠一段时间

sleep步骤可用于简单地暂停pipeline，

其支持的参数有：

• time：整型，休眠时间。

• unit（可选）：时间单位，支持的值有NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS（默认）、MINUTES、HOURS、DAYS。示例如下：

sleep(120) // 休眠120秒
sleep(time: 2,unit: MINUTES) //休眠2分钟
1
2

使用VS Code扩展校验Jenkinsfile

1.8小结