LLMX/build.gradle.kts

plugins {
    alias(libs.plugins.java)
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.kotlin.plugin.spring)
    alias(libs.plugins.spring.boot)
    alias(libs.plugins.jibLocalPlugin)
}

group = "org.jcnc"
version = "1.0-SNAPSHOT"

/**
 * 由于 Kotlin 插件引入时会自动添加依赖，但根项目不需要 Kotlin 依赖，因此需要排除 Kotlin 依赖
 */
configurations.implementation {
    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
}
allprojects {
    // 设置全局属性
    ext {
        set(ProjectFlags.USE_SPRING_BOOT_WEB, false)
        set(ProjectFlags.USE_LLM_KT_IMPL_DEPENDENCE, false)
        set(ProjectFlags.USE_SPRING_CLOUD_BOM, false)
        set(ProjectFlags.IS_ROOT_MODULE, false)
        set(ProjectFlags.USE_SPRING_BOOT_BOM, false)
        set(ProjectFlags.USE_LLM_IMPL_PLATFORM_DEPENDENCE, false)
    }
    repositories {
        mavenLocal()
        maven {
            url = uri("http://49.235.96.75:3001/api/packages/gewuyou/maven")
            isAllowInsecureProtocol = true
        }
        maven {
            url = uri("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/dev")
        }
        maven {
            url = uri("https://maven.aliyun.com/repository/public/")
        }
        maven { url = uri("https://maven.aliyun.com/repository/central") }
        maven {
            url = uri("https://maven.aliyun.com/repository/spring/")
        }
        maven {
            url = uri("https://maven.aliyun.com/repository/spring-plugin/")
        }
        maven {
            url = uri("https://maven.aliyun.com/repository/gradle-plugin/")
        }
        mavenCentral()
        google()
        gradlePluginPortal()
    }
    afterEvaluate {
        if (project.getPropertyByBoolean(ProjectFlags.IS_ROOT_MODULE)) {
            /**
             * 由于 Kotlin 插件引入时会自动添加依赖，但根项目不需要 Kotlin 依赖，因此需要排除 Kotlin 依赖
             */
            configurations.implementation {
                exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
            }
        }
    }
}

subprojects {
    afterEvaluate {
        if (project.getPropertyByBoolean(ProjectFlags.USE_LLM_IMPL_PLATFORM_DEPENDENCE)) {
            apply {
                plugin(libs.plugins.kotlin.plugin.spring.get().pluginId)
            }
            ext {
                setProperty(ProjectFlags.USE_SPRING_BOOT_WEB, true)
                setProperty(ProjectFlags.USE_SPRING_CLOUD_BOM, true)
                setProperty(ProjectFlags.USE_LLM_KT_IMPL_DEPENDENCE, true)
            }
            dependencies {
                // Nacos 服务发现和配置
                implementation(libs.springCloudStarter.alibaba.nacos.discovery)
                // 核心spi依赖
                implementation(project(Modules.Core.SPI))
                // okHttp依赖
                implementation(libs.okHttp)
                // forgeBoot依赖
                implementation(libs.forgeBoot.core.extension)
                implementation(libs.forgeBoot.core.extension)
            }
        }
        // springCloudBom
        if (project.getPropertyByBoolean(ProjectFlags.USE_SPRING_CLOUD_BOM)) {
            dependencies {
                implementation(platform(libs.springCloudDependencies.bom))
            }
        }
        // springBootBom
        if (project.getPropertyByBoolean(ProjectFlags.USE_SPRING_BOOT_BOM)) {
            dependencies {
                implementation(platform(libs.springBootDependencies.bom))
            }
        }
        // springbootWeb
        if (project.getPropertyByBoolean(ProjectFlags.USE_SPRING_BOOT_WEB)) {
            apply {
                plugin(libs.plugins.spring.boot.get().pluginId)
            }
            dependencies {
                implementation(libs.springBootStarter.web)
                implementation(platform(libs.springBootDependencies.bom))
                testImplementation(libs.springBootStarter.test)
                testRuntimeOnly(libs.junitPlatform.launcher)
            }
        }
        // 使用kt实现impl服务依赖
        if (project.getPropertyByBoolean(ProjectFlags.USE_LLM_KT_IMPL_DEPENDENCE)) {
            dependencies {
                // jackson kt模块依赖
                implementation(libs.jackson.module.kotlin)
                // kt协程依赖
                implementation(libs.kotlinx.coruntes.reactor)
            }
        }

    }
    val libs = rootProject.libs
    apply {
        plugin(libs.plugins.java.get().pluginId)
        plugin(libs.plugins.kotlin.jvm.get().pluginId)
        plugin(libs.plugins.jibLocalPlugin.get().pluginId)
    }

    kotlin {
        compilerOptions {
            freeCompilerArgs.addAll("-Xjsr305=strict")
        }
    }
    jibConfig {
        val env = System.getenv("SPRING_PROFILES_ACTIVE")
        project {
            projectName = "llmx-core-service"
            ports = listOf("9002")
            environment = mapOf("SPRING_PROFILES_ACTIVE" to env)
            imageName = "llmx-core-service"
            paths = listOf(File(rootProject.projectDir, "scripts").absolutePath)
            entrypoint = listOf(
                "/bin/sh", "-c",
                "/entrypoint.sh -d llmx-nacos:8848 -c " +
                        "'java -cp $( cat /app/jib-classpath-file ) $( cat /app/jib-main-class-file )'"
            )
        }
        project {
            projectName = "llmx-impl-bailian"
            ports = listOf("9003")
            environment = mapOf("SPRING_PROFILES_ACTIVE" to env)
            imageName = "llmx-impl-bailian"
            paths = listOf(File(rootProject.projectDir, "scripts").absolutePath)
            entrypoint = listOf(
                "/bin/sh", "-c",
                "/entrypoint.sh -d llmx-nacos:8848 -c " +
                        "'java -cp $( cat /app/jib-classpath-file ) $( cat /app/jib-main-class-file )'"
            )
        }
    }
}

tasks.test {
    useJUnitPlatform()
}
kotlin {
    jvmToolchain(21)
}
fun Project.getPropertyByBoolean(key: String): Boolean {
    return properties[key]?.toString()?.toBoolean() ?: false
}