libmongocrypt-helper 1.12.0.0.1001 → 1.13.2.0.1001

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/README.md

@@ -1,36 +0,0 @@
-# mongocrypt Java Wrapper #
-The Java wrapper for the companion C library for client side encryption in drivers.
-
-### Testing ###
-`./gradlew check` runs the java test suite. By default it expects that libmongocrypt is in `./build/jnaLibs/<ARCH>/` - where <ARCH> is the current platform architecture: eg: `linux-x86-64`.
-
-To test against a local build:
-`/gradlew check -DjnaLibsPath=../../../../libmongocrypt/cmake-build`
-
-Note: libmongocrypt and the java library are continuously built on evergreen. Submit patch builds to this evergreen project when making changes to test on supported platforms.
-
-### Publishing ####
-
-First check the build artifacts locally (~/.m2/repository/org/mongodb/mongocrypt): `./gradlew clean downloadJnaLibs publishToMavenLocal`
-
-**Sonatype**
-
-`./gradlew publishToSonatype`
-Will push the latest snapshot or release version to sonatype repository.
-
-### Custom gradle flags ###
-
-* `jnaLibsPath`: Custom local JNA library path for inclusion into the build (rather than downloading from s3)<br>
-  Usage: `./gradlew publishToSonatype -DjnaLibsPath=../../../cmake-build-nocrypto`
-* `gitRevision`: Sets the Git Revision to download the built resources for from s3.<br>
-  Usage: `./gradlew publishToSonatype -DgitRevision=<fullGitHash>`
-
-These flags can be combined with the `downloadJnaLibs` task:
- 
-* Test without compiling libmongocrypt locally:<br> `./gradlew clean downloadJnaLibs test -DgitRevision=<fullGitHash>`
-* Test using a custom libmongocrypt path:<br> `./gradlew clean test -DjnaLibsPath=<path>`
-
-
-### Debugging errors ###
-
-* Use the info and jna debug flags to output debugging information when running tasks:<br> `./gradlew <taskName> --info -Djna.debug_load=true`

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/benchmarks/build.gradle.kts

@@ -1,28 +0,0 @@
-/*
- * Copyright 2023-present MongoDB, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-plugins {
-    id("application")
-}
-
-application {
-    mainClass.set("com.mongodb.crypt.benchmark.BenchmarkRunner")
-}
-
-dependencies {
-    implementation(project(":")) // Reference to the parent project
-}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/benchmarks/src/main/java/com/mongodb/crypt/benchmark/BenchmarkRunner.java

@@ -1,217 +0,0 @@
-/*
- * Copyright 2023-present MongoDB, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package com.mongodb.crypt.benchmark;
-
-import com.mongodb.crypt.capi.*;
-import org.bson.*;
-
-import java.io.*;
-import java.net.URL;
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.time.ZoneOffset;
-import java.time.ZonedDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.*;
-import java.util.concurrent.*;
-
-public class BenchmarkRunner {
-    static final int NUM_FIELDS = 1500;
-    static final int NUM_WARMUP_SECS = 2;
-    static final int NUM_SECS = 10;
-    static final byte[] LOCAL_MASTER_KEY = new byte[]{
-            -99, -108, 75, 13, -109, -48, -59, 68, -91, 114, -3, 50, 27, -108, 48, -112, 35, 53,
-            115, 124, -16, -10, -62, -12, -38, 35, 86, -25, -113, 4, -52, -6, -34, 117, -76, 81,
-            -121, -13, -117, -105, -41, 75, 68, 59, -84, 57, -94, -58, 77, -111, 0, 62, -47, -6, 74,
-            48, -63, -46, -58, 94, -5, -84, 65, -14, 72, 19, 60, -101, 80, -4, -89, 36, 122, 46, 2,
-            99, -93, -58, 22, 37, 81, 80, 120, 62, 15, -40, 110, -124, -90, -20, -115, 45, 36, 71,
-            -27, -81
-    };
-
-    private static String getFileAsString(final String fileName) {
-        try {
-            URL resource = BenchmarkRunner.class.getResource("/" + fileName);
-            if (resource == null) {
-                throw new RuntimeException("Could not find file " + fileName);
-            }
-            return new String(Files.readAllBytes(Paths.get(resource.toURI())));
-        } catch (Throwable t) {
-            throw new RuntimeException("Could not parse file " + fileName, t);
-        }
-    }
-
-    private static BsonDocument getResourceAsDocument(final String fileName) {
-        return BsonDocument.parse(getFileAsString(fileName));
-    }
-
-    private static MongoCrypt createMongoCrypt() {
-        return MongoCrypts.create(MongoCryptOptions
-                .builder()
-                .localKmsProviderOptions(MongoLocalKmsProviderOptions.builder()
-                        .localMasterKey(ByteBuffer.wrap(LOCAL_MASTER_KEY))
-                        .build())
-                .build());
-    }
-
-    // DecryptTask decrypts a document repeatedly for a specified number of seconds and records ops/sec.
-    private static class DecryptTask implements Runnable {
-        public DecryptTask (MongoCrypt mongoCrypt, BsonDocument toDecrypt, int numSecs, CountDownLatch doneSignal) {
-            this.mongoCrypt = mongoCrypt;
-            this.toDecrypt = toDecrypt;
-            this.opsPerSecs = new ArrayList<Long>(numSecs);
-            this.numSecs = numSecs;
-            this.doneSignal = doneSignal;
-        }
-        public void run() {
-            for (int i = 0; i < numSecs; i++) {
-                long opsPerSec = 0;
-                long start = System.nanoTime();
-                // Run for one second.
-                while (System.nanoTime() - start < 1_000_000_000) {
-                    try (MongoCryptContext ctx = mongoCrypt.createDecryptionContext(toDecrypt)) {
-                        assert ctx.getState() == MongoCryptContext.State.READY;
-                        ctx.finish();
-                        opsPerSec++;
-                    }
-                }
-                opsPerSecs.add(opsPerSec);
-            }
-            doneSignal.countDown();
-        }
-        public long getMedianOpsPerSecs () {
-            if (opsPerSecs.size() == 0) {
-                throw new IllegalStateException("opsPerSecs is empty. Was `run` called?");
-            }
-            Collections.sort(opsPerSecs);
-            return opsPerSecs.get(numSecs / 2);
-        }
-        private MongoCrypt mongoCrypt;
-        private BsonDocument toDecrypt;
-        private ArrayList<Long> opsPerSecs;
-        private int numSecs;
-        private CountDownLatch doneSignal;
-    }
-    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
-        System.out.printf("BenchmarkRunner is using libmongocrypt version=%s, NUM_WARMUP_SECS=%d, NUM_SECS=%d%n", CAPI.mongocrypt_version(null).toString(), NUM_WARMUP_SECS, NUM_SECS);
-        // `keyDocument` is a Data Encryption Key (DEK) encrypted with the Key Encryption Key (KEK) `LOCAL_MASTER_KEY`.
-        BsonDocument keyDocument = getResourceAsDocument("keyDocument.json");
-        try (MongoCrypt mongoCrypt = createMongoCrypt()) {
-            // `encrypted` will contain encrypted fields.
-            BsonDocument encrypted = new BsonDocument();
-            {
-                for (int i = 0; i < NUM_FIELDS; i++) {
-                    MongoExplicitEncryptOptions options = MongoExplicitEncryptOptions.builder()
-                            .keyId(new BsonBinary(BsonBinarySubType.UUID_STANDARD, Base64.getDecoder().decode("YWFhYWFhYWFhYWFhYWFhYQ==")))
-                            .algorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")
-                            .build();
-                    BsonDocument toEncrypt = new BsonDocument("v", new BsonString(String.format("value %04d", i)));
-                    try (MongoCryptContext ctx = mongoCrypt.createExplicitEncryptionContext(toEncrypt, options)) {
-                        // If mongocrypt_t has not yet cached the DEK, supply it.
-                        if (MongoCryptContext.State.NEED_MONGO_KEYS == ctx.getState()) {
-                            ctx.addMongoOperationResult(keyDocument);
-                            ctx.completeMongoOperation();
-                        }
-                        assert ctx.getState() == MongoCryptContext.State.READY;
-                        RawBsonDocument result = ctx.finish();
-                        BsonValue encryptedValue = result.get("v");
-                        String key = String.format("key%04d", i);
-                        encrypted.append(key, encryptedValue);
-                    }
-                }
-            }
-
-            // Warm up benchmark and discard the result.
-            DecryptTask warmup = new DecryptTask(mongoCrypt, encrypted, NUM_WARMUP_SECS, new CountDownLatch(1));
-            warmup.run();
-
-            // Decrypt `encrypted` and measure ops/sec.
-            // Check with varying thread counts to measure impact of a shared pool of Cipher instances.
-            int[] threadCounts = {1,2,8,64};
-            ArrayList<Long> totalMedianOpsPerSecs = new ArrayList<Long>(threadCounts.length);
-            ArrayList<String> createdAts = new ArrayList<String>(threadCounts.length);
-            ArrayList<String> completedAts = new ArrayList<String>(threadCounts.length);
-
-            for (int threadCount : threadCounts) {
-                ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
-                CountDownLatch doneSignal = new CountDownLatch(threadCount);
-                ArrayList<DecryptTask> decryptTasks = new ArrayList<DecryptTask>(threadCount);
-                createdAts.add(ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT));
-
-                for (int i = 0; i < threadCount; i++) {
-                    DecryptTask decryptTask = new DecryptTask(mongoCrypt, encrypted, NUM_SECS, doneSignal);
-                    decryptTasks.add(decryptTask);
-                    executorService.submit(decryptTask);
-                }
-
-                // Await completion of all tasks. Tasks are expected to complete shortly after NUM_SECS. Time out `await` if time exceeds 2 * NUM_SECS.
-                boolean ok = doneSignal.await(NUM_SECS * 2, TimeUnit.SECONDS);
-                assert ok;
-                completedAts.add(ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT));
-                // Sum the median ops/secs of all tasks to get total throughput.
-                long totalMedianOpsPerSec = 0;
-                for (DecryptTask decryptTask : decryptTasks) {
-                    totalMedianOpsPerSec += decryptTask.getMedianOpsPerSecs();
-                }
-                System.out.printf("threadCount=%d. Decrypting 1500 fields median ops/sec : %d%n", threadCount, totalMedianOpsPerSec);
-                totalMedianOpsPerSecs.add(totalMedianOpsPerSec);
-                executorService.shutdown();
-                ok = executorService.awaitTermination(NUM_SECS * 2, TimeUnit.SECONDS);
-                assert ok;
-            }
-
-            // Print the results in JSON that can be accepted by the `perf.send` command.
-            // See https://docs.devprod.prod.corp.mongodb.com/evergreen/Project-Configuration/Project-Commands#perfsend for the expected `perf.send` input.
-            ArrayList<BsonDocument> resultsArray = new ArrayList<BsonDocument>(threadCounts.length);
-            for (int i = 0; i < threadCounts.length; i++) {
-                int threadCount = threadCounts[i];
-                long totalMedianOpsPerSec = totalMedianOpsPerSecs.get(i);
-                String createdAt = createdAts.get(i);
-                String completedAt = completedAts.get(i);
-
-                resultsArray.add(new BsonDocument()
-                    .append("info", new BsonDocument()
-                            .append("test_name", new BsonString("java_decrypt_1500"))
-                            .append("args", new BsonDocument()
-                                .append("threadCount", new BsonInt32(threadCount))))
-                    .append("created_at", new BsonString(createdAt))
-                    .append("completed_at", new BsonString(completedAt))
-                    .append("artifacts", new BsonArray())
-                    .append("metrics", new BsonArray(Arrays.asList(
-                            new BsonDocument()
-                                    .append("name", new BsonString("medianOpsPerSec"))
-                                    .append("type", new BsonString("THROUGHPUT"))
-                                    .append("value", new BsonInt64(totalMedianOpsPerSec))
-                    )))
-                    .append("sub_tests", new BsonArray()));
-            }
-
-            BsonDocument results = new BsonDocument().append("results", new BsonArray(resultsArray));
-            String resultsString = results.toJson();
-            // Remove the prefix and suffix when writing to a file so only the [ ... ] array is included.
-            resultsString = resultsString.substring("{\"results\": ".length(), resultsString.length() - 1);
-
-            String resultsFilePath = "results.json";
-            try (OutputStreamWriter fileWriter = new OutputStreamWriter(new FileOutputStream(resultsFilePath), StandardCharsets.UTF_8)) {
-                fileWriter.write(resultsString);
-            }
-            System.out.println("Results written to file: " + resultsFilePath);
-        }
-    }
-}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/benchmarks/src/main/resources/keyDocument.json

@@ -1,24 +0,0 @@
-{
-  "_id": {
-    "$binary": {
-      "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
-      "subType": "04"
-    }
-  },
-  "keyMaterial": {
-    "$binary": {
-      "base64": "ACR7Hm33dDOAAD7l2ubZhSpSUWK8BkALUY+qW3UgBAEcTV8sBwZnaAWnzDsmrX55dgmYHWfynDlJogC/e33u6pbhyXvFTs5ow9OLCuCWBJ39T/Ivm3kMaZJybkejY0V+uc4UEdHvVVz/SbitVnzs2WXdMGmo1/HmDRrxGYZjewFslquv8wtUHF5pyB+QDlQBd/al9M444/8bJZFbMSmtIg==",
-      "subType": "00"
-    }
-  },
-  "creationDate": {
-    "$date": "2023-08-21T14:28:20.875Z"
-  },
-  "updateDate": {
-    "$date": "2023-08-21T14:28:20.875Z"
-  },
-  "status": 0,
-  "masterKey": {
-    "provider": "local"
-  }
-}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/build.gradle.kts

@@ -1,354 +0,0 @@
-/*
- * Copyright 2019-present MongoDB, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-import de.undercouch.gradle.tasks.download.Download
-import java.io.ByteArrayOutputStream
-import java.net.URI
-
-buildscript {
-    repositories {
-        mavenCentral()
-        google()
-    }
-    dependencies {
-        "classpath"(group = "net.java.dev.jna", name = "jna", version = "5.11.0")
-    }
-}
-
-plugins {
-    `java-library`
-    `maven-publish`
-    signing
-    id("de.undercouch.download") version "5.0.5"
-    id("biz.aQute.bnd.builder") version "6.2.0"
-}
-
-allprojects {
-    repositories {
-        mavenCentral()
-        google()
-    }
-}
-
-group = "org.mongodb"
-version = "1.12.0-SNAPSHOT"
-description = "MongoDB client-side crypto support"
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-
-    registerFeature("loggingSupport") {
-        usingSourceSet(sourceSets["main"])
-    }
-}
-
-
-val bsonRangeVersion = "[3.10,5.0)"
-dependencies {
-    api("org.mongodb:bson:$bsonRangeVersion")
-    api("net.java.dev.jna:jna:5.11.0")
-    "loggingSupportImplementation"("org.slf4j:slf4j-api:1.7.36")
-
-    // Tests
-    testImplementation(platform("org.junit:junit-bom:5.8.2"))
-    testImplementation("org.junit.jupiter:junit-jupiter")
-    testRuntimeOnly("ch.qos.logback:logback-classic:1.2.11")
-}
-
-/*
- * Git version information
- */
-
-// Returns a String representing the output of `git describe`
-val gitDescribe by lazy {
-    val describeStdOut = ByteArrayOutputStream()
-    exec {
-        commandLine = listOf("git", "describe", "--tags", "--always", "--dirty")
-        standardOutput = describeStdOut
-    }
-    describeStdOut.toString().trim()
-}
-
-val isJavaTag by lazy { gitDescribe.startsWith("java") }
-val gitVersion by lazy { gitDescribe.subSequence(gitDescribe.toCharArray().indexOfFirst { it.isDigit() }, gitDescribe.length).toString() }
-
-val defaultDownloadRevision: String by lazy {
-    val gitCommandLine = if (gitVersion == version) {
-        listOf("git", "rev-list", "-n", "1", gitVersion)
-    } else {
-        listOf("git", "rev-parse", "HEAD")
-    }
-    val describeStdOut = ByteArrayOutputStream()
-    exec {
-        commandLine = gitCommandLine
-        standardOutput = describeStdOut
-    }
-    describeStdOut.toString().trim()
-}
-
-/*
- * Jna copy or download resources
- */
-val jnaDownloadsDir = "$buildDir/jnaLibs/downloads/"
-val jnaResourcesDir = "$buildDir/jnaLibs/resources/"
-val jnaLibPlatform: String = if (com.sun.jna.Platform.RESOURCE_PREFIX.startsWith("darwin")) "darwin" else com.sun.jna.Platform.RESOURCE_PREFIX
-val jnaLibsPath: String = System.getProperty("jnaLibsPath", "${jnaResourcesDir}${jnaLibPlatform}")
-val jnaResources: String = System.getProperty("jna.library.path", jnaLibsPath)
-
-// Download jnaLibs that match the git to jnaResourcesBuildDir
-val downloadRevision: String = System.getProperties().computeIfAbsent("gitRevision") { k -> defaultDownloadRevision }.toString()
-val downloadUrl: String = "https://mciuploads.s3.amazonaws.com/libmongocrypt/java/$downloadRevision/libmongocrypt-java.tar.gz"
-
-val jnaMapping: Map<String, String> = mapOf(
-    "rhel-62-64-bit" to "linux-x86-64",
-    "rhel72-zseries-test" to "linux-s390x",
-    "rhel-71-ppc64el" to "linux-ppc64le",
-    "ubuntu1604-arm64" to "linux-aarch64",
-    "windows-test" to "win32-x86-64",
-    "macos" to "darwin"
-)
-
-tasks.register<Download>("downloadJava") {
-    src(downloadUrl)
-    dest("${jnaDownloadsDir}/libmongocrypt-java.tar.gz")
-    overwrite(true)
-}
-
-// The `processResources` task (defined by the `java-library` plug-in) consumes files in the main source set.
-// Add a dependency on `unzipJava`. `unzipJava` adds libmongocrypt libraries to the main source set.
-tasks.processResources {
-    mustRunAfter(tasks.named("unzipJava"))
-}
-
-tasks.register<Copy>("unzipJava") {
-    outputs.upToDateWhen { false }
-    from(tarTree(resources.gzip("${jnaDownloadsDir}/libmongocrypt-java.tar.gz")))
-    include(jnaMapping.keys.flatMap {
-        listOf("${it}/nocrypto/**/libmongocrypt.so", "${it}/lib/**/libmongocrypt.dylib", "${it}/bin/**/mongocrypt.dll" )
-    })
-    eachFile {
-        path = "${jnaMapping[path.substringBefore("/")]}/${name}"
-    }
-    into(jnaResourcesDir)
-    mustRunAfter("downloadJava")
-
-    doLast {
-        println("jna.library.path contents: \n  ${fileTree(jnaResourcesDir).files.joinToString(",\n  ")}")
-    }
-}
-
-tasks.register("downloadJnaLibs") {
-    dependsOn("downloadJava", "unzipJava")
-}
-
-tasks.test {
-    systemProperty("jna.debug_load", "true")
-    systemProperty("jna.library.path", jnaResources)
-    useJUnitPlatform()
-    testLogging {
-        events("passed", "skipped", "failed")
-    }
-
-    doFirst {
-        println("jna.library.path contents:")
-        println(fileTree(jnaResources)  {
-            this.setIncludes(listOf("*.*"))
-        }.files.joinToString(",\n  ", "  "))
-    }
-    mustRunAfter("downloadJnaLibs", "downloadJava", "unzipJava")
-}
-
-tasks.withType<AbstractPublishToMaven> {
-    description = """$description
-        | System properties:
-        | =================
-        |
-        | jnaLibsPath    : Custom local JNA library path for inclusion into the build (rather than downloading from s3)
-        | gitRevision    : Optional Git Revision to download the built resources for from s3.
-    """.trimMargin()
-}
-
-tasks.withType<PublishToMavenRepository> {
-    sourceSets["main"].resources.srcDirs("resources", jnaResourcesDir)
-}
-
-/*
- * Publishing
- */
-tasks.register<Jar>("sourcesJar") {
-    description = "Create the sources jar"
-    from(sourceSets.main.get().allJava)
-    archiveClassifier.set("sources")
-}
-
-tasks.register<Jar>("javadocJar") {
-    description = "Create the Javadoc jar"
-    from(tasks.javadoc)
-    archiveClassifier.set("javadoc")
-}
-
-tasks.jar {
-    manifest {
-        attributes(
-                "-exportcontents" to "com.mongodb.crypt.capi.*;-noimport:=true",
-                "Automatic-Module-Name" to "com.mongodb.crypt.capi",
-                "Import-Package" to """org.bson.*;version="$bsonRangeVersion"""",
-                "Build-Version" to gitVersion,
-                "Bundle-Version" to gitVersion,
-                "Bundle-Name" to "MongoCrypt",
-                "Bundle-SymbolicName" to "com.mongodb.crypt.capi",
-                "Private-Package" to ""
-        )
-    }
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("mavenJava") {
-            artifactId = "mongodb-crypt"
-            from(components["java"])
-            suppressPomMetadataWarningsFor("loggingSupportApiElements")
-            suppressPomMetadataWarningsFor("loggingSupportRuntimeElements")
-
-            artifact(tasks["sourcesJar"])
-            artifact(tasks["javadocJar"])
-
-            pom {
-                name.set("MongoCrypt")
-                description.set(project.description)
-                url.set("http://www.mongodb.org")
-                licenses {
-                    license {
-                        name.set("The Apache License, Version 2.0")
-                        url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                    }
-                }
-                developers {
-                    developer {
-                        id.set("Various")
-                        organization.set("MongoDB")
-                    }
-                }
-                scm {
-                    url.set("https://github.com/mongodb/libmongocrypt")
-                    connection.set("scm:https://github.com/mongodb/libmongocrypt")
-                    developerConnection.set("scm:git@github.com:mongodb/libmongocrypt")
-                }
-            }
-        }
-    }
-
-    repositories {
-        maven {
-            val snapshotsRepoUrl = URI("https://oss.sonatype.org/content/repositories/snapshots/")
-            val releasesRepoUrl = URI("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-            url = if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl
-            credentials {
-                val nexusUsername: String? by project
-                val nexusPassword: String? by project
-                username = nexusUsername ?: ""
-                password = nexusPassword ?: ""
-            }
-        }
-    }
-}
-
-signing {
-    sign(publishing.publications["mavenJava"])
-}
-
-tasks.javadoc {
-    if (JavaVersion.current().isJava9Compatible) {
-        (options as StandardJavadocDocletOptions).addBooleanOption("html5", true)
-    }
-}
-
-tasks.register("publishToSonatype") {
-    group = "publishing"
-    description = """Publishes to Sonatype.
-        |
-        | - If the version string ends with SNAPSHOT then publishes to the Snapshots repo.
-        |   Note: Uses the JNA libs from the current build.
-        |
-        | - If is a release then publishes the release to maven central staging.
-        |   A release is when the current git tag is prefixed with java (eg: java-1.7.0)
-        |   AND the git tag version matches the version the build.gradle.kts.
-        |   Note: Uses the JNA libs from the associated tag.
-        |   Eg: Tag java-1.7.0 will use the JNA libs created by the 1.7.0 release tag.
-        |
-        | To override the JNA library downloaded use -DgitRevision=<git hash>
-    """.trimMargin()
-    val isSnapshot = version.toString().endsWith("-SNAPSHOT")
-    val isRelease = isSnapshot || (isJavaTag && gitVersion == version)
-
-    doFirst {
-        if (isSnapshot && isJavaTag) {
-                throw GradleException("""
-                | Invalid Release
-                | ===============
-                |
-                | Version: $version 
-                | GitVersion: $gitVersion
-                | isJavaTag: $isJavaTag
-                |
-                |""".trimMargin())
-        }
-
-        if (isRelease) {
-            println("Publishing: ${project.name} : $gitVersion")
-        } else {
-            println("""
-                | Not a Java release:
-                |
-                | Version:
-                | ========
-                |
-                | $gitDescribe
-                |
-                | The project version does not match the git tag.
-                |""".trimMargin())
-        }
-    }
-
-    if (isRelease) {
-        dependsOn("downloadJnaLibs")
-        finalizedBy(tasks.withType<PublishToMavenRepository>())
-        tasks.withType<PublishToMavenRepository>().forEach { t -> t.mustRunAfter("downloadJnaLibs", "downloadJava", "unzipJava") }
-    }
-}
-
-
-/*
-For security we allow the signing-related project properties to be passed in as environment variables, which
-Gradle enables if they are prefixed with "ORG_GRADLE_PROJECT_".  But since environment variables can not contain
-the '.' character and the signing-related properties contain '.', here we map signing-related project properties with '_'
-to ones with '.' that are expected by the signing plugin.
-*/
-gradle.taskGraph.whenReady {
-    if (allTasks.any { it is Sign }) {
-        val signing_keyId: String? by project
-        val signing_secretKeyRingFile: String? by project
-        val signing_password: String? by project
-
-        allprojects {
-            signing_keyId?.let { extra["signing.keyId"] = it }
-            signing_secretKeyRingFile?.let { extra["signing.secretKeyRingFile"] = it }
-            signing_password?.let { extra["signing.password"] = it }
-        }
-    }
-}

data/ext/libmongocrypt/libmongocrypt/bindings/java/mongocrypt/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists