public void SslPreferredIsInvalid() { var expectedErrorMessage = "Value '{0}' is not of the correct type."; // In connection string. var exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(ConnectionStringUri + "?ssl-mode=Preferred")); Assert.Equal(string.Format(expectedErrorMessage, "Preferred"), exception.Message); exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(ConnectionStringUri + "?ssl-mode=Prefered")); Assert.Equal(string.Format(expectedErrorMessage, "Prefered"), exception.Message); // In anonymous object. var builder = new MySqlXConnectionStringBuilder(ConnectionString); var connectionObject = new{ server = builder.Server, port = builder.Port, user = builder.UserID, password = builder.Password, sslmode = MySqlSslMode.Prefered }; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(connectionObject)); Assert.Equal(string.Format(expectedErrorMessage, "Prefered"), exception.Message); // In MySqlXConnectionStringBuilder. builder = new MySqlXConnectionStringBuilder(ConnectionString); builder.SslMode = MySqlSslMode.Prefered; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(connectionObject)); Assert.Equal(string.Format(expectedErrorMessage, "Prefered"), exception.Message); builder = new MySqlXConnectionStringBuilder(ConnectionString); builder.SslMode = MySqlSslMode.Preferred; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(connectionObject)); Assert.Equal(string.Format(expectedErrorMessage, "Prefered"), exception.Message); }
public void SslCertificatePathKeepsCase() { var certificatePath = "../../../../MySql.Data.Tests/client.pfx"; // Connection string in basic format. string connString = ConnectionString + ";ssl-ca=" + certificatePath + ";ssl-ca-pwd=pass;"; var stringBuilder = new MySqlXConnectionStringBuilder(connString); Assert.Equal(certificatePath, stringBuilder.CertificateFile); Assert.Equal(certificatePath, stringBuilder.SslCa); Assert.True(stringBuilder.ConnectionString.Contains(certificatePath)); connString = stringBuilder.ToString(); Assert.True(connString.Contains(certificatePath)); // Connection string in uri format. string connStringUri = ConnectionStringUri + "/?ssl-ca=" + certificatePath + "& ssl-ca-pwd=pass;"; using (var session = MySQLX.GetSession(connStringUri)) { Assert.Equal(certificatePath, session.Settings.CertificateFile); Assert.Equal(certificatePath, session.Settings.SslCa); Assert.True(session.Settings.ConnectionString.Contains(certificatePath)); connString = session.Settings.ToString(); Assert.True(connString.Contains(certificatePath)); } }
/// <summary> /// Attempts to establish a connection to a host specified from the list. /// </summary> /// <param name="originalConnectionString">The original connection string set by the user.</param> /// <param name="connectionString">An out parameter that stores the updated connection string.</param> /// <returns>An <see cref="InternalSession"/> instance if the connection was succesfully established, a <see cref="MySqlException"/> exception is thrown otherwise.</returns> internal static InternalSession AttemptConnection(string originalConnectionString, out string connectionString) { if (FailoverGroup == null || originalConnectionString == null) { connectionString = null; return(null); } XServer currentHost = FailoverGroup.ActiveHost; string initialHost = currentHost.Host; MySqlXConnectionStringBuilder Settings = null; InternalSession internalSession = null; TimeoutException timeoutException = null; do { // Attempt to connect to each host by retrieving the next host based on the failover method being used. connectionString = "server=" + currentHost.Host + ";" + originalConnectionString.Substring(originalConnectionString.IndexOf(';') + 1); Settings = new MySqlXConnectionStringBuilder(connectionString); if (currentHost != null && currentHost.Port != -1) { Settings.Port = (uint)currentHost.Port; } if (currentHost.Host == initialHost) { string exTimeOutMessage = Settings.ConnectTimeout == 0 ? ResourcesX.TimeOutMultipleHost0ms : String.Format(ResourcesX.TimeOutMultipleHost, Settings.ConnectTimeout); timeoutException = new TimeoutException(exTimeOutMessage); } try { internalSession = InternalSession.GetSession(Settings); timeoutException = null; } catch (Exception ex) { if (!(ex is TimeoutException)) { timeoutException = null; } } if (internalSession != null) { break; } currentHost = FailoverGroup.GetNextHost(); }while (currentHost.Host != initialHost); // All connection attempts failed. if (timeoutException != null) { throw timeoutException; } if (internalSession == null) { throw new MySqlException(Resources.UnableToConnectToHost); } return(internalSession); }
public void AttemptConnectionWitSwitchedPemCertificates() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = _sslCert; builder.SslMode = MySqlSslMode.VerifyCA; var exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.SslCertificateIsNotCA, exception.InnerException.Message); builder.SslCa = _sslKey; builder.SslMode = MySqlSslMode.VerifyCA; exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.FileIsNotACertificate, exception.InnerException.Message); builder.SslCa = _sslCa; builder.SslCert = _sslCa; builder.SslMode = MySqlSslMode.VerifyFull; exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.InvalidSslCertificate, exception.InnerException.Message); builder.SslCert = _sslCert; builder.SslKey = _sslCa; builder.SslMode = MySqlSslMode.VerifyFull; exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.FileIsNotAKey, exception.InnerException.Message); }
public void AttemptConnectionWithDummyPemCertificates() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = _sslCa.Replace("ca.pem", "ca_dummy.pem"); builder.SslMode = MySqlSslMode.VerifyCA; var exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.FileIsNotACertificate, exception.InnerException.Message); builder.SslCa = _sslCa; builder.SslCert = _sslCert.Replace("client-cert.pem", "client-cert_dummy.pem"); builder.SslMode = MySqlSslMode.VerifyFull; exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.FileIsNotACertificate, exception.InnerException.Message); builder.SslCa = _sslCa; builder.SslCert = _sslCert; builder.SslKey = _sslKey.Replace("client-key.pem", "client-key_dummy.pem"); builder.SslMode = MySqlSslMode.VerifyFull; exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.FileIsNotAKey, exception.InnerException.Message); }
public void InvalidFileNameForSslCaConnectionOption() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = "C:\\certs\\ca.pema"; builder.SslMode = MySqlSslMode.VerifyCA; var exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(MySql.Data.Resources.FileNotFound, exception.InnerException.Message); }
public void ConnectUsingCaPemCertificate() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = _sslCa; builder.SslMode = MySqlSslMode.VerifyCA; using (var session = MySQLX.GetSession(builder.ConnectionString)) { session.Close(); } }
public void Bug28151070_5() { Session session = null; session = MySQLX.GetSession(_xConnectionURI); var builder = new MySqlXConnectionStringBuilder(); builder.Auth = MySqlAuthenticationMode.AUTO; builder.SslCa = ""; }
public SslTests() { _sslCa = "ca.pem"; _sslCert = "client-cert.pem"; _sslKey = "client-key.pem"; // Update the port to the default xport. var builder = new MySqlXConnectionStringBuilder(ConnectionString); builder.Port = Convert.ToUInt32(XPort); _connectionString = builder.ConnectionString; }
public void MissingSslCertConnectionOption() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = _sslCa; builder.SslCert = string.Empty; builder.SslMode = MySqlSslMode.VerifyFull; var exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.Equal(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.Equal(string.Format(MySql.Data.Resources.FilePathNotSet, nameof(builder.SslCert)), exception.InnerException.Message); }
public void InvalidFileNameForSslKeyConnectionOption() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = _sslCa; builder.SslCert = _sslCert; builder.SslKey = "file"; builder.SslMode = MySqlSslMode.VerifyFull; var exception = Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); Assert.AreEqual(MySql.Data.Resources.SslConnectionError, exception.Message); Assert.AreEqual(MySql.Data.Resources.FileNotFound, exception.InnerException.Message); }
public void SslCaConnectionOptionsAreIgnoredOnDifferentSslModes() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = "dummy_file"; builder.SslMode = MySqlSslMode.Required; // Connection attempt is successful since SslMode=Preferred causing SslCa to be ignored. using (var session = MySQLX.GetSession(builder.ConnectionString)) { session.Close(); } }
public void ConnectionOptionIsValidUsingBuilder() { var builder = new MySqlXConnectionStringBuilder(ConnectionString); builder.Compression = CompressionType.Preferred; StringAssert.Contains("compression=Preferred", builder.ToString()); builder.Compression = CompressionType.Required; StringAssert.Contains("compression=Required", builder.ToString()); builder.Compression = CompressionType.Disabled; StringAssert.Contains("compression=Disabled", builder.ToString()); }
public void ConnectionAttributes() { if (!(session.Version.isAtLeast(8, 0, 16))) { return; } // Validate that MySQLX.GetSession() supports a new 'connection-attributes' query parameter // with default values and all the client attributes starts with a '_'. TestConnectionAttributes(ConnectionString + ";connection-attributes=true;"); // Validate that no attributes, client or user defined, are sent to server when the value is "false". TestConnectionAttributes(ConnectionString + ";connection-attributes=false;"); // Validate default behavior with different scenarios. TestConnectionAttributes(ConnectionString + ";connection-attributes;"); TestConnectionAttributes(ConnectionString + ";connection-attributes=true;"); // Validate user-defined attributes to be sent to server. Dictionary <string, object> userAttrs = new Dictionary <string, object> { { "foo", "bar" }, { "quua", "qux" }, { "key", null } }; TestConnectionAttributes(ConnectionString + ";connection-attributes=[foo=bar,quua=qux,key]", userAttrs); TestConnectionAttributes(ConnectionStringUri + "?connectionattributes=[foo=bar,quua=qux,key=]", userAttrs); // Errors var ex = Assert.Throws <MySqlException>(() => MySQLX.GetSession(ConnectionString + ";connection-attributes=[_key=value]")); Assert.Equal(ResourcesX.InvalidUserDefinedAttribute, ex.Message); ex = Assert.Throws <MySqlException>(() => MySQLX.GetSession(ConnectionString + ";connection-attributes=123")); Assert.Equal(ResourcesX.InvalidConnectionAttributes, ex.Message); ex = Assert.Throws <MySqlException>(() => MySQLX.GetSession(ConnectionString + ";connection-attributes=[key=value,key=value2]")); Assert.Equal(string.Format(ResourcesX.DuplicateUserDefinedAttribute, "key"), ex.Message); MySqlXConnectionStringBuilder builder = new MySqlXConnectionStringBuilder(); builder.Server = "localhost"; builder.Port = 33060; builder.UserID = "root"; builder.ConnectionAttributes = ";"; ex = Assert.Throws <MySqlException>(() => MySQLX.GetClient(builder.ConnectionString, "{ \"pooling\": { \"enabled\": true } }")); Assert.Equal("The requested value ';' is invalid for the given keyword 'connection-attributes'.", ex.Message); }
public SslTests() { string assemblyPath = TestContext.CurrentContext.TestDirectory; _sslCa = assemblyPath + "\\ca.pem"; _sslCert = assemblyPath + "\\client-cert.pem"; _sslKey = assemblyPath + "\\client-key.pem"; // Update the port to the default xport. var builder = new MySqlXConnectionStringBuilder(ConnectionString); builder.Port = Convert.ToUInt32(XPort); _connectionString = builder.ConnectionString; }
public void ValidateTlsVersionOptionAsString(string options, string result, string error = null) { if (result != null) { MySqlXConnectionStringBuilder builder = new MySqlXConnectionStringBuilder(_connectionString + options); Assert.AreEqual(result, builder.TlsVersion); } else { string info = string.Empty; #if NET48 || NETCOREAPP3_1 info = ", TLSv1.3"; #endif Assert.Throws <ArgumentException>(() => { new MySqlXConnectionStringBuilder(_connectionString + options); }); } }
public void ConnectUsingAllCertificates() { var builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = _sslCa; builder.SslCert = _sslCert; builder.SslKey = _sslKey; builder.SslMode = MySqlSslMode.VerifyFull; using (var session = MySQLX.GetSession(builder.ConnectionString)) { session.Close(); } builder.SslKey = _sslKey.Replace("client-key.pem", "client-key_altered.pem"); Assert.Throws <MySqlException>(() => MySQLX.GetSession(builder.ConnectionString)); }
public void CaseInsensitiveAuthOption() { string[,] values = new string[, ] { { "PLAIN", "plain", "PLAin", "PlaIn" }, { "MYSQL41", "MySQL41", "mysql41", "mYSqL41" }, { "EXTERNAL", "external", "exterNAL", "eXtERNal" } }; for (int i = 0; i < values.GetLength(0); i++) { for (int j = 0; j < values.GetLength(1); j++) { var builder = new MySqlXConnectionStringBuilder(String.Format("server=localhost;auth={0}", values[i, j])); Assert.AreEqual((MySqlAuthenticationMode)(i + 1), builder.Auth); } } }
public void ConnectAsLocalUser() { var builder = new MySqlXConnectionStringBuilder(); builder.UserID = MYSQL_ROOT_USER; builder.Server = MYSQL_HOST_NAME; builder.Port = Convert.ToUInt32(MYSQL_SERVER_PORT); builder.SshHostName = SSH_HOST_NAME; builder.SshUserName = SSH_USER_NAME; builder.SshPassword = SSH_PASSWORD; builder.SshPort = SSH_PORT; ValidateConnection(builder.ConnectionString); builder.Server = "127.0.0.1"; ValidateConnection(builder.ConnectionString); builder.Server = "::1"; ValidateConnection(builder.ConnectionString); }
public void DnsSrvConnectionAnonymousTypeInvalidConfiguration() { var sb = new MySqlXConnectionStringBuilder(); sb.DnsSrv = true; sb.Port = 3306; sb.Server = "localhost"; var exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(sb.ConnectionString)); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionPort, exception.Message); exception = Assert.Throws <ArgumentException>(() => MySQLX.GetClient(sb.ConnectionString, new { pooling = new { enabled = true } })); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionPort, exception.Message); sb = new MySqlXConnectionStringBuilder(); sb.DnsSrv = true; sb.Server = "localhost, 10.10.10.10"; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(sb.ConnectionString)); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionMultihost, exception.Message); exception = Assert.Throws <ArgumentException>(() => MySQLX.GetClient(sb.ConnectionString, new { pooling = new { enabled = true } })); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionMultihost, exception.Message); sb = new MySqlXConnectionStringBuilder(); sb.DnsSrv = true; sb.Server = "(address=localhost,priority=100), (address=10.10.10.10,priority=90)"; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetSession(sb.ConnectionString)); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionMultihost, exception.Message); var connDataHost = new { server = "(address=localhost,priority=100), (address=10.10.10.10,priority=90)", dnssrv = true }; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetClient(connDataHost, new { pooling = new { enabled = true } })); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionMultihost, exception.Message); var connDataPort = new { server = "localhost", port = 33060, dnssrv = true }; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetClient(connDataPort, new { pooling = new { enabled = true } })); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionPort, exception.Message); var connDataUnix = new { server = "localhost", protocol = "unix", dnssrv = true }; exception = Assert.Throws <ArgumentException>(() => MySQLX.GetClient(connDataUnix, new { pooling = new { enabled = true } })); Assert.AreEqual(MySql.Data.Resources.DnsSrvInvalidConnOptionUnixSocket, exception.Message); }
public void SslCertificateConnectionOptionsExistAndDefaultToNull() { var builder = new MySqlXConnectionStringBuilder(); // Options exist. Assert.True(builder.values.ContainsKey("sslca")); Assert.True(builder.values.ContainsKey("sslcert")); Assert.True(builder.values.ContainsKey("sslkey")); // Options default to null. Assert.Null(builder["sslca"]); Assert.Null(builder["sslcert"]); Assert.Null(builder["sslkey"]); Assert.Null(builder["ssl-ca"]); Assert.Null(builder["ssl-cert"]); Assert.Null(builder["ssl-key"]); Assert.Null(builder.SslCa); Assert.Null(builder.SslCert); Assert.Null(builder.SslKey); // Null or whitespace options are ignored. builder = new MySqlXConnectionStringBuilder(_connectionString); builder.SslCa = null; builder.SslCert = string.Empty; builder.SslKey = " "; using (var session = MySQLX.GetSession(builder.ConnectionString)) { Assert.Null(session.Settings.SslCa); Assert.Null(session.Settings.SslCert); Assert.Equal(" ", session.Settings.SslKey); session.Close(); } // Failing to provide a value defaults to null. using (var session = MySQLX.GetSession($"{_connectionString};sslca=;sslcert=;sslkey=")) { Assert.Null(session.Settings.SslCa); Assert.Null(session.Settings.SslCert); Assert.Null(session.Settings.SslKey); session.Close(); } }
public void ConnectionOptionIsValidUsingConnectionString() { var builder = new MySqlXConnectionStringBuilder("server=localhost;port=33060;compression=PreFerRed"); Assert.AreEqual(CompressionType.Preferred, builder.Compression); builder = new MySqlXConnectionStringBuilder("server=localhost;port=33060;compression=required"); Assert.AreEqual(CompressionType.Required, builder.Compression); builder = new MySqlXConnectionStringBuilder("server=localhost;port=33060;compression=DISABLED"); Assert.AreEqual(CompressionType.Disabled, builder.Compression); // Test whitespace builder = new MySqlXConnectionStringBuilder("server=localhost;port=33060;compression= required"); Assert.AreEqual(CompressionType.Required, builder.Compression); builder = new MySqlXConnectionStringBuilder("server=localhost;port=33060;compression= required"); Assert.AreEqual(CompressionType.Required, builder.Compression); builder = new MySqlXConnectionStringBuilder("server=localhost;port=33060;compression= required "); Assert.AreEqual(CompressionType.Required, builder.Compression); }
public void PreferredIsTheDefaultValue() { var builder = new MySqlXConnectionStringBuilder(); Assert.AreEqual(CompressionType.Preferred, builder.Compression); // Empty value is ignored. var updatedConnectionStringUri = ConnectionStringUri + "?compression="; using (var session = MySQLX.GetSession(updatedConnectionStringUri)) { Assert.AreEqual(CompressionType.Preferred, session.Settings.Compression); session.Close(); } // Whitespace is ignored. updatedConnectionStringUri = ConnectionStringUri + "?compression= "; using (var session = MySQLX.GetSession(updatedConnectionStringUri)) { Assert.AreEqual(CompressionType.Preferred, session.Settings.Compression); session.Close(); } }
public static InternalSession GetSession(MySqlXConnectionStringBuilder settings) { InternalSession session = new XInternalSession(settings); int count = 0; do { try { session.Open(); SetDefaultCollation(session, settings.CharacterSet); break; } catch (IOException ex) { // Retry SSL connection (manual fallback). if (count++ >= 5) { throw new MySqlException(ResourcesX.UnableToOpenSession, ex); } } } while (true); return(session); }
public void ValidateTlsVersionOptionAndSslMode(MySqlSslMode?sslMode1, string options, string result, MySqlSslMode?sslMode2) { MySqlXConnectionStringBuilder builder = new MySqlXConnectionStringBuilder(_connectionString); if (sslMode1.HasValue) { builder.SslMode = sslMode1.Value; } if (result != null) { builder.TlsVersion = options; Assert.AreEqual(result, builder.TlsVersion); } else { Assert.Throws <ArgumentException>(() => { builder.TlsVersion = options; }); } if (sslMode2.HasValue) { Assert.Throws <ArgumentException>(() => { builder.SslMode = sslMode2.Value; }); } }
public XInternalSession(MySqlXConnectionStringBuilder settings) : base(settings) { }
public ExternalAuthenticationPlugin(MySqlXConnectionStringBuilder settings) { _settings = settings; }
// WL-14001 XProtocol -- support for configurable compression algorithms public void ConfigurableCompressionAlgorithms() { bool success = true; try { ExecuteSqlAsRoot(@"SET GLOBAL mysqlx_compression_algorithms = ""ZSTD_STREAM,LZ4_MESSAGE,DEFLATE_STREAM"" "); // FR1_1 Create session with option compression-algorithms for URI, connectionstring, anonymous object, MySqlXConnectionStringBuilder. using (var session = MySQLX.GetSession(ConnectionStringUri + "?compression-algorithms=lz4_message;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression-algorithms=lz4_message;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } #if NET452 // No exception expected due to compression=preferred, no compression expected using (var session = MySQLX.GetSession(new { server = "localhost", port = $"{XPort}", uid = "test", password = "******", compressionalgorithms = "deflate_stream" })) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } #else using (var session = MySQLX.GetSession(new { server = "localhost", port = 33060, uid = "test", password = "******", compressionalgorithms = "deflate_stream" })) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); StringAssert.AreEqualIgnoringCase(CompressionAlgorithms.deflate_stream.ToString(), compressionAlgorithm); } #endif var sb = new MySqlXConnectionStringBuilder("server=localhost;port=33060;uid=test;password=test;compression-algorithms=lz4_message"); using (var session = MySQLX.GetSession(sb.GetConnectionString(true))) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } // FR1_2 Create session with option compression-algorithms and set the option with no value either by not including the property in the connection string // or by setting it with an empty value. using (var session = MySQLX.GetSession("server=localhost;port=33060;uid=test;password=test;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.zstd_stream.ToString(), compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression-algorithms=")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.zstd_stream.ToString(), compressionAlgorithm); } // FR2_1,FR2_2 Create session with option compression-algorithms and set the value with multiple compression algorithms for // URI,connectionstring,anonymous object,MySqlXConnectionStringBuilder.check that the negotiation happens in the order provided in the connection string using (var session = MySQLX.GetSession(ConnectionStringUri + "?compression-algorithms=lz4_message,zstd_stream,deflate_stream;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression-algorithms=lz4_message,zstd_stream,deflate_stream;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } #if NET452 // No exception expected due to compression=preferred, lz4_message compression expected using (var session = MySQLX.GetSession(new { server = "localhost", port = $"{XPort}", uid = "test", password = "******", compressionalgorithms = "deflate_stream,lz4_message,zstd_stream" })) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } #else using (var session = MySQLX.GetSession(new { server = "localhost", port = 33060, uid = "test", password = "******", compressionalgorithms = "deflate_stream,lz4_message,zstd_stream" })) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); StringAssert.AreEqualIgnoringCase(CompressionAlgorithms.deflate_stream.ToString(), compressionAlgorithm); } #endif sb = new MySqlXConnectionStringBuilder(ConnectionString + ";compression-algorithms=lz4_message,zstd_stream,deflate_stream"); using (var session = MySQLX.GetSession(sb.GetConnectionString(true))) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } // FR3 Create session with option compression-algorithms and set the option with Algorithm aliases lz4, zstd, and deflate. using (var session = MySQLX.GetSession(ConnectionString + ";compression-algorithms=lz4,zstd,deflate;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionStringUri + "?compression-algorithms=ZSTD,deflate_stream")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.zstd_stream.ToString(), compressionAlgorithm); } // FR4_1 Create session with option compression-algorithms.Set the option with unsupported and supported algorithms by client. using (var session = MySQLX.GetSession(ConnectionString + ";compression=required;compression-algorithms=NotSupported,lz4,SomethingElse;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionStringUri + "?compression-algorithms=ZSTD,NotSupported")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.zstd_stream.ToString(), compressionAlgorithm); } sb = new MySqlXConnectionStringBuilder("server=localhost;port=33060;uid=test;password=test;compression-algorithms=[NotValid,INVALID,NOTSUPPORTED,zstd]"); using (var session = MySQLX.GetSession(sb.GetConnectionString(true))) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.zstd_stream.ToString(), compressionAlgorithm); } // FR4_2 Create session and set invalid values to the compression-algorithm option to check if the connection is uncompressed when // compression option is either not set or set to preferred or disabled. using (var session = MySQLX.GetSession(ConnectionString + ";compression-algorithms=NotSupported,SomethingElse;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression=disabled;compression-algorithms=lz4,NotSupported,SomethingElse;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression=preferred;compression-algorithms=[NotSupported,SomethingElse];")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } // FR4_3 Create session and set invalid values to the compression-algorithm option. // The connection should terminate with an error when compression option is set to required. Exception ex = Assert.Throws <System.NotSupportedException>(() => MySQLX.GetSession(ConnectionString + ";compression=required;compression-algorithms=NotSupported,SomethingElse;")); Assert.AreEqual("Compression requested but the compression algorithm negotiation failed.", ex.Message); // FR4_4 Start server with specific compression algorithm and create session with option // compression-algorithms.Set the option with multiple compression algorithms. ExecuteSqlAsRoot($"SET GLOBAL mysqlx_compression_algorithms = \"{CompressionAlgorithms.lz4_message.ToString().ToUpperInvariant()}\""); using (var session = MySQLX.GetSession(ConnectionString + ";compression=preferred;compression-algorithms=[lz4_message,deflate,zstd];")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } // FR4_5 Start the server with a specific compression algorithm and use some other in the client and when compression option is either // not set or set to preferred or disabled.Verify that the connection is uncompressed. ExecuteSqlAsRoot($"SET GLOBAL mysqlx_compression_algorithms = \"{CompressionAlgorithms.zstd_stream.ToString().ToUpperInvariant()}\""); using (var session = MySQLX.GetSession(ConnectionString + ";compression-algorithms=[lz4_message]")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression=preferred;compression-algorithms=[lz4_message]")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } using (var session = MySQLX.GetSession(ConnectionString + ";compression=disabled;compression-algorithms=[lz4_message]")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); } //FR4_6,FR_5 Start the server with a specific compression algorithm and use some other in the client and when compression option is set to required.Verify the behaviour ExecuteSqlAsRoot(@"SET GLOBAL mysqlx_compression_algorithms = ""LZ4_MESSAGE"" "); using (var session = MySQLX.GetSession(ConnectionString + ";compression=required;")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); var ele = new List <object>(); for (int i = 0; i < 1000; i++) { ele.Add(new { id = $"{i}", title = $"Book {i}" }); } //Verify compression is being done Collection coll = CreateCollection("testcompress1"); var result = ExecuteAddStatement(coll.Add(ele.ToArray())); var result1 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_sent_uncompressed_frame' ").Execute().FetchOne()[1]; var result2 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_received_uncompressed_frame' ").Execute().FetchOne()[1]; Assert.Greater(int.Parse(result1.ToString()), int.Parse(result2.ToString())); var result3 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_sent_compressed_payload' ").Execute().FetchOne()[1]; var result4 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_received_compressed_payload' ").Execute().FetchOne()[1]; Assert.Greater(int.Parse(result3.ToString()), int.Parse(result4.ToString())); } using (var session = MySQLX.GetSession(ConnectionString + ";compression=required;compression-algorithms=[lz4_message]")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.AreEqual(CompressionAlgorithms.lz4_message.ToString(), compressionAlgorithm); } // Server algorithm not contain user defined algorithm, with compression preferred using (var session = MySQLX.GetSession(ConnectionStringUri + "?compression-algorithms=[zstd];")) { var compressionAlgorithm = session.XSession.GetCompressionAlgorithm(true); Assert.IsNull(compressionAlgorithm); var ele = new List <object>(); for (int i = 0; i < 1000; i++) { ele.Add(new { id = $"{i}", title = $"Book {i}" }); } //Verify there is no compression Collection coll = CreateCollection("testcompress2"); var result = ExecuteAddStatement(coll.Add(ele.ToArray())); var result1 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_sent_uncompressed_frame' ").Execute().FetchOne()[1]; var result2 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_received_uncompressed_frame' ").Execute().FetchOne()[1]; Assert.AreEqual(result1, result2); var result3 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_sent_compressed_payload' ").Execute().FetchOne()[1]; var result4 = session.SQL("select * from performance_schema.session_status where variable_name='Mysqlx_bytes_received_compressed_payload' ").Execute().FetchOne()[1]; Assert.AreEqual(result3, result4); } Exception ex_args = Assert.Throws <System.ArgumentException>(() => MySQLX.GetSession(ConnectionString + ";compression=required;compression_algorithms=[lz4_message]")); StringAssert.Contains("Option not supported", ex_args.Message); } catch (Exception ex) { success = false; } finally { // This line ensures that the list of supported compression algorithms is set to its default value. ExecuteSqlAsRoot(@"SET GLOBAL mysqlx_compression_algorithms = ""ZSTD_STREAM,LZ4_MESSAGE,DEFLATE_STREAM"" "); Assert.True(success); } }
public PlainAuthenticationPlugin(MySqlXConnectionStringBuilder settings) { _settings = settings; }
public RoutingServiceBase(MySqlXConnectionStringBuilder settings) { this.settings = settings; }