import common.requiresOs
import jetbrains.buildServer.configs.kotlin.AbsoluteId
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.CheckoutMode

abstract class BasePromotionBuildType(vcsRootId: String, cleanCheckout: Boolean = true) : BuildType() {
    init {
        vcs {
            root(AbsoluteId(vcsRootId))

            checkoutMode = CheckoutMode.ON_AGENT

        stageTriggers.triggers.forEach(::buildType)
        subProject(stageProject)

        prevStage = stage
        previousPerformanceTestPasses.addAll(stageProject.performanceTests)
        previousCrossVersionTests.addAll(stageProject.crossVersionTests)
    }

    buildType(GitHubMergeQueueCheckPass(model))

    buildTypesOrder = buildTypes

package configurations

import common.Os
import jetbrains.buildServer.configs.kotlin.BuildType
import model.Stage

open class BaseGradleBuildType(
    open val stage: Stage? = null,
    open val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {}
) : BuildType() {
    init {
        this.init()
    }
}

open class OsAwareBaseGradleBuildType(
    val os: Os,
    override val stage: Stage? = null,

import common.gradleWrapper
import common.requiresOs
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.triggers.vcs
import vcsroots.gradlePromotionMaster
import vcsroots.useAbsoluteVcs

// Gradle_Master_Promotion_SanityCheck
object SanityCheck : BuildType({
    id("Promotion_SanityCheck")
    name = "SanityCheck"
    description = "Sanity check for promotion project"

    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {
        functionalTests.forEach(this::buildType)
    }

import common.removeSubstDirOnWindows
import common.substDirOnWindows
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ParameterDisplay
import jetbrains.buildServer.configs.kotlin.ParametrizedWithType

abstract class AdHocPerformanceScenario(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_Performance_AdHocPerformanceScenario${os.asName()}${arch.asName()}"

import common.gradleWrapper
import common.javaHome
import common.requiresOs
import common.uuidPrefix
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.DslContext
import vcsroots.useAbsoluteVcs

object PublishKotlinDslPlugin : BuildType({
    name = "Publish Kotlin DSL Plugin"
    id("Util_PublishKotlinDslPlugin")
    uuid = "${DslContext.uuidPrefix}_Util_PublishKotlinDslPlugin"

    this.id(spec.asConfigurationId(model))
    this.name = spec.asName()
}) {
    init {
        performanceTests.forEach(this::buildType)
    }
}

import common.killProcessStep
import configurations.CompileAll
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ParameterDisplay

class RerunFlakyTest(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
    name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"

    requirements {
        // These tests are usually heavy and the build time is twice on EC2 agents
        requiresNotEc2Agent()
    }

    applyTestDefaults(
        model = model,
        buildType = this,
        gradleTasks = ":smoke-ide-test:smokeIdeTest",
        extraParameters = listOf(
            stage.getBuildScanCustomValueParam(),
            buildScanTagParam("SmokeIdeTests")
        ).joinToString(" "),