build.gradle

import org.gradle.api.tasks.testing.logging.TestLogEvent
import java.util.regex.Pattern
import io.vproxy.pni.exec.CompilationFlag

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }
    def PNI_VERSION = '22.0.0.20'
    ext.set("PNI_VERSION", PNI_VERSION)
    dependencies {
        classpath group: 'io.vproxy', name: 'pni-exec-jdk22', version: PNI_VERSION
    }

    def buildGraalEnvVar = System.getenv("VPROXY_BUILD_GRAAL_NATIVE_IMAGE")
    if (buildGraalEnvVar != null && buildGraalEnvVar != "true" && buildGraalEnvVar != "false") {
        throw new RuntimeException("invalid env: VPROXY_BUILD_GRAAL_NATIVE_IMAGE: ${buildGraalEnvVar}")
    }
    if (buildGraalEnvVar == "true") {
        ext.set("isNativeImage", true)
    } else {
        ext.set("isNativeImage", false)
    }
    ext.set("GRAAL_SDK_MOCK_VERSION", '1.2.2')
}

plugins {
    id 'application'
    id 'idea'
    id 'org.jetbrains.kotlin.jvm' version '2.0.0'
    id 'org.jetbrains.dokka' version "1.9.20"
    id 'maven-publish'
    id 'signing'

    id 'com.github.johnrengelman.shadow' version '8.1.1'
    id 'org.openjfx.javafxplugin' version '0.1.0' apply false
}

def PNI_VERSION = project.PNI_VERSION

ext {
    versionTs = System.currentTimeMillis()
}

group 'io.vproxy'
version loadVersion()

mainClassName = 'io.vproxy.app.app.Main'

jar {
    manifest {
        attributes 'Main-Class': mainClassName
    }
    exclude 'module-info.class'
}

shadowJar {
    archiveBaseName = 'vproxy'
    archiveClassifier = ''
    archiveVersion = ''
    exclude "module-info.class"
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'org.jetbrains.kotlin.jvm'
    apply plugin: 'org.jetbrains.dokka'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    group 'io.vproxy'
    version loadVersion()

    java {
        withSourcesJar()

        sourceCompatibility = '22'
        targetCompatibility = '22'
    }

    compileKotlin {
        kotlinOptions {
            jvmTarget = '11'
            freeCompilerArgs += '-Xjvm-default=all'
            freeCompilerArgs += '-Xassertions=jvm'
        }
    }
    compileTestKotlin {
        kotlinOptions {
            jvmTarget = '11'
            freeCompilerArgs += '-Xjvm-default=all'
            freeCompilerArgs += '-Xassertions=jvm'
        }
    }
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile.class).configureEach {
        jvmTargetValidationMode = org.jetbrains.kotlin.gradle.dsl.jvm.JvmTargetValidationMode.WARNING
    }
    tasks.withType(JavaCompile) {
        options.encoding = "UTF-8"
        options.incremental = false
    }
    tasks.withType(JavaExec) {
        jvmArgs += '--enable-native-access=ALL-UNNAMED'
        jvmArgs += '--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED'

        javaLauncher.set(javaToolchains.launcherFor(java.toolchain))
    }
    tasks.withType(Test) {
        jvmArgs += '--enable-native-access=ALL-UNNAMED'
        jvmArgs += '--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED'
        jvmArgs += '--add-opens=java.base/java.lang=ALL-UNNAMED' // dubbo uses reflection on class loaders

        testLogging {
            events TestLogEvent.FAILED, TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.STARTED
            maxGranularity 100
            exceptionFormat "full"
            showCauses true
            showExceptions true
            showStackTraces true
        }
    }

    repositories {
        mavenLocal()
        mavenCentral()
    }

    task buildJavaDoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
        outputDirectory = javadoc.destinationDir
        dokkaSourceSets {
            sourceSet {
                sourceRoot(file("src/main/java"))
            }
        }
    }
    task javadocJar(type: Jar, dependsOn: buildJavaDoc) {
        archiveClassifier = 'javadoc'
        from "$buildDir/docs/javadoc"
    }

    tasks.withType(GenerateModuleMetadata) {
        enabled = false
    }

    def releaseProjects = ['dep', 'base', 'lib', 'adaptor-netty', 'adaptor-vertx', 'msquic-dummy']
    if (System.getProperty("MavenLocalInstall", "false") == "true") {
        releaseProjects.addAll(['core', 'extended', 'app', 'all'])
    }
    if (releaseProjects.contains(project.name)) {
    publishing {
        publications {
            maven(MavenPublication) {
                from components.java
                artifactId 'vproxy-' + project.name

                artifact(javadocJar)

                pom {
                    name = 'io.vproxy.' + project.name
                    description = 'vproxy component ' + project.name
                    url = 'https://vproxy.io'
                    licenses {
                        license {
                            name = 'MIT License'
                            url = 'https://github.com/wkgcass/vproxy/blob/master/LICENSE'
                        }
                    }
                    developers {
                        developer {
                            id = 'wkgcass'
                            name = 'K.G. Wang'
                            email = 'wkgcass@hotmail.com'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/wkgcass/vproxy.git'
                        developerConnection = 'scm:git:git://github.com/wkgcass/vproxy.git'
                        url = 'https://github.com/wkgcass/vproxy'
                    }
                }
                pom.withXml {
                    def pomNode = asNode()
                    pomNode.dependencies.'*'.findAll() {
                        it.groupId.text() == 'org.jetbrains.kotlin' || it.groupId.text() == 'org.jetbrains.kotlinx'
                    }.each {
                        it.parent().remove(it)
                    }
                }
            }
        }
        repositories {
            maven {
                credentials {
                    username 'wkgcass'
                    password System.getProperty("MavenPublishPassword")
                }
                def releasesRepoUrl = 'https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/'
                def snapshotsRepoUrl = 'https://s01.oss.sonatype.org/content/repositories/snapshots/'
                url = version.contains('-DEV') ? snapshotsRepoUrl : releasesRepoUrl
            }
        }
    }
    if (!System.getProperty("MavenLocalInstall", "false").equals("true")) {
    signing {
        sign publishing.publications.maven
    }
    }
    }
}

repositories {
    mavenLocal()
    mavenCentral()
}

project(':dep') {
    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }
    dependencies {
        api group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib-jdk8', version: '2.0.0'
        api group: 'org.jetbrains.kotlinx', name: 'kotlinx-coroutines-core-jvm', version: '1.8.1'
        api group: 'io.vproxy', name: 'pni-api-jdk22', version: PNI_VERSION
        api (group: 'io.vproxy', name: 'vjson', version: '1.5.5-jdk9') {
            exclude group: 'io.vproxy', module: 'kotlin-stdlib-lite'
        }
    }
}

project(':pni-template') {
    sourceSets {
        main {
            java {
                srcDirs = ['src/main/java',
                           project.rootProject.rootDir.getAbsolutePath() + '/submodules/msquic-java/template/src/main/java']
            }
        }
    }
    dependencies {
        implementation project(':dep')
    }
    compileJava {
        options.compilerArgs += '-parameters'
    }
    task pniClean(type: Exec) {
        workingDir project.rootProject.rootDir.getAbsolutePath() + '/base/src/main/'
        commandLine 'bash', '-c', 'rm -rf c-generated/* && rm -rf generated/*'
    }

    // ====================== pni related ========================
    def baseOpts = () -> {
        def workingDir = project.rootProject.rootDir.getAbsolutePath()
        return new io.vproxy.pni.exec.CompilerOptions()
            .setClasspath(List.of(workingDir + '/pni-template/build/classes/java/main'))
            .setFilters(List.of(
                Pattern.compile('io\\.vproxy\\.vfd.*'),
                Pattern.compile('io\\.vproxy\\.xdp.*'),
                Pattern.compile('io\\.vproxy\\.fubuki.*'),
                Pattern.compile('io\\.vproxy\\.msquic\\.CxPlat.*'),
                Pattern.compile('^io\\.vproxy\\.msquic\\.MsQuicMod2$'),
            ))
            .setJavaOutputBaseDirectory(workingDir + '/base/src/main/generated')
            .setCOutputDirectory(workingDir + '/base/src/main/c-generated')
            .setCompilationFlag(CompilationFlag.TYPE_NAME_PREFIX, "PNI")
            .setCompilationFlag(CompilationFlag.RELEASE_PNI_H_FILE)
            .setCompilationFlag(CompilationFlag.RELEASE_PNI_C_FILE)
            .setCompilationFlag(CompilationFlag.RELEASE_JNI_H_MOCK_FILE)
            .setCompilationFlag(CompilationFlag.ALWAYS_ALIGNED, true)
    }

    task pniGenerate() {
        dependsOn compileJava

        def opts = baseOpts()
        def gen = new io.vproxy.pni.exec.Generator(opts)

        doLast {
            gen.generate()
        }
    }
    task pniGenerateGraal() {
        dependsOn compileJava

        def workingDir = project.rootProject.rootDir.getAbsolutePath()
        def opts = baseOpts()
            .setJavaOutputBaseDirectory(workingDir + '/base/src/main/generated-graal')
            .setCOutputDirectory(workingDir + '/base/src/main/c-generated-graal')
            .setCompilationFlag(CompilationFlag.GRAAL_NATIVE_IMAGE_FEATURE, "io.vproxy.base.NativeAccessGraalFeature")
            .setCompilationFlag(CompilationFlag.GRAAL_C_ENTRYPOINT_LITERAL_UPCALL)
        def gen = new io.vproxy.pni.exec.Generator(opts)

        doLast {
            gen.generate()
        }
    }
}

project(':base') {
    def baseGenPath = 'src/main/generated'
    def msquicGenPath = project.rootProject.rootDir.getAbsolutePath() + '/submodules/msquic-java/core/src/main/generated'
    def vpxdpGenPath = project.rootProject.rootDir.getAbsolutePath() + '/submodules/vpxdp/vpxdp-java/core/src/main/generated'
    if (isNativeImage) {
        baseGenPath = 'src/main/generated-graal'
        msquicGenPath = project.rootProject.rootDir.getAbsolutePath() + '/submodules/msquic-java/core/src/main/generated-graal'
        vpxdpGenPath = project.rootProject.rootDir.getAbsolutePath() + '/submodules/vpxdp/vpxdp-java/core/src/main/generated-graal'
    }
    sourceSets {
        main {
            java {
                srcDirs = ['src/main/java', baseGenPath,
                           project.rootProject.rootDir.getAbsolutePath() + '/submodules/msquic-java/core/src/main/java',
                           msquicGenPath,
                           project.rootProject.rootDir.getAbsolutePath() + '/submodules/vpxdp/vpxdp-java/core/src/main/java',
                           vpxdpGenPath,
                ]
            }
        }
    }
    compileJava {
        options.compilerArgs += '--add-exports=java.base/jdk.internal.misc=io.vproxy.base'
    }
    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }

    dependencies {
        api project(':dep')
        compileOnly group: 'io.vproxy', name: 'graal-sdk-mock-nativeimage', version: GRAAL_SDK_MOCK_VERSION
        runtimeOnly group: 'io.vproxy', name: 'graal-sdk-mock-runtime', version: GRAAL_SDK_MOCK_VERSION
        implementation 'io.vproxy:pni-api-graal-jdk22:' + PNI_VERSION
    }
}

project(':lib') {
    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }

    dependencies {
        api project(':base')
        api project(':msquic-dummy')
    }
}

project(':adaptor-netty') {
    dependencies {
        api project(':base')
        api group: 'io.netty', name: 'netty-transport', version: '4.1.89.Final'
        testImplementation group: 'io.netty', name: 'netty-codec-http', version: '4.1.89.Final'
        testImplementation 'io.netty.incubator:netty-incubator-codec-native-quic:0.0.37.Final:osx-x86_64'
        testImplementation 'io.netty.incubator:netty-incubator-codec-native-quic:0.0.37.Final:linux-x86_64'
        testImplementation 'io.netty.incubator:netty-incubator-codec-native-quic:0.0.37.Final:windows-x86_64'
    }
}

project(':adaptor-vertx') {
    dependencies {
        api project(':adaptor-netty')
        api group: 'io.vertx', name: 'vertx-core', version: '4.4.0'
        testImplementation group: 'io.vertx', name: 'vertx-web', version: '4.4.0'
    }
}

project(':core') {
    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }

    dependencies {
        api project(':base')
        api project(':lib')
    }
}

project(':extended') {
    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }

    dependencies {
        api project(':base')
        api project(':core')
        api project(':lib')
    }
}

project(':app') {
    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }

    dependencies {
        api project(':base')
        api project(':core')
        api project(':lib')
        api project(':extended')

        implementation 'io.vproxy:pni-api-graal-jdk22:' + PNI_VERSION
        compileOnly group: 'io.vproxy', name: 'graal-sdk-mock-nativeimage', version: GRAAL_SDK_MOCK_VERSION
        runtimeOnly group: 'io.vproxy', name: 'graal-sdk-mock-runtime', version: GRAAL_SDK_MOCK_VERSION
    }
}

project(':all') {
    dependencies {
        api project(':dep')
        api project(':base')
        api project(':lib')
        api project(':core')
        api project(':extended')
        api project(':app')
        api project(':msquic-dummy')

        compileOnly group: 'io.vproxy', name: 'graal-sdk-mock-nativeimage', version: GRAAL_SDK_MOCK_VERSION
        runtimeOnly group: 'io.vproxy', name: 'graal-sdk-mock-runtime', version: GRAAL_SDK_MOCK_VERSION
    }

    task runNative(type: JavaExec) {
        standardInput = System.in
        if ("true" == System.getProperty("enableAssertions")) {
            enableAssertions = true
        }
        classpath = sourceSets.test.runtimeClasspath
        workingDir = project.rootProject.rootDir.getAbsolutePath()
        systemProperty("java.library.path",
            "./submodules/msquic/build/bin/Release" +
                File.pathSeparator +
                "./submodules/msquic-java/core/src/main/c" +
                File.pathSeparator +
                "./base/src/main/c")
        systemProperty("vfd", "posix")
        main = "io.vproxy.app.app.Main"
    }
}

project(':ui') {
    apply plugin: 'org.openjfx.javafxplugin'

    javafx {
        version = '22.0.1'
        modules = ['javafx.controls', 'javafx.swing', 'javafx.media']
    }

    compileKotlin {
        destinationDirectory = compileJava.destinationDir
    }

    dependencies {
        api project(':all')
        api(group: 'io.vproxy', name: 'vfx', version: '1.3.0') {
            exclude group: 'io.vproxy', module: 'commons'
        }
    }

    jar {
        exclude 'module-info.class'
        from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
        duplicatesStrategy 'exclude'
    }

    task runIPv4Calculator(type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = "io.vproxy.ui.calculator.CalculatorMain"
    }
}

project(':test') {
    compileTestKotlin {
        destinationDirectory = compileTestJava.destinationDir
    }

    dependencies {
        api project(':base')
        api project(':core')
        api project(':extended')
        api project(':lib')
        api project(':app')

        testImplementation group: 'junit', name: 'junit', version: '4.12'
        testImplementation group: 'io.vertx', name: 'vertx-redis-client', version: '3.7.0'
        testImplementation group: 'io.vertx', name: 'vertx-web-client', version: '3.7.0'
        testImplementation group: 'io.grpc', name: 'grpc-all', version: '1.20.0'
        testImplementation group: 'javax.annotation', name: 'javax.annotation-api', version: '1.3.2'
        testImplementation group: 'org.apache.thrift', name: 'libthrift', version: '0.11.0'
        testImplementation group: 'com.alibaba', name: 'dubbo', version: '2.6.6'
        testImplementation group: 'org.ow2.asm', name: 'asm', version: '9.2'
    }

    task runSuite(type: Test) {
        include '**/VSuite.class'
    }

    task runCI(type: Test) {
        include '**/CI.class'
    }

    task runTest {
        dependsOn clean
        dependsOn runSuite
        dependsOn runCI
    }

    task runSingleTest(type: Test) {
        outputs.upToDateWhen { return false }

        def message;
        filter {
            def c = System.getProperty("case")
            if (c == null) {
                message = "missing test case to run, specify it with -Dcase"
                return
            }
            def testCase = c
            def m = System.getProperty("method")
            if (m != null && !m.isEmpty()) {
                testCase += '.' + m
            }

            includeTestsMatching testCase
        }
        doFirst {
            if (message) {
                println(message)
                throw new Exception(message)
            }
        }
    }

    task runPanamaTest(type: Test) {
        jvmArgs += '-Djava.library.path=' +
            project.rootProject.rootDir.getAbsolutePath() + '/base/src/main/c'
        jvmArgs += '-Dvfd=posix'

        include '**/TestPanamaGeneralPosix.class'
    }

    task XDPPoc(type: JavaExec) {
        if (!org.gradle.internal.os.OperatingSystem.current().isLinux()) {
            return
        }

        if ("true" == System.getProperty("enableAssertions")) {
            enableAssertions = true
        }
        classpath = sourceSets.test.runtimeClasspath
        workingDir = project.rootProject.rootDir.getAbsolutePath()
        systemProperty("java.library.path", "/usr/lib/" + "uname -m".execute().text.trim() + "-linux-gnu:" +
            "base/src/main/c:" +
            "submodules/vpxdp:" +
            "submodules/vpxdp/submodules/xdp-tools/lib/libxdp")
        systemProperty("vfd", "posix")
        main = "io.vproxy.poc.XDPPoc"
        def ifname = System.getProperty("ifname")
        def offload = System.getProperty("offload")
        doLast {
            if (ifname == null) {
                throw new Exception("You must specify -Difname={...}")
            }
            var ls = [ifname]
            if (offload != null) {
                ls.add(offload)
            }
            args = ls
        }
    }

    task QuicPoc(type: JavaExec) {
        if ("true" == System.getProperty("enableAssertions")) {
            enableAssertions = true
        }
        classpath = sourceSets.test.runtimeClasspath
        workingDir = project.rootProject.rootDir.getAbsolutePath()
        def msquicLD = "./submodules/msquic/build/bin/Release"
        if (org.gradle.internal.os.OperatingSystem.current().isWindows()) {
            msquicLD = "./submodules/msquic/artifacts/bin/windows/x64_Release_openssl"
        }
        systemProperty("java.library.path",
            msquicLD +
            File.pathSeparator +
            "./base/src/main/c")
        if (org.gradle.internal.os.OperatingSystem.current().isWindows()) {
            systemProperty("vfd", "windows")
        } else {
            systemProperty("vfd", "posix")
        }
        def gw = System.getProperty("Gateway")
        if ("true" == gw || "1" == gw) {
            main = "io.vproxy.poc.QuicGatewayPoc"
        } else {
            main = "io.vproxy.poc.QuicPoc"
        }
    }

    task WinPoc(type: JavaExec) {
        if (!org.gradle.internal.os.OperatingSystem.current().isWindows()) {
            return
        }

        if ("true" == System.getProperty("enableAssertions")) {
            enableAssertions = true
        }
        classpath = sourceSets.test.runtimeClasspath
        workingDir = project.rootProject.rootDir.getAbsolutePath()
        systemProperty("java.library.path", "base\\src\\main\\c")

        def mainClass = System.getProperty("MainClass")
        main = "io.vproxy.poc." + mainClass
    }

    task GenerateModuleInfo(type: JavaExec) {
        classpath = sourceSets.test.runtimeClasspath
        workingDir = project.rootProject.rootDir.getAbsolutePath()
        main = "io.vproxy.buildtools.ModuleInfoGenerator"
    }
}

project(':msquic-dummy') {
    dependencies {
        api project(':base')
    }
}

dependencies {
    api project(':all')
    testImplementation project(':test')
}

def loadVersion() {
    def PREFIX = "public static final String VERSION = \""
    def SUFFIX = "\"; // _THE_VERSION_"
    def ver = file(projectDir.getAbsolutePath() + "/base/src/main/java/io/vproxy/base/util/Version.java")
    def lines = ver.getText().split("\n")
    def isMavenLocalInstall = System.getProperty("MavenLocalInstall", "false").equals("true")
    for (def line : lines) {
        line = line.trim()
        if (line.startsWith(PREFIX) && line.endsWith(SUFFIX)) {
            def verstr = line.substring(PREFIX.length(), line.length() - SUFFIX.length())
            if (verstr.endsWith('-DEV')) {
                if (isMavenLocalInstall) {
                    return "MAVEN-LOCAL"
                } else {
                    verstr = verstr + '-' + versionTs + '-SNAPSHOT'
                }
            }
            return verstr
        }
    }
    return "unknown"
}