在构建链中使用参数

输入和输出参数

创建输出参数

outputParams {
    // Expose predefined parameter as is
    param("originConfName", "%system.teamcity.buildConfName%")

    // Expose modified parameter value
    param("buildNumber", "Build %\system.build.number%")

    // Expose input parameter as is
    param("name", "%existingInputParam%")

    // Expose static value
    param("number", "54")
}

输出参数值中的 %parameterName% 可以引用现有的输入参数或动态创建的参数。例如，以下配置使用输入 "DateFormat" 参数来计算通过 setParameter 服务消息创建的 "Date" 参数的值：

import jetbrains.buildServer.configs.kotlin.*
import jetbrains.buildServer.configs.kotlin.buildSteps.csharpScript

object CalculateDate : BuildType({
    name = "Calculate Date"

    params {
        param("DateFormat", "dd/MM/yyyy") // Input parameter
    }

    steps {
        csharpScript {
            id = "csharpScript"
            content = """
                var date = DateTime.Now;
                // Calculate and add a new 'Date' parameter
                // Its value is shared by the output parameter
                Console.WriteLine("##teamcity[setParameter name='Date' value='" + date.ToString("%DateFormat%") + "']");
            """.trimIndent()
            tool = "%teamcity.tool.TeamCity.csi.DEFAULT%"
        }
    }
})

object CalculateDate : BuildType({
    params {
        param("DateFormat", "dd/MM/yyyy")
    }
    outputParams {
        exposeAllParameters = false
        param("OutputDate", "%Date%")
    }
})

现在，输出参数可以被依赖于原始配置的另一个配置访问。要访问参数，请使用 dep.<origin configuration ID>.<output parameter name> 语法。

object PrintDate : BuildType({
    name = "Print Date"

    // Retrieve the 'OutputDate' value and print it
    steps {
        script {
            id = "simpleRunner"
            scriptContent = """echo "The date is ${CalculateDate.depParamRefs["OutputDate"]}""""
        }
    }

    // An artifact or snapshot dependency is required
    // to access another configuration's parameter
    dependencies { snapshot(CalculateDate) {} }
})

公开所有输入参数

如果启用了此设置，则所有输入参数都可以通过 dep.<config ID>.<parameter name> 语法被依赖配置访问。为了向后兼容，此设置默认启用。但是，我们强烈建议您执行以下操作：

这样可以确保配置保持易于维护：您可以根据需要编辑和删除输入参数，而不会意外破坏通过 dep... 语法使用这些参数的下游配置。此外，这通过隐藏从未设计为共享的参数来增强安全性。

从依赖配置中访问输出参数

依赖构建可以以 dep.<bcID>.<parameter_name> 的形式访问前一个链构建的输出参数，其中 bcID 是您需要访问其参数值的源构建配置的 ID。

您可以使用 dep... 参数，即使当前配置仅具有间接依赖关系，也可以从配置中访问参数。例如，在 A → B → C 的链中，C 依赖于 B，B 依赖于 A，配置 C 可以访问 A 的参数。

以下构建配置用于构建并推送 Docker 镜像。这个镜像的名称被写入到 DockerImageName 参数中。

TAG=v1
docker build -f Dockerfile --tag your.registry/MyApp:${TAG}
docker push your.registry/MyApp:v1
echo "##teamcity[setParameter name='DockerImageName' value='MyApp:${TAG}']"

如果此配置的 ID 是“ConfigA”，则构建链下游执行的构建可以访问图像名称为 dep.ConfigA.DockerImageName：

docker run -d your.registry/%\dep.ConfigA.DockerImageName%

覆盖前置配置的输入参数

添加一个具有 reverse.dep.<build_conf_ID>.<parameter_name> 名称语法的参数，以覆盖当前配置之前的目标配置中定义的输入 <parameter_name> 参数。

例如，以下的 Kotlin 代码定义了一个项目，该项目包含三个构建配置，这些配置在一个单一的构建链中统一（ConfigA → ConfigB → ConfigC）。每个构建配置都有一个 chain.ConfigX.param 参数，并带有其自定义值。最后的配置有额外的 reverse.dep.ChainConfigA.chain.ConfigA.param 参数。

import jetbrains.buildServer.configs.kotlin.*

project {
    buildType(ChainConfigA)
    buildType(ChainConfigB)
    buildType(ChainConfigC)
}

object ChainConfigA : BuildType({
    name = "ChainConfigA"

    params {
        param("chain.ConfigA.param", "Config A")
    }

    steps {
        script {
            scriptContent = """echo "Parameter value is: %chain.ConfigA.param%""""
        }
    }
})

object ChainConfigB : BuildType({
    name = "ChainConfigB"

    params {
        param("chain.ConfigB.param", "Config B")
    }

    steps {
        script {
            scriptContent = """echo "Parameter value is: %chain.ConfigB.param%""""
        }
    }

    dependencies {
        snapshot(ChainConfigA) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

object ChainConfigC : BuildType({
    name = "ChainConfigC"

    params {
        param("chain.ConfigC.param", "Config C")
        param("reverse.dep.ChainConfigA.chain.ConfigA.param", "Value Overridden in ConfigC")
    }

    steps {
        script {
            scriptContent = """echo "Parameter value is: %chain.ConfigC.param%""""
        }
    }

    dependencies {
        snapshot(ChainConfigB) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

# ConfigA build log
Parameter value is: Config A

# ConfigA build log
Parameter value is: Value Overridden in ConfigC

您可以在参数名称中使用 * 通配符，以便在多个前面的配置中使用相同的参数。例如，以下示例中的 ConfigC 具有 reverse.dep.ChainConfig*.MyParam 参数，该参数覆盖了 ConfigA 和 ConfigB 中的 MyParam。

object ChainConfigA : BuildType({
    params {
        param("MyParam", "OriginalValue_A")
    }
})

object ChainConfigB : BuildType({
    params {
        param("MyParam", "OriginalValue_B")
    }

    dependencies {
        snapshot(ChainConfigA) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

object ChainConfigC : BuildType({
    params {
        param("reverse.dep.ChainConfig*.MyParam", "CustomValue_C")
    }

    dependencies {
        snapshot(ChainConfigB) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

冲突的参数覆盖

object ChainConfigA : BuildType({
    params {
        param("MyParam", "OriginalValue_A")
    }
})

object ChainConfigB : BuildType({
    params {
        // Lower priority
        param("reverse.dep.ChainConfigA.MyParam", "CustomValue_B")
    }

    // Depends on config A
    dependencies {
        snapshot(ChainConfigA) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

object ChainConfigC : BuildType({
    params {
        // Higher priority
        param("reverse.dep.ChainConfigA.MyParam", "CustomValue_C")
    }

    // Depends on config B
    dependencies {
        snapshot(ChainConfigB) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

如果所有冲突的配置都有相似的参数名称，且没有一个明显的赢家，那么 TeamCity 就会报告一个冲突并创建额外的 conflict.<build_config_ID>.<parameter_name>=<value> 参数（每个冲突的配置都有一个）。

object ChainConfigA : BuildType({
    params {
        param("MyParam", "OriginalValue_A")
    }
})

object ChainConfigB : BuildType({
    params {
        // Equal priority
        param("reverse.dep.ChainConfigA.MyParam", "CustomValue_B")
    }

    // Depends on config A
    dependencies {
        snapshot(ChainConfigA) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

object ChainConfigC : BuildType({
    params {
        // Equal priority
        param("reverse.dep.ChainConfigA.MyParam", "CustomValue_C")
    }

    // Depends on config A
    dependencies {
        snapshot(ChainConfigA) {
            reuseBuilds = ReuseBuilds.NO
        }
    }
})

// Composite build configuration that runs the entire chain
object ChainABC : BuildType({
    type = BuildTypeSettings.Type.COMPOSITE
    dependencies {
        snapshot(ChainConfigB) {}
        snapshot(ChainConfigC) {}
    }
})

在构建链中使用参数﻿

输入和输出参数﻿

note

创建输出参数﻿

tip

note

公开所有输入参数﻿

从依赖配置中访问输出参数﻿

覆盖前置配置的输入参数﻿

冲突的参数覆盖﻿

其他考虑因素﻿