In tests, use TlsChannel when possible, otherwise use Netty

JAVA-3038

Author: jyemin

.evergreen/run-tests.sh

@@ -49,8 +49,6 @@ provision_ssl () {
 
   # We add extra gradle arguments for SSL
   export GRADLE_EXTRA_VARS="-Pssl.enabled=true -Pssl.keyStoreType=pkcs12 -Pssl.keyStore=`pwd`/client.pkc -Pssl.keyStorePassword=bithere -Pssl.trustStoreType=jks -Pssl.trustStore=`pwd`/mongo-truststore -Pssl.trustStorePassword=hithere"
-  export ASYNC_TYPE="-Dorg.mongodb.async.type=netty"
-
   # Arguments for auth + SSL
   if [ "$AUTH" != "noauth" ] || [ "$TOPOLOGY" == "replica_set" ]; then
     export MONGODB_URI="${MONGODB_URI}&ssl=true&sslInvalidHostNameAllowed=true"

driver-async/src/test/functional/com/mongodb/async/client/Fixture.java

@@ -19,14 +19,22 @@
 import com.mongodb.Block;
 import com.mongodb.ClusterFixture;
 import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
 import com.mongodb.MongoCommandException;
 import com.mongodb.MongoInterruptedException;
 import com.mongodb.MongoNamespace;
 import com.mongodb.MongoTimeoutException;
 import com.mongodb.async.FutureResultCallback;
+import com.mongodb.connection.AsynchronousSocketChannelStreamFactoryFactory;
 import com.mongodb.connection.SslSettings;
+import com.mongodb.connection.StreamFactoryFactory;
+import com.mongodb.connection.TlsChannelStreamFactoryFactory;
+import com.mongodb.connection.netty.NettyStreamFactoryFactory;
 import org.bson.Document;
 
+import static com.mongodb.ClusterFixture.getSslSettings;
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7;
+import static com.mongodb.ClusterFixture.isNotAtLeastJava8;
 import static com.mongodb.connection.ClusterType.SHARDED;
 import static java.lang.Thread.sleep;
 import static java.util.concurrent.TimeUnit.SECONDS;
@@ -51,6 +59,10 @@ public static synchronized MongoClient getMongoClient() {
         return mongoClient;
     }
 
+    public static MongoClientSettings getMongoClientSettings() {
+        return getMongoClientBuilderFromConnectionString().build();
+    }
+
     public static com.mongodb.MongoClientSettings.Builder getMongoClientBuilderFromConnectionString() {
         com.mongodb.MongoClientSettings.Builder builder = com.mongodb.MongoClientSettings.builder()
                 .applyConnectionString(getConnectionString());
@@ -62,9 +74,26 @@ public void apply(final SslSettings.Builder builder) {
                 }
             });
         }
+        builder.streamFactoryFactory(getStreamFactoryFactory());
         return builder;
     }
 
+    public static StreamFactoryFactory getStreamFactoryFactory() {
+        if (getSslSettings().isEnabled()) {
+            if (isNotAtLeastJava8()) {
+                return NettyStreamFactoryFactory.builder().build();
+            } else {
+                return new TlsChannelStreamFactoryFactory();
+            }
+        } else {
+            if (isNotAtLeastJava7()) {
+                return NettyStreamFactoryFactory.builder().build();
+            } else {
+                return AsynchronousSocketChannelStreamFactoryFactory.builder().build();
+            }
+        }
+    }
+
     public static synchronized ConnectionString getConnectionString() {
         return ClusterFixture.getConnectionString();
     }

driver-async/src/test/functional/com/mongodb/async/client/InitialDnsSeedlistDiscoveryTest.java

@@ -54,6 +54,7 @@
 
 import static com.mongodb.ClusterFixture.getSslSettings;
 import static com.mongodb.ClusterFixture.isDiscoverableReplicaSet;
+import static com.mongodb.async.client.Fixture.getStreamFactoryFactory;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -170,11 +171,11 @@ public void shouldDiscover() throws InterruptedException {
         assumeTrue("SSL settings don't match", getSslSettings().isEnabled() == sslSettings.isEnabled());
 
         com.mongodb.MongoClientSettings settings = com.mongodb.MongoClientSettings.builder()
-                .streamFactoryFactory(NettyStreamFactoryFactory.builder().build())  // TODO: why wasn't this necessary before?  Is it now?
+                .streamFactoryFactory(getStreamFactoryFactory())
                 .applyToClusterSettings(new Block<ClusterSettings.Builder>() {
-            @Override
-            public void apply(final ClusterSettings.Builder builder) {
-                builder.applyConnectionString(connectionString)
+                    @Override
+                    public void apply(final ClusterSettings.Builder builder) {
+                        builder.applyConnectionString(connectionString)
                         .addClusterListener(new ClusterListener() {
                             @Override
                             public void clusterOpening(final ClusterOpeningEvent event) {

driver-core/src/test/functional/com/mongodb/ClusterFixture.java

@@ -46,6 +46,7 @@
 import com.mongodb.connection.SocketStreamFactory;
 import com.mongodb.connection.SslSettings;
 import com.mongodb.connection.StreamFactory;
+import com.mongodb.connection.TlsChannelStreamFactoryFactory;
 import com.mongodb.connection.netty.NettyStreamFactory;
 import com.mongodb.operation.AsyncReadOperation;
 import com.mongodb.operation.AsyncWriteOperation;
@@ -330,10 +331,22 @@ public static StreamFactory getStreamFactory() {
     public static StreamFactory getAsyncStreamFactory() {
         String streamType = System.getProperty("org.mongodb.async.type", "nio2");
 
-        if (streamType.equals("netty") || getSslSettings().isEnabled()) {
+        if (streamType.equals("netty")) {
             return new NettyStreamFactory(getSocketSettings(), getSslSettings());
         } else if (streamType.equals("nio2")) {
-            return new AsynchronousSocketChannelStreamFactory(getSocketSettings(), getSslSettings());
+            if (getSslSettings().isEnabled()) {
+                if (isNotAtLeastJava8()) {
+                    return new NettyStreamFactory(getSocketSettings(), getSslSettings());
+                } else {
+                    return new TlsChannelStreamFactoryFactory().create(getSocketSettings(), getSslSettings());
+                }
+            } else {
+                if (isNotAtLeastJava7()) {
+                    return new NettyStreamFactory(getSocketSettings(), getSslSettings());
+                } else {
+                    return new AsynchronousSocketChannelStreamFactory(getSocketSettings(), getSslSettings());
+                }
+            }
         } else {
             throw new IllegalArgumentException("Unsupported stream type " + streamType);
         }