build.gradle

import org.labkey.gradle.util.BuildUtils
import org.labkey.gradle.util.PomFileHelper
import org.labkey.gradle.util.GroupNames
import org.labkey.gradle.task.CheckForVersionConflicts
import org.labkey.gradle.plugin.extension.ServerDeployExtension

plugins {
    id "java"
    id "maven-publish"
    id "org.springframework.boot" version "${springBootVersion}"
    id "io.spring.dependency-management" version "1.0.8.RELEASE"
}

// 'dependency-management' plugin doesn't allow us to use 'resolutionStrategy.force' to lock versions
ext['log4j2.version'] = log4j2Version

sourceSets {
    main {
        java {
            srcDirs = ['src']
        }
    }
}

configurations {
    developmentOnly
    runtimeClasspath {
        extendsFrom developmentOnly
    }
    embedded
}

configurations.configureEach {
    exclude group: 'ch.qos.logback', module: 'logback-classic'
    exclude group: 'org.apache.logging.log4j', module: 'log4j-to-slf4j'
}

dependencies {
    // Needed to support composite Log4j2 plugins using JSONLayout elements
    implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonDatabindVersion}"

    implementation("org.springframework.boot:spring-boot-starter-web:${springBootVersion}") {
        exclude group: "org.springframework.boot", module: "spring-boot-starter-json" // Not used (?) and pulls in an old version of Jackson
        exclude group: "jakarta.annotation", module: "jakarta.annotation-api" // Already present in tomcat-annotations-api
        exclude group: "org.apache.tomcat.embed", module: "tomcat-embed-core" // We want to force apacheTomcatVersion
    }

    // Allows forcing a Spring Framework version that differs from spring-boot's version (e.g., to address CVEs)
    implementation('org.springframework:spring-web') {
        version {
            strictly "${springVersion}"
        }
    }

    // Allows forcing a Tomcat version that differs from spring-boot's version (e.g., to address CVEs or regressions,
    // or to test a Tomcat release candidate)
    implementation('org.apache.tomcat.embed:tomcat-embed-core') {
        version {
            strictly "${apacheTomcatVersion}"
        }
    }
    implementation('org.apache.tomcat.embed:tomcat-embed-el') {
        version {
            strictly "${apacheTomcatVersion}"
        }
    }
    implementation('org.apache.tomcat.embed:tomcat-embed-websocket') {
        version {
            strictly "${apacheTomcatVersion}"
        }
        exclude group: "org.apache.tomcat.embed", module: "tomcat-embed-core" // We want to force apacheTomcatVersion
    }
    implementation('org.apache.tomcat:tomcat-annotations-api') {
        version {
            strictly "${apacheTomcatVersion}"
        }
    }

    runtimeOnly "org.apache.tomcat.embed:tomcat-embed-jasper:${apacheTomcatVersion}"
    runtimeOnly("org.apache.tomcat:tomcat-dbcp:${apacheTomcatVersion}") {
        exclude group: "org.apache.tomcat", module: "tomcat-juli"
    }
    implementation ("org.apache.logging.log4j:log4j-slf4j2-impl:${log4j2Version}") {
        exclude group: 'commons-logging', module: 'commons-logging'
    }

    implementation "commons-io:commons-io:${commonsIoVersion}"
    implementation "org.apache.logging.log4j:log4j-core:${log4j2Version}"

    developmentOnly("org.springframework.boot:spring-boot-devtools")
}

BuildUtils.addLabKeyDependency(project: project, config: "implementation", depProjectPath: BuildUtils.getBootstrapProjectPath(gradle))

project.tasks.register(
    "checkVersionConflicts", CheckForVersionConflicts)
        { CheckForVersionConflicts task ->
            task.group = GroupNames.BUILD
            task.description = "Check for conflicts in version numbers of jar file and files already in the build directory ${ServerDeployExtension.getEmbeddedServerDeployDirectoryPath(project)}. " +
                    "Default action on detecting a conflict is to fail. Use -PversionConflictAction=[delete|fail|warn] to change this behavior. The value 'delete' will cause the " +
                    "conflicting version(s) in the ${ServerDeployExtension.getEmbeddedServerDeployDirectoryPath(project)} directory to be removed."
            task.directory = new File(ServerDeployExtension.getEmbeddedServerDeployDirectoryPath(project))
            task.extension = "jar"
            task.cleanTask = "server:cleanEmbeddedDeploy"
            task.collection = project.tasks.bootJar.outputs.files
        }

project.publishing {
    publications {
        embeddedJar(MavenPublication) {
            groupId = 'org.labkey.build'
            artifactId = 'embedded'
            version = project.version
            artifact project.tasks.bootJar.outputs.files.singleFile
            pom {
                name = "LabKey Server Embedded"
                description = "LabKey classes for producing distributions with embedded TomCat."
                developers PomFileHelper.getLabKeyTeamDevelopers()
                licenses PomFileHelper.getApacheLicense()
                organization PomFileHelper.getLabKeyOrganization()
                scm PomFileHelper.getLabKeyGitScm()
            }
        }

        if (BuildUtils.shouldPublish(project))
        {
            project.artifactoryPublish {
                publications('embeddedJar')
            }
            project.artifactoryPublish.skip = false
        }
    }
}

project.artifacts {
    embedded project.tasks.bootJar
}

// The primary artifact from this build should be the jar produced from the bootJar task as that contains
// the SpringBoot classes. This default jar task produces a jar file containing only the classes from src,
// which no one really needs. If produced, this is the jar file that will be used in distributions, making
// them not really embedding anything.
jar {
 onlyIf { false }
}