build.gradle

/*
 * Copyright 2014-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
 */

import org.jetbrains.kotlin.konan.target.HostManager

buildscript {
    /*
     * These property group is used to build ktor against Kotlin compiler snapshot.
     * How does it work:
     * When build_snapshot_train is set to true, kotlin_version property is overridden with kotlin_snapshot_version,
     * atomicfu_version, coroutines_version, serialization_version and kotlinx_io_version are overwritten by TeamCity environment.
     * Additionally, mavenLocal and Sonatype snapshots are added to repository list and stress tests are disabled.
     * DO NOT change the name of these properties without adapting kotlinx.train build chain.
     */
    def prop = rootProject.properties['build_snapshot_train']
    ext.build_snapshot_train = prop != null && prop != ""
    if (build_snapshot_train) {
        ext.kotlin_version = rootProject.properties['kotlin_snapshot_version']
        if (kotlin_version == null) {
            throw new IllegalArgumentException("'kotlin_snapshot_version' should be defined when building with snapshot compiler")
        }
        repositories {
            mavenLocal()
            maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
        }

        configurations.classpath {
            resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                if (details.requested.group == 'org.jetbrains.kotlin') {
                    details.useVersion kotlin_version
                }
            }
        }
    }
    // These three flags are enabled in train builds for JVM IR compiler testing
    ext.jvm_ir_enabled = rootProject.properties['enable_jvm_ir'] != null
    ext.jvm_ir_api_check_enabled = rootProject.properties['enable_jvm_ir_api_check'] != null
    // This flag is also used in settings.gradle to exclude native-only projects
    ext.native_targets_enabled = rootProject.properties['disable_native_targets'] == null

    repositories {
        mavenLocal()
        mavenCentral()
        google()
        gradlePluginPortal()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
        classpath "org.jetbrains.kotlinx:atomicfu-gradle-plugin:$atomicfu_version"
        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
        classpath "org.jetbrains.kotlinx:binary-compatibility-validator:$validator_version"
        classpath "com.android.tools.build:gradle:$android_gradle_version"
        classpath("org.jmailen.gradle:kotlinter-gradle:$ktlint_version")
    }

    CacheRedirector.configureBuildScript(buildscript, rootProject)
}


ext.configuredVersion = project.hasProperty("releaseVersion") ? project.releaseVersion : project.version
ext.globalM2 = "$buildDir/m2"
ext.publishLocal = project.hasProperty("publishLocal")

apply from: "gradle/experimental.gradle"
apply from: 'gradle/verifier.gradle'

/**
 * `darwin` is subset of `posix`.
 * Don't create `posix` and `darwin` sourceSets in single project.
 */
def platforms = ["common", "jvm", "js"]

if (native_targets_enabled) {
    platforms += ["posix", "darwin"]
}

ext.skipPublish = []
ext.nonDefaultProjectStructure = ["ktor-bom"]

def projectNeedsPlatform(project, platform) {
    if (rootProject.ext.skipPublish.contains(project.name)) return platform == "jvm"

    def files = project.projectDir.listFiles()
    def hasPosix = files.any { it.name == "posix" }
    def hasDarwin = files.any { it.name == "darwin" }

    if (hasPosix && hasDarwin) return false

    if (hasPosix && platform == "darwin") return false
    if (hasDarwin && platform == "posix") return false
    if (!hasPosix && !hasDarwin && platform == "darwin") return false

    return files.any { it.name == "common" || it.name == platform }
}

def check(Object version, String libVersion, String libName) {
    if (version != libVersion) {
        throw new IllegalStateException("Current deploy version is $version, but $libName version is not overridden ($libVersion)")
    }
}

def disabledExplicitApiModeProjects = [
    "ktor-client-tests",
    "ktor-client-json-tests",
    "ktor-server-test-host",
    "ktor-server-test-suites",
    "ktor-server-tests"
]

apply from: 'gradle/compatibility.gradle'

allprojects {
    group = "io.ktor"
    version = configuredVersion
    project.ext.hostManager = new HostManager()

    if (build_snapshot_train) {
        ext.kotlin_version = rootProject.properties['kotlin_snapshot_version']
        println "Using Kotlin $kotlin_version for project $it"
        def deployVersion = properties['DeployVersion']
        if (deployVersion != null) version = deployVersion

        def skipSnapshotChecks = rootProject.properties['skip_snapshot_checks'] != null
        if (!skipSnapshotChecks) {
            check(version, atomicfu_version, "atomicfu")
            check(version, coroutines_version, "coroutines")
            check(version, serialization_version, "serialization")
        }
        kotlin_version = rootProject.properties['kotlin_snapshot_version']
        repositories {
            mavenLocal()
            maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
        }
    }

    repositories {
        mavenLocal()
        mavenCentral()
        maven { url "https://maven.pkg.jetbrains.space/public/p/kotlinx-html/maven" }
    }

    CacheRedirector.configure(project)

    if (rootProject.ext.nonDefaultProjectStructure.contains(project.name)) return

    apply plugin: "kotlin-multiplatform"

    apply from: rootProject.file("gradle/utility.gradle")

    project.ext.nativeTargets = []
    project.ext.nativeCompilations = []
    platforms.each { platform ->
        if (projectNeedsPlatform(project, platform)) {
            configure([it]) {
                apply from: rootProject.file("gradle/${platform}.gradle")
            }
        }
    }

    configurations { testOutput }

    kotlin {
        if (!disabledExplicitApiModeProjects.contains(project.name)) {
            explicitApi()
        }

        sourceSets.matching { !(it.name in ["main", "test"]) }.all {
            def srcDir = name.endsWith("Main") ? "src" : "test"
            def resourcesPrefix = name.endsWith("Test") ? "test-" : ""
            def platform = name[0..-5]

            kotlin.srcDirs = ["$platform/$srcDir"]
            resources.srcDirs = ["$platform/${resourcesPrefix}resources"]

            languageSettings {
                progressiveMode = true
                experimentalAnnotations.each { useExperimentalAnnotation(it) }

                if (project.path.startsWith(":ktor-server:ktor-server") && project.name != "ktor-server-core") {
                    useExperimentalAnnotation("io.ktor.server.engine.EngineAPI")
                }
            }
        }
    }

    if (!rootProject.ext.skipPublish.contains(project.name)) {
        apply from: rootProject.file('gradle/dokka.gradle')
        apply from: rootProject.file('gradle/publish.gradle')
    }
}

if (project.hasProperty("enableCodeStyle")) {
    apply from: 'gradle/codestyle.gradle'
}

task rootAllTest(type: org.jetbrains.kotlin.gradle.testing.internal.KotlinTestReport) {
    def rootAllTest = it
    destinationDir = new File(project.buildDir, "reports/tests/rootAllTest")

    allprojects {
        it.afterEvaluate {
            if (it.tasks.findByName("allTests") != null) {
                def projectTests = it.tasks.named("allTests")
                rootAllTest.addChild(projectTests)
                rootAllTest.dependsOn(projectTests)
            }
        }
    }

    beforeEvaluate {
        project.gradle.taskGraph.whenReady { graph ->
            rootAllTest.maybeOverrideReporting(graph)
        }
    }
}

build.dependsOn(rootAllTest)

println("Using Kotlin compiler version: $org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION")
if (build_snapshot_train) {
    println "Hacking test tasks, removing stress and flaky tests"
    allprojects {
        tasks.withType(Test).all {
            exclude '**/*ServerSocketTest*'
            exclude '**/*NettyStressTest*'
            exclude '**/*CIOMultithreadedTest*'
            exclude '**/*testBlockingConcurrency*'
            exclude '**/*testBigFile*'
            exclude '**/*numberTest*'
            exclude '**/*testWithPause*'
            exclude '**/*WebSocketTest*'
            exclude '**/*PostTest*'
            exclude '**/*testCustomUrls*'
            exclude '**/*testStaticServeFromDir*'
            exclude '**/*testRedirect*'
            exclude '**/*CIOHttpsTest*'

        }
    }

    println "Manifest of kotlin-compiler-embeddable.jar"
    configure(subprojects.findAll { it.name == "ktor-client" }) {
        configurations.matching { it.name == "kotlinCompilerClasspath" }.all {
            resolvedConfiguration.getFiles().findAll { it.name.contains("kotlin-compiler-embeddable") }.each {
                def manifest = zipTree(it).matching {
                    include 'META-INF/MANIFEST.MF'
                }.getFiles().first()

                manifest.readLines().each {
                    println it
                }
            }
        }
    }
}

afterEvaluate {
    def allCompileKotlinTasks = subprojects.collect {
        it.hasProperty("compileKotlinJvm") ? [it.compileKotlinJvm] : []
    }.flatten()

    task dokkaWebsite(type: dokka.getClass()) {
        outputFormat = 'kotlin-website'
        outputDirectory = "${rootProject.projectDir}/apidoc"

        kotlinTasks { allCompileKotlinTasks }

        reportUndocumented = false
    }
}

if (project.hasProperty("enable-coverage")) {
    apply from: "gradle/jacoco.gradle"
}

// Disable binary compatibility check for JVM IR compiler output by default
if (jvm_ir_enabled) {
    subprojects { project ->
        afterEvaluate {
            configure(tasks.matching { it.name == "apiCheck" }) {
                enabled = enabled && jvm_ir_api_check_enabled
            }
        }
    }
}