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

PerforceVcsRoot

Example. Defines a Perforce VCS root for a Perforce stream with automatic monitoring of sub-streams.

object StreamBasedRootWithSubStreams : PerforceVcsRoot({
    name = "Stream-based root with sub-streams"
    port = "perforce:1666"

    mode = stream {
        streamName = "//streams/project/mainline"
        enableFeatureBranches = true
        branchSpec = """
            +://streams/project/(*)
            -://streams/project/release1.0
        """.trimIndent()
    }

    // Create a non-stream workspace but allow using TeamCity checkout rules.
    // When false (default), TeamCity creates a stream workspace which allows commit back to P4
    nonStreamWorkspace = true

    userName = "tcAdmin"
    password = "credentialsJSON:******"

    // Instead of polling, consider using commit hooks:
    // https://www.jetbrains.com/help/teamcity/configuring-vcs-post-commit-hooks-for-teamcity.html#Setting+up+post-commit+hook+on+Perforce+server
    pollInterval = 120
})

Example. Defines a Perforce VCS root with some client mapping and some custom workspace options.

object MainRoot : PerforceVcsRoot({
    name = "Main root"

    port = "perforce:1666"
    mode = clientMapping {
        mapping = """
            //depot/MyProject/... //team-city-agent/...
            //depot/Library1/... //team-city-agent/lib1/...
            //depot/Library2/... //team-city-agent/lib2/...
            -//depot/Library2/xxx/... //team-city-agent/lib1/xxx/...
        """.trimIndent()
    }

    workspaceOptions = """
        Options:        noallwrite clobber nocompress unlocked nomodtime rmdir
        Host:           %teamcity.agent.hostname%
        SubmitOptions:  revertunchanged
        LineEnd:        local
    """.trimIndent()

    userName = "tcAdmin"
    password = "credentialsJSON:******"
})

Example. Defines a Perforce VCS root with checkout mapping based on a specific non-stream client. Also, an explicit p4 clean will be run for each checkout, and utf8 encoding will be used when obtaining sources from the Perforce server.

object ClientBasedRoot : PerforceVcsRoot({
    name = "Client-based root"
    port = "perforce:1666"

    mode = client {
        clientName = "teamcityClient"
    }

    userName = "tcAdmin"
    password = "credentialsJSON:******"

    runP4Clean = true
    charsetName = "utf8"
})

Constructors

PerforceVcsRoot

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

constructor()

Types

Mode

sealed class Mode : CompoundParam<PerforceVcsRoot.Mode>

Properties

charsetName

var charsetName: <Error class: unknown class>

A charset to use on the client machine

checkoutRevision

var checkoutRevision: <Error class: unknown class>

Custom Perforce revision/label to checkout

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).

mode

var mode: <Error class: unknown class>

A mode of Perforce connection

name

var name: String

VCS root name

nonStreamWorkspace

var nonStreamWorkspace: <Error class: unknown class>

When set, the created Perforce workspace on agent will not be stream-enabled. The option allows using arbitrary checkout rules, but prohibits commits from agent into the stream.

p4Path

var p4Path: <Error class: unknown class>

A path to p4 executable

paramRefs

open val paramRefs: VcsRootRefs

Helper for creating references to parameters of this VCS root

params

val params: List<Parameter>

password

var password: <Error class: unknown class>

A password for Perforce connection

pollInterval

var pollInterval: Int?

VCS root polling interval, in seconds

port

var port: <Error class: unknown class>

A Perforce server address in the "host:port" format

runP4Clean

var runP4Clean: <Error class: unknown class>

Whether TeamCity should run 'p4 clean' command before the build

skipHaveListUpdate

var skipHaveListUpdate: <Error class: unknown class>

Whether TeamCity should track files on the Perforce server on sync

supportUtf16

var supportUtf16: <Error class: unknown class>

Enables support for files with UTF-16 encoding

syncOptions

var syncOptions: <Error class: unknown class>

Additional options for the p4 sync command

type

var type: String

VCS type

userName

var userName: <Error class: unknown class>

A username for Perforce connection

useTicketBasedAuth

var ~~useTicketBasedAuth~~: <Error class: unknown class>

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.

workspaceOptions

var workspaceOptions: <Error class: unknown class>

Settings for the p4 client command.

Functions

booleanParameter

fun booleanParameter(customName: String? = null, trueValue: String? = "true", falseValue: String? = "false"): <Error class: unknown class><Parametrized, <Error class: unknown class><Parametrized, T?>>

clear

fun clear()

client

fun client(init: PerforceVcsRoot.Mode.Client.() -> Unit = {}): PerforceVcsRoot.Mode.Client

Connect to to Perforce using the specified client name

clientMapping

fun clientMapping(init: PerforceVcsRoot.Mode.ClientMapping.() -> Unit = {}): PerforceVcsRoot.Mode.ClientMapping

Connect to Perforce using the specified client mapping

compoundParameter

fun <T : CompoundParam<T>> compoundParameter(customName: String? = null): <Error class: unknown class><Parametrized, <Error class: unknown class><Parametrized, 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.

doubleParameter

fun doubleParameter(customName: String? = null): <Error class: unknown class><Parametrized, <Error class: unknown class><Parametrized, T?>>

enumParameter

fun <E : Enum<E>> enumParameter(customName: String? = null, mapping: Map<E, String?>? = null): <Error class: unknown class><Parametrized, <Error class: unknown class><Parametrized, T?>>

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): <Error class: unknown class><Parametrized, <Error class: unknown class><Parametrized, T?>>

param

fun param(name: String, value: String)

Adds parameter with specified name and value

removeRawParam

fun removeRawParam(paramName: String)

stream

fun stream(init: PerforceVcsRoot.Mode.Stream.() -> Unit = {}): PerforceVcsRoot.Mode.Stream

Connect to Perforce stream with specified name

stringParameter

open fun stringParameter(customName: String? = null): <Error class: unknown class><Parametrized, <Error class: unknown class><Parametrized, T?>>

toString

open override fun toString(): String

validate

open override fun validate(consumer: ErrorConsumer)

Validates this object and reports found errors to the provided consumer