build.gradle

buildscript {
    dependencies {
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.9.4'
        classpath 'de.undercouch:gradle-download-task:5.5.0'
    }
}

plugins {
    id 'java'
    id 'com.google.protobuf' version '0.9.4'
    id 'idea'
    id 'maven-publish'
}

def ENV = System.getenv()

repositories {
    mavenCentral()
}

tasks.withType(JavaCompile) {
    options.compilerArgs += ['-Xlint:deprecation', '-Xlint:unchecked']
}

group = 'io.trogonstack'
version = '0.0.1' // x-release-please-version

java {
    withSourcesJar()
    withJavadocJar()
}

artifacts {
    archives javadocJar
    archives sourcesJar
}

configurations {
    exposedRuntime {
        canBeResolved = false
        canBeConsumed = true
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation "org.reactivestreams:reactive-streams:${reactiveStreamsApiVersion}"

    implementation "javax.annotation:javax.annotation-api:${annotationApiVersion}"
    implementation "javax.validation:validation-api:${validationApiVersion}"

    implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
    implementation "com.google.protobuf:protobuf-java-util:${protobufVersion}"
    implementation 'com.google.errorprone:error_prone_annotations:2.23.0'
    implementation "io.grpc:grpc-netty-shaded:${grpcVersion}"
    implementation "io.grpc:grpc-stub:${grpcVersion}"
    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
    implementation "com.google.api.grpc:grpc-google-common-protos:2.61.3"
    implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
    implementation "org.slf4j:slf4j-api:2.0.17"
    implementation "org.bouncycastle:bcprov-jdk18on:1.80"
    implementation "org.bouncycastle:bcpkix-jdk18on:1.80"

    implementation platform("io.opentelemetry:opentelemetry-bom:${openTelemetryVersion}")
    implementation "io.opentelemetry:opentelemetry-api"
    implementation "io.opentelemetry.semconv:opentelemetry-semconv:${openTelemetrySemConvVersion}"
    implementation "io.opentelemetry.semconv:opentelemetry-semconv-incubating:${openTelemetrySemConvVersion}"

    testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
    testImplementation "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
    testImplementation "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
    testImplementation "org.junit.platform:junit-platform-suite:1.10.0"
    testImplementation 'org.junit-pioneer:junit-pioneer:1.9.1'
    testImplementation 'io.reactivex.rxjava3:rxjava:3.1.8'
    testImplementation "org.reactivestreams:reactive-streams-tck:${reactiveStreamsApiVersion}"
    testImplementation "org.testcontainers:testcontainers:${testcontainersVersion}"
    testImplementation platform("com.fasterxml.jackson:jackson-bom:${jacksonVersion}")
    testImplementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
    testImplementation "com.github.javafaker:javafaker:1.0.2"
    testImplementation 'org.slf4j:slf4j-simple:2.0.17'
    testImplementation "io.opentelemetry:opentelemetry-sdk"
    testImplementation "io.opentelemetry:opentelemetry-sdk-testing"
    testImplementation "io.opentelemetry:opentelemetry-exporter-logging"
    testImplementation "io.opentelemetry:opentelemetry-exporter-otlp"
}

tasks.withType(Test).configureEach {
    testLogging {
        events "PASSED", "SKIPPED", "FAILED"
        showExceptions true
        exceptionFormat "full"
        showCauses true
        showStackTraces true
        showStandardStreams = true
    }
}

tasks.register("generateCertificates", Exec) {
    description = "Generates SSL certificates to start a secured TrogonEventStore server"
    commandLine 'docker', 'compose', '--file', './configure-tls-for-tests.yml', 'up'
}

tasks.register("generateUserCertificates", Exec) {
    description = "Generates X.509 certificates for Plugins tests"
    commandLine 'docker', 'compose', '--file', './configure-user-certs-for-tests.yml', 'up'
}

tasks.register("startDockerCompose", Exec) {
    description = "Starts the TrogonEventStore cluster"
    commandLine 'docker', 'compose', '--file', './docker-compose.yml', 'up', '-d'
}

tasks.register("stopDockerCompose", Exec) {
    description = "Stops the TrogonEventStore cluster"
    commandLine 'docker', 'compose', '--file', './docker-compose.yml', 'down'
}


tasks.register("miscTests", Test) {
    useJUnitPlatform {
        include("**/MiscTests.class")
    }
}

tasks.register("singleNodeTests", Test) {
    useJUnitPlatform {
        include("**/StreamsTests.class")
        include("**/PersistentSubscriptionsTests.class")
        include("**/TelemetryTests.class")
        include("**/ConnectionShutdownTests.class")
    }
}

tasks.register("secureNodeTests", Test) {
    dependsOn generateCertificates
    environment "SECURE", "true"

    useJUnitPlatform {
        include("**/StreamsTests.class")
        include("**/PersistentSubscriptionsTests.class")
    }
}

tasks.register("clusterTests", Test) {
    dependsOn startDockerCompose
    finalizedBy stopDockerCompose
    environment "SECURE", "true"
    environment "CLUSTER", "true"

    useJUnitPlatform {
        include("**/StreamsTests.class")
        include("**/PersistentSubscriptionsTests.class")
        include("**/ConnectionShutdownTests.class")
    }
}

tasks.register("pluginsTests", Test) {
    dependsOn generateCertificates
    dependsOn generateUserCertificates

    environment "SECURE", "true"

    useJUnitPlatform {
        include("**/PluginsTests.class")
    }
}

tasks.register("ci", Test) {
    useJUnitPlatform()
}

test {
    dependsOn miscTests, singleNodeTests, secureNodeTests, clusterTests
}

protobuf {
    protoc {
        // The artifact spec for the Protobuf Compiler
        artifact = "com.google.protobuf:protoc:${protocVersion}"
    }
    plugins {
        // Optional: an artifact spec for a protoc plugin, with "grpc" as
        // the identifier, which can be referred to in the "plugins"
        // container of the "generateProtoTasks" closure.
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
        }
    }
    generateProtoTasks {
        ofSourceSet('main')*.plugins {
            // Apply the "grpc" plugin whose spec is defined above, without
            // options.  Note the braces cannot be omitted, otherwise the
            // plugin will not be added. This is because of the implicit way
            // NamedDomainObjectContainer binds the methods.
            grpc {}
        }
    }
}

javadoc {
    options.addStringOption('Xdoclint:none', '-quiet')
    failOnError = false
}

publishing {
    publications {
        maven(MavenPublication) {
            groupId = 'io.trogonstack'
            artifactId = 'trogon-eventstore-client'

            from components.java
            pom {
                name = 'TrogonEventStore Java Client'
                description = 'Java client for TrogonEventStore'
                url = 'https://github.com/TrogonStack/TrogonEventStore-Client-Java'

                scm {
                    connection = 'scm:git:https://github.com/TrogonStack/TrogonEventStore-Client-Java.git'
                    developerConnection = 'scm:git:ssh://git@github.com/TrogonStack/TrogonEventStore-Client-Java.git'
                    url = 'https://github.com/TrogonStack/TrogonEventStore-Client-Java'
                }
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        id = 'straw-hat-team'
                        name = 'Straw Hat, LLC'
                    }
                }
            }
        }
    }
    repositories {
        maven {
            name = 'GitHubPackages'
            url = uri('https://maven.pkg.github.com/TrogonStack/TrogonEventStore-Client-Java')
            credentials {
                username = ENV.GITHUB_ACTOR
                password = ENV.GITHUB_TOKEN
            }
        }
    }
}


sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

if (!JavaVersion.current().isJava8Compatible()) {
    throw new Exception("Java 8 or newer is required to build TrogonEventStore-Client-Java")
}