TeamCity Kotlin DSL/jetbrains.buildServer.configs.kotlin.buildSteps/DockerCommandStep

DockerCommandStep

open class DockerCommandStep : BuildStep

fun BuildSteps.dockerCommand(init: DockerCommandStep.() -> Unit): DockerCommandStep

A build step for a generic docker command runner (can run Docker build, push, other...)

Example. Adds a Docker Build build step with a source as Dockerfile located in the checkout directory with extra Docker command line argument.

buildType {
    // Other Build Type settings ...
    steps {
        // Other Build Steps ...
        dockerCommand {
            name = "My Docker step"
            commandType = build {
                source = file {
                    path = "my-docker/Dockerfile"
                }
                commandArgs = "--pull"
            }
        }







Content copied to clipboard
    }
}

Example. Adds a Docker Build build step with a URL as Dockerfile with extra platform settings and images names and tags provided (using parameter reference).

buildType {
    // Other Build Type settings ...
    steps {
        // Other Build Steps ...
        dockerCommand {
            name = "My Docker step"
            commandType = build {
                source = url {
                    url = "https://my.repo.org/files/Dockerfile"
                }
                platform = DockerCommandStep.ImagePlatform.Linux
                namesAndTags = """
                    imageName:%myimage.version%
                    otherImage:%myimage.version%
                """.trimIndent()
            }
        }











Content copied to clipboard
    }
}

Example. Adds a Docker Build build step with a source as Dockerfile content provided explicitly in the DSL configuration with extra platform settings and images names and tags provided.

buildType {
    // Other Build Type settings ...
    steps {
        // Other Build Steps ...
        dockerCommand {
            name = "My Docker step"

            commandType = build {
                source = content {
                    content = """
                        Dockerfile content
                    """.trimIndent()
                }
                platform = DockerCommandStep.ImagePlatform.Linux
                namesAndTags = "myImage:1.0"
            }
        }











Content copied to clipboard
    }
}

Example. Adds a Docker Push build step with images names and tags provided (using parameter reference). Additional property for not removing the image after the step is set up. This step will we executed only if build status is sucessfull for previous build steps and extra condition is met.

buildType {
    // Other Build Type settings ...
    steps {
        // Other Build Steps ...
        dockerCommand {
            name = "My Docker push step"

            executionMode = BuildStep.ExecutionMode.RUN_ON_SUCCESS
            conditions {
                equals("teamcity.build.branch", "release")
            }

            commandType = push {
                namesAndTags = "imageName:%myimage.version%"
                removeImageAfterPush = false
            }
        }











Content copied to clipboard
    }
}

Example. Adds a Docker Other build step with a docker command provided and Docker command additional arguments. Custom working directory is provided.

buildType {
    // Other Build Type settings ...
    steps {
        // Other Build Steps ...
        dockerCommand {
            name = "My Docker other (tag) step"

            commandType = other {
                subCommand = "tag"
                workingDir = "docker/images"
                commandArgs = "source target:%myimage.version%"
            }
        }







Content copied to clipboard
    }
}

Constructors

DockerCommandStep

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

constructor()

Types

CommandType

sealed class CommandType : CompoundParam<DockerCommandStep.CommandType>

ImagePlatform

enum ImagePlatform : Enum<DockerCommandStep.ImagePlatform>

Docker image platforms

Properties

commandType

var commandType: <Error class: unknown class>

Specifies the type of the command, at the moment "build", "push", "other"

conditions

var conditions: BuildStepConditions

Optional collection of build step execution conditions

enabled

var enabled: Boolean

Specifies whether the step is enabled, true by default

executionMode

var executionMode: BuildStep.ExecutionMode

Build step execution mode

var id: String?

Optional id of the step. Usually the id is not required, however if a build configuration inherits from a template and wants to override a build step defined there, then both steps should have the same id.

name

var name: String

Build step name

params

val params: List<Parameter>

type

var type: String

Build step type

Functions

booleanParameter

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

build

fun build(init: DockerCommandStep.CommandType.Build.() -> Unit = {}): DockerCommandStep.CommandType.Build

Run "docker build" command

clear

fun clear()

clearConditions

fun clearConditions()

Deletes all configured build step conditions

compoundParameter

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

conditions

fun conditions(init: BuildStepConditions.() -> Unit = {})

Configures build step conditions

copyParamsTo

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

Copies parameters of this object to the specified target

create

open fun create(): BuildStep

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

findRawParam