Jenkins声明性管道：矩阵构建轴的顺序执行

我正在尝试建立一个矩阵构建，并且正在处理几个问题。 矩阵如下所示：

stage( 'BuildAll' ) {
    matrix {
        axes {
            axis {
                name 'PLATFORM'
                values 'win32vc9', 'win32vc19' 
            }                   
            axis {
                name 'VARIANT'
                values 'debug', 'release'                   
            }
            axis {
                name 'MODULES'
                values 'repo1/module1', 'repo1/module2', 'repo2/module1', 'repo2/module2'
            }
        }

        stages {                                                
            stage( 'Checkout' ) {
            }
            stage( 'Build' ) {
            }
            stage( 'Test' ) {
            }
       }

我的问题是：

• jenkins在自己的工作区中执行矩阵的每个单元，但我的模块相互依赖。这就是为什么我想签出它们并在同一个工作区中构建它们。顺便说一句：我的构建系统可以在同一个工作区中与所有变体（debug/release x vc9/vc19）一起工作

• 詹金斯正在并行执行所有单元。我需要的是模块轴执行的序列化

有没有办法解决这个问题

例如，有没有一种方法可以描述像几个模块上的循环这样的东西，它在一行中生成一系列阶段，而不是并行的？在这个序列中，我只能在两个轴上实现矩阵

我知道ExtendedWorkspace插件，但没有找到任何关于如何在声明性管道中使用它的文档

非常感谢！ 当做

---

Christoph指令当前不支持顺序执行。
在当前的

矩阵

语法中，您能做的最好的事情是：

 stage( 'BuildAll' ) {
    matrix {
        axes {
            axis {
                name 'PLATFORM'
                values 'win32vc9', 'win32vc19' 
            }                   
            axis {
                name 'VARIANT'
                values 'debug', 'release'                   
            }
        }
        stages {                
            stage('repo1/module1') {
                stages {
                    stage( 'Checkout' ) {
                    }
                    stage( 'Build' ) {
                    }
                    stage( 'Test' ) {
                    }
                }
            }
            stage('repo1/module2') {
                stages {
                    stage( 'Checkout' ) {
                    }
                    stage( 'Build' ) {
                    }
                    stage( 'Test' ) {
                    }
                }
            }
            stage('repo2/module1') {
                stages {
                    stage( 'Checkout' ) {
                    }
                    stage( 'Build' ) {
                    }
                    stage( 'Test' ) {
                    }
                }
            }
            stage('repo2/module2') {
                stages {
                    stage( 'Checkout' ) {
                    }
                    stage( 'Build' ) {
                    }
                    stage( 'Test' ) {
                    }
                }
            }
        }
    }
}

---

其他人也提出了类似的要求。我是基于这个问题提交的。

我使用

进行
循环，而不是
矩阵
和
轴
语法。我的解决方法不如使用
matrix
语法那么漂亮，但它做了它应该做的事情

String[] platformList = ['win32vc9', 'win32vc19']
String[] variantList = ['debug', 'release']

pipeline{
    agent any
    stages {
        stage('Deploy'){
            steps{
                script{
                    for(platform in platformList){
                        for(variant in variantList){
                            stage("Checkout"){
                                powershell label: '', script: """Write-Output Step1 "${platform}/${variant}/Checkout" """
                            }
                            stage("Build"){
                                powershell label: '', script: """Write-Output Step1 "${platform}/${variant}/Build" """
                            }
                            stage("Test"){
                                powershell label: '', script: """Write-Output Step1 "${platform}/${variant}/Test" """
                            }
                        }
                    }
                }
            }
        }
    }
}


通过使用，您可能可以做您想做的事情

在我的例子中，我只是希望矩阵按顺序构建，而不是并行构建，所以我只是将所有内容包装在一个阶段中，并对其进行锁定。比如：

stage( 'BuildAll' ) {
    matrix {
        axes {
            ...
        }
        stages {                                                
            stage( 'Sequential Matrix' ) {
                options {
                    lock( 'synchronous-matrix' )
                }
                stages {
                    ...
                }
            }
        }
    }
}

一次只能生成一个矩阵配置，因为在当前配置完成之前，其他矩阵配置无法获取锁

但是，在您的例子中，您希望模块按顺序一个接一个地构建。
锁资源的字符串可以是动态的，因此我认为您可以使用从其他两个轴构造的名称来防止同时构建多个模块：

stage( 'BuildAll' ) {
    matrix {
        axes {
            axis {
                name 'PLATFORM'
                values 'win32vc9', 'win32vc19' 
            }                   
            axis {
                name 'VARIANT'
                values 'debug', 'release'                   
            }
            axis {
                name 'MODULES'
                values 'repo1/module1', 'repo1/module2', 'repo2/module1', 'repo2/module2'
            }
        }

        stages {                                                
            stage( 'Force Sequential' ) {
                options {
                    lock( "synchronous-${PLATFORM}-${VARIANT}" )
                }
                stages {
                    stage( 'Checkout' ) {

                    }
                    stage( 'Build' ) {

                    }
                    stage( 'Test' ) {

                    }
                }
            }
        }
    }
}

请注意，这只会保证相同平台和变体的模块不会同时构建，并且不会说明任何有关订购的内容。我不知道Jenkins选择构建轴的顺序是否已定义，但我发现如果存在问题，这可能有助于排序。
我也有同样的问题：我有2个轴，我想先运行轴第一个条目的所有单元格，完成后，我想运行轴第二个条目的所有单元格。但我不认为这是可能的