TeamCity Kotlin DSL/jetbrains.buildServer.configs.kotlin.triggers/VcsTrigger

VcsTrigger

fun Triggers.vcs(init: VcsTrigger.() -> Unit): VcsTrigger

Base class for VCS triggers. VCS trigger automatically starts a new build each time TeamCity detects new changes.

Example. Trigger a build on a commit but only if there were no other commits for 120 seconds (quiet period), otherwise wait another 120 seconds.

buildType {
    // Other Build Type settings ...
    triggers {
        // Other Triggers ...
        vcs {
          quietPeriodMode = VcsTrigger.QuietPeriodMode.USE_CUSTOM
          quietPeriod = 120
        }
Content copied to clipboard
    }
}

Example. Trigger a build on every commit in the default branch or a branch which name starts with 'release/'.

buildType {
    // Other Build Type settings ...
    triggers {
        // Other Triggers ...
        vcs {
          branchFilter = """
            +:<default>
            +:release/ *
          """.trimIndent()
        }
Content copied to clipboard
    }
}

Example. Do not trigger a build on a commit made by a user with name 'tag_user'. See trigger rules syntax.

buildType {
    // Other Build Type settings ...
    triggers {
        // Other Triggers ...
        vcs {
          triggerRules = "-:user=tag_user:**"
        }
Content copied to clipboard
    }
}

Example. Trigger a single build on every commit. Build queue optimization should also be disabled to avoid including several commits into the one build.

buildType {
    // Other Build Type settings ...
    triggers {
        // Other Triggers ...
        vcs {
          perCheckinTriggering = true
          enableQueueOptimization = false
        }
Content copied to clipboard
    }
}

Constructors

VcsTrigger

constructor(init: VcsTrigger.() -> Unit)

constructor()

Types

QuietPeriodMode

enum QuietPeriodMode : Enum<VcsTrigger.QuietPeriodMode>

Quiet Period Settings

Properties

branchFilter

var branchFilter: String?

Branch filter specifies changes in which branches the trigger should watch

buildParams

val buildParams: TriggerBuildParameters

Parameters that are added to triggered builds

enabled

var enabled: Boolean

Specifies whether the trigger is enabled

enableQueueOptimization

var enableQueueOptimization: Boolean?

Whether the trigger should allow builds optimization in the build queue. By default optimization is enabled. It is ignored when per-check-in triggering is enabled.

enforceCleanCheckout

var enforceCleanCheckout: Boolean

Whether the build should be triggered with clean checkout

enforceCleanCheckoutForDependencies

var enforceCleanCheckoutForDependencies: Boolean

When the enforceCleanCheckout is set to true specifies whether the clean checkout should also be applied to all dependencies.

groupCheckinsByCommitter

var groupCheckinsByCommitter: Boolean?

Whether the trigger should include check-ins from the same user into a build. Works only when per-check-in triggering is enabled.

var id: String?

Trigger id, if not set will be generated

params

val params: List<Parameter>

perCheckinTriggering

var perCheckinTriggering: Boolean?

Whether the trigger should run build on each check-in in VCS.

quietPeriod

var quietPeriod: Int?

Custom quiet period for the trigger, to enable it set the quietPeriodMode to QuietPeriodMode.USE_CUSTOM

quietPeriodMode

var quietPeriodMode: VcsTrigger.QuietPeriodMode?

Quiet Period Settings

triggerRules

var triggerRules: String?

Trigger rules allow to limit the changes that trigger builds

type

var type: String

Trigger type

watchChangesInDependencies

var watchChangesInDependencies: Boolean?

When enabled, the trigger runs builds on changes in snapshot dependencies

Functions

booleanParameter

fun booleanParameter(customName: String? = null, trueValue: String? = "true", falseValue: String? = "false"): DelegateProvider<Boolean?>

buildParams

fun buildParams(init: TriggerBuildParameters.() -> Unit)

Configures build parameters that are applied to triggered builds

clear

fun clear()

clearBuildParams

fun clearBuildParams()

Deletes all configured build parameters

compoundParameter

fun <T : CompoundParam<T>> compoundParameter(customName: String? = null): DelegateProvider<T>

copyParamsTo

fun <T : Parametrized> copyParamsTo(target: T): T

Copies parameters of this object to the specified target

create

open fun create(): Trigger

Creates an instance of this trigger via reflection using a no argument constructor, used during copying. Throws an error if this class doesn't have a default constructor. Subclasses can override it to create an instance without using a default constructor.

doubleParameter