CSHARP-2425: Implement Unified URI Options.

Author: DmitryLukyanov

src/MongoDB.Driver.Core/Core/Configuration/ClusterBuilderExtensions.cs

@@ -90,14 +90,13 @@ public static ClusterBuilder ConfigureWithConnectionString(this ClusterBuilder b
                     writeTimeout: connectionString.SocketTimeout.Value));
             }
 
-            if (connectionString.Ssl != null)
+            if (connectionString.Tls != null)
             {
                 builder = builder.ConfigureSsl(ssl =>
                 {
-                    if (!connectionString.SslVerifyCertificate.GetValueOrDefault(true))
+                    if (connectionString.TlsInsecure.GetValueOrDefault(false))
                     {
-                        ssl = ssl.With(
-                            serverCertificateValidationCallback: new RemoteCertificateValidationCallback(AcceptAnySslCertificate));
+                        ssl = ssl.With(serverCertificateValidationCallback: new RemoteCertificateValidationCallback(AcceptAnySslCertificate));
                     }
 
                     return ssl;

src/MongoDB.Driver.Core/Core/Configuration/ConnectionString.cs

@@ -94,8 +94,8 @@ public sealed class ConnectionString
         private ConnectionStringScheme _scheme;
         private TimeSpan? _serverSelectionTimeout;
         private TimeSpan? _socketTimeout;
-        private bool? _ssl;
-        private bool? _sslVerifyCertificate;
+        private bool? _tls;
+        private bool? _tlsInsecure;
         private string _username;
         private GuidRepresentation? _uuidRepresentation;
         private double? _waitQueueMultiple;
@@ -383,7 +383,7 @@ public bool? RetryWrites
             get { return _retryWrites; }
         }
 
-       /// <summary>
+        /// <summary>
         /// Gets the connection string scheme.
         /// </summary>
         public ConnectionStringScheme Scheme
@@ -410,18 +410,27 @@ public TimeSpan? SocketTimeout
         /// <summary>
         /// Gets whether to use SSL.
         /// </summary>
+        [Obsolete("Use Tls instead.")]
         public bool? Ssl
         {
-            get { return _ssl; }
+            get { return _tls; }
         }
 
         /// <summary>
         /// Gets whether to verify SSL certificates.
         /// </summary>
-        public bool? SslVerifyCertificate
-        {
-            get { return _sslVerifyCertificate; }
-        }
+        [Obsolete("Use TlsInsecure instead.")]
+        public bool? SslVerifyCertificate => !_tlsInsecure;
+
+        /// <summary>
+        /// Gets whether to use TLS.
+        /// </summary>
+        public bool? Tls => _tls;
+
+        /// <summary>
+        /// Gets whether to relax TLS constraints as much as possible.
+        /// </summary>
+        public bool? TlsInsecure => _tlsInsecure;
 
         /// <summary>
         /// Gets the username.
@@ -620,9 +629,9 @@ private ConnectionString BuildResolvedConnectionString(ConnectionStringScheme re
             }
 
             // remove any option from the resolved options that was specified locally
-            foreach(var key in _allOptions.AllKeys)
+            foreach (var key in _allOptions.AllKeys)
             {
-                if(resolvedOptions.Get(key) != null)
+                if (resolvedOptions.Get(key) != null)
                 {
                     resolvedOptions.Remove(key);
                 }
@@ -654,8 +663,11 @@ private void ExtractScheme(Match match)
                 if (schemeGroup.Value == "mongodb+srv")
                 {
                     _scheme = ConnectionStringScheme.MongoDBPlusSrv;
-                    _ssl = true;
-                    _allOptions.Add("ssl", "true");
+                    if (!_tls.HasValue)
+                    {
+                        _tls = true;
+                        _allOptions.Add("tls", "true");
+                    }
                 }
             }
         }
@@ -777,10 +789,10 @@ private void Parse()
                 throw new MongoConfigurationException(message);
             }
 
-            ExtractScheme(match);
             ExtractUsernameAndPassword(match);
             ExtractDatabaseName(match);
             ExtractOptions(match);
+            ExtractScheme(match);
             ExtractHosts(match);
 
             if (_journal.HasValue && _journal.Value && _w != null && _w.Equals(0))
@@ -940,11 +952,22 @@ private void ParseOption(string name, string value)
                 case "sockettimeoutms":
                     _socketTimeout = ParseTimeSpan(name, value);
                     break;
-                case "ssl":
-                    _ssl = ParseBoolean(name, value);
+                case "ssl": // Obsolete
+                case "tls":
+                    var tlsValue = ParseBoolean(name, value);
+                    if (_tls.HasValue && _tls.Value != tlsValue)
+                    {
+                        throw new MongoConfigurationException("tls has already been configured with a different value.");
+                    }
+                    _tls = tlsValue;
+                    break;
+                case "sslverifycertificate": // Obsolete
+                    var sslVerifyCertificateValue = ParseBoolean(name, value);
+                    _tlsInsecure = EnsureTlsInsecureIsValid(!sslVerifyCertificateValue);
                     break;
-                case "sslverifycertificate":
-                    _sslVerifyCertificate = ParseBoolean(name, value);
+                case "tlsinsecure":
+                    var tlsInsecureValue = ParseBoolean(name, value);
+                    _tlsInsecure = EnsureTlsInsecureIsValid(tlsInsecureValue);
                     break;
                 case "guids":
                 case "uuidrepresentation":
@@ -1126,6 +1149,16 @@ private static TimeSpan ParseTimeSpan(string name, string value)
             }
         }
 
+        private bool EnsureTlsInsecureIsValid(bool value)
+        {
+            if (_tlsInsecure.HasValue && _tlsInsecure.Value != value)
+            {
+                throw new MongoConfigurationException("tlsInsecure has already been configured with a different value.");
+            }
+
+            return value;
+        }
+
         private List<string> GetHostsFromResponse(IDnsQueryResponse response)
         {
             var hosts = new List<string>();
@@ -1176,7 +1209,7 @@ private void ValidateResolvedHosts(string original, List<string> resolved)
             }
 
             // for each resolved host, make sure that it ends with domain of the parent.
-            foreach(var resolvedHost in resolved)
+            foreach (var resolvedHost in resolved)
             {
                 EndPoint endPoint;
                 if (!EndPointHelper.TryParse(resolvedHost, 0, out endPoint) || !(endPoint is DnsEndPoint))
@@ -1206,8 +1239,8 @@ internal static bool HasValidParentDomain(string original, DnsEndPoint resolvedE
                     return false;
                 }
 
-                // loop from back to front making sure that all of b is at the back of a, in order.
-                for (int ai = a.Length - 1, bi = b.Length - 1; bi >= 0; ai--, bi--)
+            // loop from back to front making sure that all of b is at the back of a, in order.
+            for (int ai = a.Length - 1, bi = b.Length - 1; bi >= 0; ai--, bi--)
                 {
                     if (a[ai] != b[bi])
                     {

src/MongoDB.Driver.Legacy/MongoServerSettings.cs

@@ -32,6 +32,7 @@ namespace MongoDB.Driver
     public class MongoServerSettings : IEquatable<MongoServerSettings>, IInheritableMongoClientSettings
     {
         // private fields
+        private bool _allowInsecureTls;
         private string _applicationName;
         private Action<ClusterBuilder> _clusterConfigurator;
         private IReadOnlyList<CompressorConfiguration> _compressors;
@@ -60,8 +61,7 @@ public class MongoServerSettings : IEquatable<MongoServerSettings>, IInheritable
         private TimeSpan _serverSelectionTimeout;
         private TimeSpan _socketTimeout;
         private SslSettings _sslSettings;
-        private bool _useSsl;
-        private bool _verifySslCertificate;
+        private bool _useTls;
         private int _waitQueueSize;
         private TimeSpan _waitQueueTimeout;
         private WriteConcern _writeConcern;
@@ -78,6 +78,7 @@ public class MongoServerSettings : IEquatable<MongoServerSettings>, IInheritable
         /// </summary>
         public MongoServerSettings()
         {
+            _allowInsecureTls = false;
             _applicationName = null;
             _compressors = new CompressorConfiguration[0];
             _connectionMode = ConnectionMode.Automatic;
@@ -105,8 +106,7 @@ public MongoServerSettings()
             _serverSelectionTimeout = MongoDefaults.ServerSelectionTimeout;
             _socketTimeout = MongoDefaults.SocketTimeout;
             _sslSettings = null;
-            _useSsl = false;
-            _verifySslCertificate = true;
+            _useTls = false;
             _waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
             _waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
             _writeConcern = WriteConcern.Unacknowledged;
@@ -123,6 +123,19 @@ public AddressFamily AddressFamily
             get { return _ipv6 ? AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork; }
         }
 
+        /// <summary>
+        /// Gets or sets whether to relax TLS constraints as much as possible.
+        /// </summary>
+        public bool AllowInsecureTls
+        {
+            get { return _allowInsecureTls; }
+            set
+            {
+                if (_isFrozen) { throw new InvalidOperationException("MongoServerSettings is frozen."); }
+                _allowInsecureTls = value;
+            }
+        }
+
         /// <summary>
         /// Gets or sets the application name.
         /// </summary>
@@ -552,26 +565,41 @@ public SslSettings SslSettings
         /// <summary>
         /// Gets or sets a value indicating whether to use SSL.
         /// </summary>
+        [Obsolete("Use UseTls instead.")]
         public bool UseSsl
         {
-            get { return _useSsl; }
+            get { return _useTls; }
+            set
+            {
+                if (_isFrozen) { throw new InvalidOperationException("MongoServerSettings is frozen."); }
+                _useTls = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to use TLS.
+        /// </summary>
+        public bool UseTls
+        {
+            get { return _useTls; }
             set
             {
                 if (_isFrozen) { throw new InvalidOperationException("MongoServerSettings is frozen."); }
-                _useSsl = value;
+                _useTls = value;
             }
         }
 
         /// <summary>
         /// Gets or sets a value indicating whether to verify an SSL certificate.
         /// </summary>
+        [Obsolete("Use AllowInsecureTls instead.")]
         public bool VerifySslCertificate
         {
-            get { return _verifySslCertificate; }
+            get { return !_allowInsecureTls; }
             set
             {
                 if (_isFrozen) { throw new InvalidOperationException("MongoServerSettings is frozen."); }
-                _verifySslCertificate = value;
+                _allowInsecureTls = !value;
             }
         }
 
@@ -667,6 +695,7 @@ public UTF8Encoding WriteEncoding
         public static MongoServerSettings FromClientSettings(MongoClientSettings clientSettings)
         {
             var serverSettings = new MongoServerSettings();
+            serverSettings.AllowInsecureTls = clientSettings.AllowInsecureTls;
             serverSettings.ApplicationName = clientSettings.ApplicationName;
             serverSettings.ClusterConfigurator = clientSettings.ClusterConfigurator;
             serverSettings.Compressors = clientSettings.Compressors;
@@ -696,8 +725,7 @@ public static MongoServerSettings FromClientSettings(MongoClientSettings clientS
             serverSettings.ServerSelectionTimeout = clientSettings.ServerSelectionTimeout;
             serverSettings.SocketTimeout = clientSettings.SocketTimeout;
             serverSettings.SslSettings = (clientSettings.SslSettings == null) ? null : clientSettings.SslSettings.Clone();
-            serverSettings.UseSsl = clientSettings.UseSsl;
-            serverSettings.VerifySslCertificate = clientSettings.VerifySslCertificate;
+            serverSettings.UseTls = clientSettings.UseTls;
             serverSettings.WaitQueueSize = clientSettings.WaitQueueSize;
             serverSettings.WaitQueueTimeout = clientSettings.WaitQueueTimeout;
             serverSettings.WriteConcern = clientSettings.WriteConcern;
@@ -715,6 +743,7 @@ public static MongoServerSettings FromUrl(MongoUrl url)
             var credential = url.GetCredential();
 
             var serverSettings = new MongoServerSettings();
+            serverSettings.AllowInsecureTls = url.AllowInsecureTls;
             serverSettings.ApplicationName = url.ApplicationName;
             serverSettings.Compressors = url.Compressors;
             serverSettings.ConnectionMode = url.ConnectionMode;
@@ -755,8 +784,7 @@ public static MongoServerSettings FromUrl(MongoUrl url)
             serverSettings.ServerSelectionTimeout = url.ServerSelectionTimeout;
             serverSettings.SocketTimeout = url.SocketTimeout;
             serverSettings.SslSettings = null; // SSL settings must be provided in code
-            serverSettings.UseSsl = url.UseSsl;
-            serverSettings.VerifySslCertificate = url.VerifySslCertificate;
+            serverSettings.UseTls = url.UseTls;
             serverSettings.WaitQueueSize = url.ComputedWaitQueueSize;
             serverSettings.WaitQueueTimeout = url.WaitQueueTimeout;
             serverSettings.WriteConcern = url.GetWriteConcern(false);
@@ -772,6 +800,7 @@ public static MongoServerSettings FromUrl(MongoUrl url)
         public MongoServerSettings Clone()
         {
             var clone = new MongoServerSettings();
+            clone._allowInsecureTls = _allowInsecureTls;
             clone._applicationName = _applicationName;
             clone._clusterConfigurator = _clusterConfigurator;
             clone._compressors = _compressors;
@@ -800,8 +829,7 @@ public MongoServerSettings Clone()
             clone._serverSelectionTimeout = _serverSelectionTimeout;
             clone._socketTimeout = _socketTimeout;
             clone._sslSettings = (_sslSettings == null) ? null : _sslSettings.Clone();
-            clone._useSsl = _useSsl;
-            clone._verifySslCertificate = _verifySslCertificate;
+            clone._useTls = _useTls;
             clone._waitQueueSize = _waitQueueSize;
             clone._waitQueueTimeout = _waitQueueTimeout;
             clone._writeConcern = _writeConcern;
@@ -833,6 +861,7 @@ public override bool Equals(object obj)
             if (object.ReferenceEquals(obj, null) || GetType() != obj.GetType()) { return false; }
             var rhs = (MongoServerSettings)obj;
             return
+                _allowInsecureTls == rhs._allowInsecureTls &&
                 _applicationName == rhs._applicationName &&
                 object.ReferenceEquals(_clusterConfigurator, rhs._clusterConfigurator) &&
                _compressors.SequenceEqual(rhs._compressors) &&
@@ -861,8 +890,7 @@ public override bool Equals(object obj)
                _serverSelectionTimeout == rhs._serverSelectionTimeout &&
                _socketTimeout == rhs._socketTimeout &&
                _sslSettings == rhs._sslSettings &&
-               _useSsl == rhs._useSsl &&
-               _verifySslCertificate == rhs._verifySslCertificate &&
+                _useTls == rhs._useTls &&
                _waitQueueSize == rhs._waitQueueSize &&
                _waitQueueTimeout == rhs._waitQueueTimeout &&
                _writeConcern.Equals(rhs._writeConcern) &&
@@ -912,6 +940,7 @@ public override int GetHashCode()
             }
 
             return new Hasher()
+                .Hash(_allowInsecureTls)
                 .Hash(_applicationName)
                 .Hash(_clusterConfigurator)
                 .HashElements(_compressors)
@@ -940,8 +969,7 @@ public override int GetHashCode()
                 .Hash(_serverSelectionTimeout)
                 .Hash(_socketTimeout)
                 .Hash(_sslSettings)
-                .Hash(_useSsl)
-                .Hash(_verifySslCertificate)
+                .Hash(_useTls)
                 .Hash(_waitQueueSize)
                 .Hash(_waitQueueTimeout)
                 .Hash(_writeConcern)
@@ -1008,8 +1036,8 @@ public override string ToString()
             {
                 parts.Add(string.Format("SslSettings={0}", _sslSettings));
             }
-            parts.Add(string.Format("Ssl={0}", _useSsl));
-            parts.Add(string.Format("SslVerifyCertificate={0}", _verifySslCertificate));
+            parts.Add(string.Format("Tls={0}", _useTls));
+            parts.Add(string.Format("TlsInsecure={0}", _allowInsecureTls));
             parts.Add(string.Format("WaitQueueSize={0}", _waitQueueSize));
             parts.Add(string.Format("WaitQueueTimeout={0}", _waitQueueTimeout));
             parts.Add(string.Format("WriteConcern={0}", _writeConcern));
@@ -1024,6 +1052,7 @@ public override string ToString()
         internal ClusterKey ToClusterKey()
         {
             return new ClusterKey(
+                _allowInsecureTls,
                 _applicationName,
                 _clusterConfigurator,
                 _compressors,
@@ -1047,8 +1076,7 @@ internal ClusterKey ToClusterKey()
                 _serverSelectionTimeout,
                 _socketTimeout,
                 _sslSettings,
-                _useSsl,
-                _verifySslCertificate,
+                _useTls,
                 _waitQueueSize,
                 _waitQueueTimeout);
         }