TeamCity Kotlin DSL/jetbrains.buildServer.configs.kotlin.vcs/GitVcsRoot

GitVcsRoot

Example. Defines a VCS root MyVcsRoot with authentication by an SSH key and registers it in the project and a build configuration.

project {
  ...
  vcsRoot(MyVcsRoot)

  buildType{
    id = "MyBuild"
    name = "MyBuild"

    vcs {
      root(MyVcsRoot)
    }
    ...
  }
  ...
}

object MyVcsRoot: GitVcsRoot({
  name = "My project main repository"
  url = "<repository URL>"
  branch = "refs/heads/main"
  checkoutPolicy = AgentCheckoutPolicy.USE_MIRRORS
  authMethod = uploadedKey {
    uploadedKey = "<SSH key name>"
  }
})

Constructors

GitVcsRoot

fun GitVcsRoot(init: GitVcsRoot.() -> Unit)

GitVcsRoot

fun GitVcsRoot()

Types

AgentCheckoutPolicy

enum AgentCheckoutPolicy : Enum<GitVcsRoot.AgentCheckoutPolicy>

Policy for checking out sources on agent

AgentCleanFilesPolicy

enum AgentCleanFilesPolicy : Enum<GitVcsRoot.AgentCleanFilesPolicy>

Specifies flags for the "git clean" command during agent-side checkout and defines which files will be removed.

AgentCleanPolicy

enum AgentCleanPolicy : Enum<GitVcsRoot.AgentCleanPolicy>

Specifies when the "git clean" command should be executed in case of agent-side checkout

AuthMethod

sealed class AuthMethod : CompoundParam<GitVcsRoot.AuthMethod>

CheckoutSubmodules

enum CheckoutSubmodules : Enum<GitVcsRoot.CheckoutSubmodules>

Submodules checkout mode

UserNameStyle

enum UserNameStyle : Enum<GitVcsRoot.UserNameStyle>

Defines how TeamCity retrieves VCS username from git commit. When the git config contains the following

Functions

anonymous

fun anonymous(): GitVcsRoot.AuthMethod.Anonymous

Anonymous repository access

booleanParameter

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

clear

fun clear()

compoundParameter

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

copyParamsTo

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

Copies parameters of this object to the specified target

create

open fun create(): VcsRoot

Creates an instance of this VCS root 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.

customPrivateKey

fun customPrivateKey(init: GitVcsRoot.AuthMethod.CustomPrivateKey.() -> Unit = {}): GitVcsRoot.AuthMethod.CustomPrivateKey

SSH key on the specified path. Supported only for server-side checkout. Switch to uploaded SSH key if you want to use an agent-side checkout.

defaultPrivateKey

fun defaultPrivateKey(init: GitVcsRoot.AuthMethod.DefaultPrivateKey.() -> Unit = {}): GitVcsRoot.AuthMethod.DefaultPrivateKey

Default SSH key found on the machine. If you use an agent-side checkout, then this key should also be available on the build agent machines. Often it is easier to use the uploaded SSH key.

doubleParameter

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

enumParameter

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

equals

open operator override fun equals(other: Any?): Boolean

findRawParam

fun findRawParam(paramName: String): Parameter?

hashCode

open override fun hashCode(): Int

hasParam

fun hasParam(paramName: String): Boolean

fun id(id: String)

Sets the id to the specified value. Type of the id depends on the context in which DSL is executed: it is RelativeId when DSL context is relative, otherwise it is AbsoluteId.

intParameter

fun intParameter(customName: String? = null): SingleDelegateProvider<Int>

param

fun param(name: String, value: String)

Adds parameter with specified name and value

password

fun password(init: GitVcsRoot.AuthMethod.Password.() -> Unit = {}): GitVcsRoot.AuthMethod.Password

Password authentication

removeRawParam

fun removeRawParam(paramName: String)

stringParameter

fun stringParameter(customName: String? = null): SingleDelegateProvider<String>

token

fun token(init: GitVcsRoot.AuthMethod.Token.() -> Unit = {}): GitVcsRoot.AuthMethod.Token

Authentication with a refreshable token stored in TeamCity token storage

toString

open override fun toString(): String

uploadedKey

fun uploadedKey(init: GitVcsRoot.AuthMethod.UploadedKey.() -> Unit = {}): GitVcsRoot.AuthMethod.UploadedKey

Uploaded SSH key with the specified name.

validate

open override fun validate(consumer: ErrorConsumer)

Validates this object and reports found errors to the provided consumer

Properties

agentCleanFilesPolicy

var agentCleanFilesPolicy: GitVcsRoot.AgentCleanFilesPolicy?

Specifies which files should be removed when "git clean" command is executed during agent-side checkout.

agentCleanPolicy

var agentCleanPolicy: GitVcsRoot.AgentCleanPolicy?

Specifies when the "git clean" command should be executed in case of agent-side checkout

agentGitPath

var agentGitPath: String?

Custom path to git executable on the build agent machine

authMethod

var authMethod: GitVcsRoot.AuthMethod?

VCS Root authentication method

branch

var branch: String?

The default branch name

branchSpec

var branchSpec: String?

Branch specification to use in VCS root

checkoutPolicy

var checkoutPolicy: GitVcsRoot.AgentCheckoutPolicy?

Policy for checking out sources on agent

checkoutSubmodules

var checkoutSubmodules: GitVcsRoot.CheckoutSubmodules?

Whether VCS root should include changes in submodules and check their sources for build. By default submodules are checked out.

open override var id: Id?

VCS root id. It appears in the web UI and is used in urls. If the VCS root has a uuid specified, then the id can be changed at any time. If uuid is omitted, then TeamCity treats a VCS root with a changed id as a new VCS root, all data associated with the old root will be lost (e.g. a commits graph). Id can also be used by some settings, e.g. as a part of parameter reference. If you change the id, you should find all its occurrences in the current project and change them too. Id must be unique across all VCS roots on the server. If id is missing, it will be generated from the class name (if the class is not from the jetbrains.buildServer.configs.kotlin package).

name

var name: String

VCS root name

paramRefs

open val paramRefs: VcsRootRefs

Helper for creating references to parameters of this VCS root

params

val params: List<Parameter>

pollInterval

var pollInterval: Int? = null

VCS root polling interval, in seconds

pushUrl

var pushUrl: String?

Custom repository push url. If not specified then the url specified in the url property is used for push operations.

serverSideAutoCRLF

var serverSideAutoCRLF: Boolean?

Whether TeamCity should convert line-endings of all text files to CRLF during server-side checkout. By default false.

type

var type: String

VCS type

url

var url: String?

Repository url

useMirrors

~~var~~ ~~useMirrors~~: Boolean?

When this option is enabled, TeamCity creates a separate clone of the repository on each agent and uses it in the checkout directory via git alternates. This make agent-side checkout faster. By default true.

userForTags

var userForTags: String?

A username for tag/merge operations in this VCS root. Format: Username

userNameStyle

var userNameStyle: GitVcsRoot.UserNameStyle?

Defines how TeamCity retrieves VCS username from git commit.

useTagsAsBranches

var useTagsAsBranches: Boolean?

When enabled tags matched by branch specification will be shown in UI as regular branches. By default false.

uuid

var uuid: String

VCS root uuid. TeamCity uses it to identify the VCS root. If uuid changes, TeamCity considers it to be a new entity. If uuid is missing, it is reconstructed from VCS root id. Uuid must be unique across all entities on the server.