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;
}
