TeamCity Kotlin DSL 2026.1/jetbrains.buildServer.configs.kotlin.buildFeatures/CommitStatusPublisher

CommitStatusPublisher

open class CommitStatusPublisher : BuildFeature

fun BuildFeatures.commitStatusPublisher(init: CommitStatusPublisher.() -> Unit): CommitStatusPublisher

A build feature publishing status to external system.

Example. Publishes build statuses to GitHub.com / GitHub Enterprise. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = github {
            githubUrl = "<GitHub URL, https://api.github.com for github.com>"
            authType = personalToken { // authType = password { ... } to use username and password
              token = "credentialsJSON:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to GitHub.com / GitHub Enterprise. Uses the credentials of the VCS root.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = github {
            githubUrl = "<GitHub URL, https://api.github.com for github.com>"
            authType = vcsRoot()
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to GitHub.com / GitHub Enterprise. Uses a GitHub App installation token stored in TeamCity.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // A VCS root must be specified to use this authentication type
          publisher = github {
            githubUrl = "<GitHub URL, https://api.github.com for github.com>"
            authType = storedToken {
              tokenId = "tc_token_id:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to GitHub.com / GitHub Enterprise. Sets the buildName value as a status check name displayed in the status message posted to the VCS.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // A VCS root must be specified to use this authentication type
            publisher = github {
              githubUrl = "<GitHub URL, https://api.github.com for github.com>"
              statusCheckName = "Customized GitHub status check name" // optional, can be used for branch protection rules
              authType = storedToken {
                tokenId = "tc_token_id:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to GitLab.com / GitLab CE/EE. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = gitlab {
            gitlabApiUrl = "https://<GitLab URL>/api/v4" // optional, the URL will be composed based on the VCS root fetch URL if omitted (https://gitlab.com/api/v4 for gitlab.com)
            accessToken = personalToken { // authType = vcsRoot() to take credentials from the VCS root
              accessToken = "credentialsJSON:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to GitLab.com / GitLab CE/EE. Instead of personal token authentication a refreshable access token stored in TeamCity is used. Sets the buildName value as build name displayed in the status message posted to the VCS.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = gitlab {
            jobName = "Customized GitLab status job name" // optional
            gitlabApiUrl = "https://<GitLab URL>/api/v4" // optional, the URL will be composed based on the VCS root fetch URL if omitted (https://gitlab.com/api/v4 for gitlab.com)
            authType = storedToken {
              tokenId = "tc_token_id:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to Bitbucket Cloud. The password must be Bitbucket App password generated by user. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = bitbucketCloud {
            authType = password { // authType = vcsRoot() to take credentials from the VCS root
              userName = "<username>"
              password = "credentialsJSON:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to Bitbucket Cloud. Instead of password authentication an access token stored in TeamCity is used. Sets the buildName value as build name displayed in the status message posted to the VCS.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = bitbucketCloud {
            buildName = "Customized Bitbucket Cloud status build name" // optional
            authType = storedToken {
              tokenId = "tc_token_id:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to Bitbucket Server / Data Center. The password can be either user's password (not recommended) or Bitbucket HTTP access token generated by user. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = bitbucketServer {
              url = "<Bitbucket Server Base URL>" // optional, the URL will be composed based on the VCS root fetch URL if omitted
              authType = password { // authType = vcsRoot() to take credentials from the VCS root
                userName = "<username>"
                password = "credentialsJSON:*****"
              }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to Bitbucket Server / Data Center. Instead of password authentication an access token stored in TeamCity is used. Sets the buildName value as build name displayed in the status message posted to the VCS.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = bitbucketServer {
            buildName = "Customized Bitbucket Server / Data Center status build name" // optional
            url = "<Bitbucket Server Base URL>"
            authType = storedToken {
              tokenId = "tc_token_id:*****"
            }
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to Azure DevOps. For now only personal access token authentication type is supported. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = azureDevOps {
            serverUrl = "<Azure DevOps URL>" // optional
            authType = personalToken {
              accessToken = "tc_token_id:*****"
            }
            publishPullRequests = true // optional
          }
        }
Content copied to clipboard
    }
}

Example. Publishes build statuses to Azure DevOps. Instead of password authentication an access token stored in TeamCity is used. Sets the buildName value as build name displayed in the status message posted to the VCS.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = azureDevOps {
            buildName = "Customized Azure DevOps status build name" // optional
            serverUrl = "<Azure DevOps URL>" // optional
            authType = storedToken {
              tokenId = "tc_token_id:*****"
            }
            publishPullRequests = true // optional
          }
        }
Content copied to clipboard
    }
}

Example. Enables publishing build statuses to Perforce P4 Code Review (Helix Swarm). For now only personal access token authentication type is supported. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = swarm {
            serverUrl = "<Swarm URL>"
            username = "<username>"
            token = "credentialsJSON:*****"
            createSwarmTest = true // optional, if set, TeamCity will create a test run on the P4 Code Review (Helix Swarm) server and update its status according to the build status in TeamCity.
            commentOnEvents = true // optional
          }
        }
Content copied to clipboard
    }
}

Example. Enables voting in Gerrit based on build statuses.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = gerrit {
            server = "<Gerrit server URL>"
            gerritProject = "<Gerrit project name>"
            label = "<label>" // e.g. Verified
            failureVote = "<failed build vote>" // e.g. -1
            successVote = "<successful build vote>" // e.g. +1
            userName = "<username>"
            uploadedKey = "<SSH key name>"
          }
        }
Content copied to clipboard
    }
}

Example. Enables publishing build statuses to JetBrains Upsource. It is not recommended to store secure values directly in the DSL code, see Managing Tokens section of our documentation.

buildType {
    // Other Build Type settings ...
    features {
        // Other Build Features ...
        commitStatusPublisher {
          vcsRootExtId = "${<VCS root object>.id}" // optional, publishes to all attached git VCS roots if omitted
          publisher = upsource {
            serverUrl = "<Upsource URL>"
            projectId = "<Upsource project id>"
            userName = "<username>"
            password = "credentialsJSON:*****"
          }
        }
Content copied to clipboard
    }
}

Constructors

CommitStatusPublisher

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

constructor()

Types

Publisher

sealed class Publisher : CompoundParam<CommitStatusPublisher.Publisher>

Properties

enabled

var enabled: Boolean

Specifies whether the feature is enabled, true by default

var id: String?

Build feature id, if not specified will be generated

params

val params: List<Parameter>

publisher

var publisher: CommitStatusPublisher.Publisher?

The type of the VCS provider to which the build status should be published.

type

var type: String

Build feature type

vcsRootExtId

var vcsRootExtId: String?

Id of the VCS root for which commits a status should be published. Set to an empty string to publish status for all VCS roots attached to a build configuration.

yamlParams

val yamlParams: List<Parameter>

yamlType

var yamlType: String

Build feature type in yaml

Functions

azureDevOps

fun azureDevOps(init: CommitStatusPublisher.Publisher.AzureDevOps.() -> Unit = {}): CommitStatusPublisher.Publisher.AzureDevOps

Publish build statuses to Azure DevOps / TFS.

bitbucketCloud

fun bitbucketCloud(init: CommitStatusPublisher.Publisher.BitbucketCloud.() -> Unit = {}): CommitStatusPublisher.Publisher.BitbucketCloud

Publish status to Bitbucket Cloud

bitbucketServer

fun bitbucketServer(init: CommitStatusPublisher.Publisher.BitbucketServer.() -> Unit = {}): CommitStatusPublisher.Publisher.BitbucketServer

Publish build statuses to Bitbucket Server / Data Center.

booleanParameter

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

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

clear

fun clear()

compoundParameter

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

fun <T : CompoundParam<T>> compoundParameter(customName: String? = null, yamlName: 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(): BuildFeature

Creates an instance of this build feature 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

fun doubleParameter(customName: String? = null): DelegateProvider<Double>

fun doubleParameter(customName: String? = null, yamlName: String? = null): DelegateProvider<Double>

enumParameter

fun <E : Enum<E>> enumParameter(customName: String? = null, mapping: Map<E, String?>? = null): DelegateProvider<E>

fun <E : Enum<E>> enumParameter(customName: String? = null, mapping: Map<E, String?>? = null, yamlName: String? = null): DelegateProvider<E>

fun <E : Enum<E>> enumParameter(customName: String? = null, mapping: Map<E, String?>? = null, yamlName: String? = null, yamlMapping: Map<E, String?>? = null): DelegateProvider<E>

findRawParam