Merge branch 'main' into JAVA-4586_bulk-write

Author: stIncMale

.evergreen/.evg.yml

@@ -144,8 +144,8 @@ functions:
 
   "create and upload SSDLC release assets":
     - command: shell.exec
-      shell: "bash"
       params:
+        shell: "bash"
         working_dir: "src"
         env:
           PRODUCT_NAME: ${product_name}
@@ -287,7 +287,7 @@ functions:
 
           AUTH="${AUTH}" SSL="${SSL}" MONGODB_URI="${MONGODB_URI}" SAFE_FOR_MULTI_MONGOS="${SAFE_FOR_MULTI_MONGOS}" TOPOLOGY="${TOPOLOGY}" \
           COMPRESSOR="${COMPRESSOR}" JAVA_VERSION="${JAVA_VERSION}" REQUIRE_API_VERSION=${REQUIRE_API_VERSION} \
-          .evergreen/run-tests.sh
+          TESTS="${TESTS}" .evergreen/run-tests.sh
 
   "run load-balancer tests":
     - command: shell.exec
@@ -335,7 +335,7 @@ functions:
         AUTH="${AUTH}" SSL="${SSL}" MONGODB_URI="${MONGODB_URI}" TOPOLOGY="${TOPOLOGY}" COMPRESSOR="${COMPRESSOR}" \
         JAVA_VERSION="${JAVA_VERSION}" \
         AZUREKMS_KEY_VAULT_ENDPOINT=${testazurekms_keyvaultendpoint} AZUREKMS_KEY_NAME=${testazurekms_keyname} \
-        SLOW_TESTS_ONLY=true .evergreen/run-tests.sh
+        TESTS="testSlowOnly" .evergreen/run-tests.sh
 
   "run scala tests":
     - command: shell.exec
@@ -861,11 +861,42 @@ tasks:
           vars:
             file: ".evergreen/static-checks.sh"
 
-    - name: "test"
+    - name: "test-bson-and-crypt"
+      commands:
+        - func: "run tests"
+          vars:
+            TESTS: 'bson:test bson-record-codec:test mongodb-crypt:test'
+
+    - name: "test-core"
+      commands:
+        - func: "bootstrap mongo-orchestration"
+        - func: "run tests"
+          vars:
+            TESTS: 'driver-core:test'
+
+    - name: "test-legacy"
       commands:
         - func: "start-kms-kmip-server"
         - func: "bootstrap mongo-orchestration"
         - func: "run tests"
+          vars:
+            TESTS: 'driver-legacy:test'
+
+    - name: "test-sync"
+      commands:
+        - func: "start-kms-kmip-server"
+        - func: "bootstrap mongo-orchestration"
+        - func: "run tests"
+          vars:
+            TESTS: 'driver-sync:test'
+
+    - name: "test-reactive"
+      commands:
+        - func: "start-kms-kmip-server"
+        - func: "bootstrap mongo-orchestration"
+        - func: "run tests"
+          vars:
+            TESTS: 'driver-reactive-streams:test'
 
     - name: load-balancer-test
       commands:
@@ -1826,11 +1857,11 @@ axes:
       - id: "2.12"
         display_name: "Scala 2.12"
         variables:
-          SCALA: "2.12.15"
+          SCALA: "2.12.20"
       - id: "2.13"
         display_name: "Scala 2.13"
         variables:
-          SCALA: "2.13.6"
+          SCALA: "2.13.15"
 
   # Choice of MongoDB storage engine
   - id: storage-engine
@@ -2105,14 +2136,20 @@ buildvariants:
   display_name: "${version} ${compressor} ${topology} ${auth} ${ssl} ${jdk} ${os} "
   tags: ["tests-variant"]
   tasks:
-     - name: "test"
+     - name: "test-sync"
+     - name: "test-reactive"
+     - name: "test-core"
+     - name: "test-legacy"
 
 - matrix_name: "tests-snappy-compression"
   matrix_spec: { compressor : "snappy", auth: "noauth", ssl: "nossl", jdk: "jdk8", version: "*", topology: "standalone", os: "linux" }
   display_name: "${version} ${compressor} ${topology} ${auth} ${ssl} ${jdk} ${os} "
   tags: ["tests-variant"]
   tasks:
-     - name: "test"
+    - name: "test-sync"
+    - name: "test-reactive"
+    - name: "test-core"
+    - name: "test-legacy"
 
 - matrix_name: "tests-zstd-compression"
   matrix_spec: { compressor : "zstd", auth: "noauth", ssl: "nossl", jdk: "jdk8",
@@ -2121,15 +2158,28 @@ buildvariants:
   display_name: "${version} ${compressor} ${topology} ${auth} ${ssl} ${jdk} ${os} "
   tags: ["tests-variant"]
   tasks:
-    - name: "test"
+    - name: "test-sync"
+    - name: "test-reactive"
+    - name: "test-core"
+    - name: "test-legacy"
+
+- matrix_name: "tests-unit"
+  matrix_spec: { jdk: [ "jdk8", "jdk11", "jdk17", "jdk21"], os: "linux" }
+  display_name: "${jdk} ${os} Unit"
+  tags: ["tests-variant"]
+  tasks:
+    - name: "test-bson-and-crypt"
 
 - matrix_name: "tests-jdk8-unsecure"
   matrix_spec: { auth: "noauth", ssl: "nossl", jdk: "jdk8", version: ["4.0", "4.2", "4.4", "5.0", "6.0", "7.0", "8.0", "latest"],
                  topology: "*", os: "linux" }
   display_name: "${version} ${topology} ${auth} ${ssl} ${jdk} ${os} "
   tags: ["tests-variant"]
   tasks:
-    - name: "test"
+    - name: "test-sync"
+    - name: "test-reactive"
+    - name: "test-core"
+    - name: "test-legacy"
 
 - matrix_name: "tests-jdk-secure"
   matrix_spec: { auth: "auth", ssl: "ssl", jdk: [ "jdk8", "jdk17", "jdk21"],
@@ -2138,22 +2188,31 @@ buildvariants:
   display_name: "${version} ${topology} ${auth} ${ssl} ${jdk} ${os} "
   tags: ["tests-variant"]
   tasks:
-     - name: "test"
+    - name: "test-sync"
+    - name: "test-reactive"
+    - name: "test-core"
+    - name: "test-legacy"
 
 - matrix_name: "tests-jdk-secure-jdk11"
   matrix_spec: { auth: "auth", ssl: "ssl", jdk: ["jdk11"], version: ["7.0"], topology: ["replicaset"], os: "linux" }
   display_name: "${version} ${topology} ${auth} ${ssl} ${jdk} ${os} "
   tags: ["tests-variant"]
   tasks:
-    - name: "test"
+    - name: "test-sync"
+    - name: "test-reactive"
+    - name: "test-core"
+    - name: "test-legacy"
 
 - matrix_name: "tests-require-api-version"
   matrix_spec: { api-version: "required", auth: "auth", ssl: "nossl", jdk: ["jdk21"], version: ["5.0", "6.0", "7.0", "8.0", "latest"],
                  topology: "standalone", os: "linux" }
   display_name: "${version} ${topology} ${api-version} "
   tags: ["tests-variant"]
   tasks:
-    - name: "test"
+    - name: "test-sync"
+    - name: "test-reactive"
+    - name: "test-core"
+    - name: "test-legacy"
 
 - matrix_name: "tests-load-balancer-secure"
   matrix_spec: { auth: "auth", ssl: "ssl", jdk: ["jdk21"], version: ["5.0", "6.0", "7.0", "8.0", "latest"], topology: "sharded-cluster",

.evergreen/run-atlas-search-tests.sh

@@ -16,4 +16,4 @@ echo "Running Atlas Search tests"
 ./gradlew --stacktrace --info \
     -Dorg.mongodb.test.atlas.search=true \
     -Dorg.mongodb.test.uri=${MONGODB_URI} \
-    driver-core:test --tests AggregatesSearchIntegrationTest
+    driver-core:test --tests AggregatesSearchIntegrationTest --tests AggregatesVectorSearchIntegrationTest

.evergreen/run-graalvm-native-image-app.sh

@@ -22,4 +22,4 @@ echo "The Gradle version is"
 ./gradlew --version
 
 echo "Building and running the GraalVM native image app"
-./gradlew -PjavaVersion=${JAVA_VERSION} -Dorg.mongodb.test.uri=${MONGODB_URI} :graalvm-native-image-app:nativeRun
+./gradlew -PincludeGraalvm -PjavaVersion=${JAVA_VERSION} -Dorg.mongodb.test.uri=${MONGODB_URI} :graalvm-native-image-app:nativeRun

.evergreen/run-tests.sh

@@ -35,6 +35,7 @@ MONGODB_URI=${MONGODB_URI:-}
 TOPOLOGY=${TOPOLOGY:-server}
 COMPRESSOR=${COMPRESSOR:-}
 STREAM_TYPE=${STREAM_TYPE:-nio2}
+TESTS=${TESTS:-test}
 SLOW_TESTS_ONLY=${SLOW_TESTS_ONLY:-false}
 
 export ASYNC_TYPE="-Dorg.mongodb.test.async.type=${STREAM_TYPE}"
@@ -136,15 +137,8 @@ echo "Running $AUTH tests over $SSL for $TOPOLOGY and connecting to $MONGODB_URI
 echo "Running tests with Java ${JAVA_VERSION}"
 ./gradlew -version
 
-if [ "$SLOW_TESTS_ONLY" == "true" ]; then
-    ./gradlew -PjavaVersion=${JAVA_VERSION} -Dorg.mongodb.test.uri=${MONGODB_URI} \
-              ${MULTI_MONGOS_URI_SYSTEM_PROPERTY} ${GRADLE_EXTRA_VARS} ${ASYNC_TYPE} \
-              ${JAVA_SYSPROP_NETTY_SSL_PROVIDER} \
-              --stacktrace --info testSlowOnly
-else
-    ./gradlew -PjavaVersion=${JAVA_VERSION} -Dorg.mongodb.test.uri=${MONGODB_URI} \
-              ${MULTI_MONGOS_URI_SYSTEM_PROPERTY} ${API_VERSION} ${GRADLE_EXTRA_VARS} ${ASYNC_TYPE} \
-              ${JAVA_SYSPROP_NETTY_SSL_PROVIDER} \
-              -Dorg.mongodb.test.fle.on.demand.credential.test.failure.enabled=true \
-              --stacktrace --info --continue test
-fi
+./gradlew -PjavaVersion=${JAVA_VERSION} -Dorg.mongodb.test.uri=${MONGODB_URI} \
+          ${MULTI_MONGOS_URI_SYSTEM_PROPERTY} ${API_VERSION} ${GRADLE_EXTRA_VARS} ${ASYNC_TYPE} \
+          ${JAVA_SYSPROP_NETTY_SSL_PROVIDER} \
+          -Dorg.mongodb.test.fle.on.demand.credential.test.failure.enabled=true \
+          --stacktrace --info --continue ${TESTS}

.evergreen/ssdlc-report.sh

@@ -40,10 +40,10 @@ declare -r EVERGREEN_BUILD_URL_PREFIX="https://spruce.mongodb.com/version"
 declare -r GIT_TAG="r${PRODUCT_VERSION}"
 GIT_COMMIT_HASH="$(git rev-list --ignore-missing -n 1 "${GIT_TAG}")"
 set +e
-    GIT_BRANCH_MASTER="$(git branch -a --contains "${GIT_TAG}" | grep 'master$')"
+    GIT_BRANCH_DEFAULT="$(git branch -a --contains "${GIT_TAG}" | grep 'main$')"
     GIT_BRANCH_PATCH="$(git branch -a --contains "${GIT_TAG}" | grep '\.x$')"
 set -e
-if [ -n "${GIT_BRANCH_MASTER}" ]; then
+if [ -n "${GIT_BRANCH_DEFAULT}" ]; then
     declare -r EVERGREEN_BUILD_URL="${EVERGREEN_BUILD_URL_PREFIX}/${EVERGREEN_PROJECT_NAME_PREFIX}_${GIT_COMMIT_HASH}"
 elif [ -n "${GIT_BRANCH_PATCH}" ]; then
     # strip out the patch version

.github/workflows/release.yml

@@ -78,12 +78,12 @@ jobs:
           exit 1
 
       # For non-patch releases (A.B.C where C == 0), we expect the release to
-      # be triggered from master or the A.B.x maintenance branch. This includes
+      # be triggered from main or the A.B.x maintenance branch. This includes
       # pre-releases for any non-patch releases, e.g. 5.2.0-beta1
       - name: "Fail if non-patch release is created from wrong release branch"
-        if: ${{ endsWith(env.RELEASE_VERSION_WITHOUT_SUFFIX, '.0') && env.RELEASE_BRANCH != github.ref_name && github.ref_name != 'master' }}
+        if: ${{ endsWith(env.RELEASE_VERSION_WITHOUT_SUFFIX, '.0') && env.RELEASE_BRANCH != github.ref_name && github.ref_name != 'main' }}
         run: |
-          echo '❌ Release failed due to branch mismatch: expected ${{ inputs.version }} to be released from ${{ env.RELEASE_BRANCH }} or master, got ${{ github.ref_name }}' >> $GITHUB_STEP_SUMMARY
+          echo '❌ Release failed due to branch mismatch: expected ${{ inputs.version }} to be released from ${{ env.RELEASE_BRANCH }} or main, got ${{ github.ref_name }}' >> $GITHUB_STEP_SUMMARY
           exit 1
 
       # Set commit author information to the user that triggered the release workflow

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/BsonDecoder.kt

@@ -37,10 +37,11 @@ import org.bson.BsonType
 import org.bson.BsonValue
 import org.bson.codecs.BsonValueCodec
 import org.bson.codecs.DecoderContext
-import org.bson.codecs.kotlinx.BsonDecoder.Companion.createBsonArrayDecoder
-import org.bson.codecs.kotlinx.BsonDecoder.Companion.createBsonDocumentDecoder
-import org.bson.codecs.kotlinx.BsonDecoder.Companion.createBsonMapDecoder
-import org.bson.codecs.kotlinx.BsonDecoder.Companion.createBsonPolymorphicDecoder
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.createBsonArrayDecoder
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.createBsonDecoder
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.createBsonDocumentDecoder
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.createBsonMapDecoder
+import org.bson.codecs.kotlinx.utils.BsonCodecUtils.createBsonPolymorphicDecoder
 import org.bson.internal.NumberCodecHelper
 import org.bson.internal.StringCodecHelper
 import org.bson.types.ObjectId
@@ -51,75 +52,12 @@ import org.bson.types.ObjectId
  * For custom serialization handlers
  */
 @ExperimentalSerializationApi
-internal sealed interface BsonDecoder : Decoder, CompositeDecoder {
-
-    /** Factory helper for creating concrete BsonDecoder implementations */
-    companion object {
-
-        @Suppress("SwallowedException")
-        private val hasJsonDecoder: Boolean by lazy {
-            try {
-                Class.forName("kotlinx.serialization.json.JsonDecoder")
-                true
-            } catch (e: ClassNotFoundException) {
-                false
-            }
-        }
-
-        fun createBsonDecoder(
-            reader: AbstractBsonReader,
-            serializersModule: SerializersModule,
-            configuration: BsonConfiguration
-        ): BsonDecoder {
-            return if (hasJsonDecoder) JsonBsonDecoderImpl(reader, serializersModule, configuration)
-            else BsonDecoderImpl(reader, serializersModule, configuration)
-        }
-
-        fun createBsonArrayDecoder(
-            descriptor: SerialDescriptor,
-            reader: AbstractBsonReader,
-            serializersModule: SerializersModule,
-            configuration: BsonConfiguration
-        ): BsonArrayDecoder {
-            return if (hasJsonDecoder) JsonBsonArrayDecoder(descriptor, reader, serializersModule, configuration)
-            else BsonArrayDecoder(descriptor, reader, serializersModule, configuration)
-        }
-
-        fun createBsonDocumentDecoder(
-            descriptor: SerialDescriptor,
-            reader: AbstractBsonReader,
-            serializersModule: SerializersModule,
-            configuration: BsonConfiguration
-        ): BsonDocumentDecoder {
-            return if (hasJsonDecoder) JsonBsonDocumentDecoder(descriptor, reader, serializersModule, configuration)
-            else BsonDocumentDecoder(descriptor, reader, serializersModule, configuration)
-        }
-
-        fun createBsonPolymorphicDecoder(
-            descriptor: SerialDescriptor,
-            reader: AbstractBsonReader,
-            serializersModule: SerializersModule,
-            configuration: BsonConfiguration
-        ): BsonPolymorphicDecoder {
-            return if (hasJsonDecoder) JsonBsonPolymorphicDecoder(descriptor, reader, serializersModule, configuration)
-            else BsonPolymorphicDecoder(descriptor, reader, serializersModule, configuration)
-        }
-
-        fun createBsonMapDecoder(
-            descriptor: SerialDescriptor,
-            reader: AbstractBsonReader,
-            serializersModule: SerializersModule,
-            configuration: BsonConfiguration
-        ): BsonMapDecoder {
-            return if (hasJsonDecoder) JsonBsonMapDecoder(descriptor, reader, serializersModule, configuration)
-            else BsonMapDecoder(descriptor, reader, serializersModule, configuration)
-        }
-    }
+public sealed interface BsonDecoder : Decoder, CompositeDecoder {
 
     /** @return the decoded ObjectId */
-    fun decodeObjectId(): ObjectId
+    public fun decodeObjectId(): ObjectId
     /** @return the decoded BsonValue */
-    fun decodeBsonValue(): BsonValue
+    public fun decodeBsonValue(): BsonValue
 }
 
 @OptIn(ExperimentalSerializationApi::class)
@@ -325,7 +263,7 @@ internal open class BsonPolymorphicDecoder(
             it.reset()
             mark = null
         }
-        return deserializer.deserialize(BsonDecoder.createBsonDecoder(reader, serializersModule, configuration))
+        return deserializer.deserialize(createBsonDecoder(reader, serializersModule, configuration))
     }
 
     override fun decodeElementIndex(descriptor: SerialDescriptor): Int {

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/BsonEncoder.kt

@@ -39,43 +39,21 @@ import org.bson.types.ObjectId
  * For custom serialization handlers
  */
 @ExperimentalSerializationApi
-internal sealed interface BsonEncoder : Encoder, CompositeEncoder {
-
-    /** Factory helper for creating concrete BsonEncoder implementations */
-    companion object {
-        @Suppress("SwallowedException")
-        private val hasJsonEncoder: Boolean by lazy {
-            try {
-                Class.forName("kotlinx.serialization.json.JsonEncoder")
-                true
-            } catch (e: ClassNotFoundException) {
-                false
-            }
-        }
-
-        fun createBsonEncoder(
-            writer: BsonWriter,
-            serializersModule: SerializersModule,
-            configuration: BsonConfiguration
-        ): BsonEncoder {
-            return if (hasJsonEncoder) JsonBsonEncoder(writer, serializersModule, configuration)
-            else BsonEncoderImpl(writer, serializersModule, configuration)
-        }
-    }
+public sealed interface BsonEncoder : Encoder, CompositeEncoder {
 
     /**
      * Encodes an ObjectId
      *
      * @param value the ObjectId
      */
-    fun encodeObjectId(value: ObjectId)
+    public fun encodeObjectId(value: ObjectId)
 
     /**
      * Encodes a BsonValue
      *
      * @param value the BsonValue
      */
-    fun encodeBsonValue(value: BsonValue)
+    public fun encodeBsonValue(value: BsonValue)
 }
 
 /**