public void SSLCertificateValidationError(bool isCertValidationSucceeded)
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var options = new ConfigurationOptions();
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
options.Ssl = true;
options.Password = TestConfig.Current.AzureCachePassword;
options.CertificateValidation += (sender, cert, chain, errors) => isCertValidationSucceeded;
options.AbortOnConnectFail = false;
using (var connection = ConnectionMultiplexer.Connect(options))
{
connection.ConnectionFailed += (object sender, ConnectionFailedEventArgs e) =>
Assert.Equal(ConnectionFailureType.AuthenticationFailure, e.FailureType);
if (!isCertValidationSucceeded)
{
//validate that in this case it throws an certificatevalidation exception
var ex = Assert.Throws <RedisConnectionException>(() => connection.GetDatabase().Ping());
var rde = (RedisConnectionException)ex.InnerException;
Assert.Equal(ConnectionFailureType.AuthenticationFailure, rde.FailureType);
Assert.Equal("The remote certificate is invalid according to the validation procedure.", rde.InnerException.Message);
}
else
{
connection.GetDatabase().Ping();
}
//wait for a second for connectionfailed event to fire
Thread.Sleep(1000);
}
}
public async Task AzureRedisEventsAutomaticSubscribe()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
bool didUpdate = false;
var options = new ConfigurationOptions()
{
EndPoints = { TestConfig.Current.AzureCacheServer },
Password = TestConfig.Current.AzureCachePassword,
Ssl = true
};
using (var connection = await ConnectionMultiplexer.ConnectAsync(options))
{
connection.ServerMaintenanceEvent += (object?_, ServerMaintenanceEvent e) =>
{
if (e is AzureMaintenanceEvent)
{
didUpdate = true;
}
};
var pubSub = connection.GetSubscriber();
await pubSub.PublishAsync("AzureRedisEvents", "HI");
await Task.Delay(100);
Assert.True(didUpdate);
}
}
public void Execute(string config)
{
if (string.IsNullOrEmpty(config))
{
Skip.IfNoConfig(nameof(TestConfig.Config.VPNConfigs), TestConfig.Current.VPNConfigs);
}
for (int i = 0; i < 50; i++)
{
var log = new StringWriter();
try
{
var options = ConfigurationOptions.Parse(config);
options.SyncTimeout = 3000;
options.ConnectRetry = 5;
using (var conn = ConnectionMultiplexer.Connect(options, log))
{
var ttl = conn.GetDatabase().Ping();
Output.WriteLine(ttl.ToString());
}
}
catch
{
Output.WriteLine(log.ToString());
throw;
}
Output.WriteLine("");
Output.WriteLine("===");
Output.WriteLine("");
}
}
public Sentinel(ITestOutputHelper output) : base(output)
{
ConnectionLog = new StringWriter();
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelServer), TestConfig.Current.SentinelServer);
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelSeviceName), TestConfig.Current.SentinelSeviceName);
var options = ServiceOptions.Clone();
options.EndPoints.Add(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortA);
options.EndPoints.Add(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortB);
options.EndPoints.Add(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortC);
Conn = ConnectionMultiplexer.SentinelConnect(options, ConnectionLog);
for (var i = 0; i < 150; i++)
{
Thread.Sleep(20);
if (Conn.IsConnected && Conn.GetSentinelMasterConnection(options).IsConnected)
{
break;
}
}
Assert.True(Conn.IsConnected);
SentinelServerA = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortA);
SentinelServerB = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortB);
SentinelServerC = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortC);
SentinelsServers = new[] { SentinelServerA, SentinelServerB, SentinelServerC };
// wait until we are in a state of a single master and replica
WaitForReady();
}
public async Task AuthenticationFailureError()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
var options = new ConfigurationOptions();
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
options.Ssl = true;
options.Password = "";
options.AbortOnConnectFail = false;
options.CertificateValidation += SSL.ShowCertFailures(Writer);
using (var muxer = ConnectionMultiplexer.Connect(options))
{
muxer.ConnectionFailed += (sender, e) =>
{
if (e.FailureType == ConnectionFailureType.SocketFailure)
{
Skip.Inconclusive("socket fail"); // this is OK too
}
Assert.Equal(ConnectionFailureType.AuthenticationFailure, e.FailureType);
};
var ex = Assert.Throws <RedisConnectionException>(() => muxer.GetDatabase().Ping());
Assert.NotNull(ex.InnerException);
var rde = Assert.IsType <RedisConnectionException>(ex.InnerException);
Assert.Equal(CommandStatus.WaitingToBeSent, ex.CommandStatus);
Assert.Equal(ConnectionFailureType.AuthenticationFailure, rde.FailureType);
Assert.Equal("Error: NOAUTH Authentication required. Verify if the Redis password provided is correct.", rde.InnerException.Message);
//wait for a second for connectionfailed event to fire
await Task.Delay(1000).ForAwait();
}
}
public Sentinel(ITestOutputHelper output) : base(output)
{
ConnectionLog = new StringWriter();
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelServer), TestConfig.Current.SentinelServer);
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelSeviceName), TestConfig.Current.SentinelSeviceName);
var options = new ConfigurationOptions()
{
CommandMap = CommandMap.Sentinel,
EndPoints =
{
{ TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort },
{ TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort1 },
{ TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort2 }
},
AllowAdmin = true,
TieBreaker = "",
ServiceName = TestConfig.Current.SentinelSeviceName,
SyncTimeout = 5000
};
Conn = ConnectionMultiplexer.Connect(options, ConnectionLog);
Thread.Sleep(3000);
Assert.True(Conn.IsConnected);
Server26379 = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort);
Server26380 = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort1);
Server26381 = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort2);
SentinelsServers = new IServer[] { Server26379, Server26380, Server26381 };
}
[InlineData(6380, true)] // all explicit
// (note the 6379 port is closed)
public void ConnectToAzure(int?port, bool ssl)
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var options = new ConfigurationOptions();
options.CertificateValidation += ShowCertFailures(Writer);
if (port == null)
{
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
}
else
{
options.EndPoints.Add(TestConfig.Current.AzureCacheServer, port.Value);
}
options.Ssl = ssl;
options.Password = TestConfig.Current.AzureCachePassword;
Log(options.ToString());
using (var connection = ConnectionMultiplexer.Connect(options))
{
var ttl = connection.GetDatabase().Ping();
Log(ttl.ToString());
}
}
public void RedisLabsSSL()
{
Skip.IfNoConfig(nameof(TestConfig.Config.RedisLabsSslServer), TestConfig.Current.RedisLabsSslServer);
Skip.IfNoConfig(nameof(TestConfig.Config.RedisLabsPfxPath), TestConfig.Current.RedisLabsPfxPath);
var cert = new X509Certificate2(TestConfig.Current.RedisLabsPfxPath, "");
Assert.NotNull(cert);
Writer.WriteLine("Thumbprint: " + cert.Thumbprint);
int timeout = 5000;
if (Debugger.IsAttached)
{
timeout *= 100;
}
var options = new ConfigurationOptions
{
EndPoints = { { TestConfig.Current.RedisLabsSslServer, TestConfig.Current.RedisLabsSslPort } },
ConnectTimeout = timeout,
AllowAdmin = true,
CommandMap = CommandMap.Create(new HashSet <string> {
"subscribe", "unsubscribe", "cluster"
}, false)
};
options.TrustIssuer("redislabs_ca.pem");
if (!Directory.Exists(Me()))
{
Directory.CreateDirectory(Me());
}
#if LOGOUTPUT
ConnectionMultiplexer.EchoPath = Me();
#endif
options.Ssl = true;
options.CertificateSelection += delegate
{
return(cert);
};
RedisKey key = Me();
using (var conn = ConnectionMultiplexer.Connect(options))
{
var db = conn.GetDatabase();
db.KeyDelete(key, CommandFlags.FireAndForget);
string s = db.StringGet(key);
Assert.Null(s);
db.StringSet(key, "abc", flags: CommandFlags.FireAndForget);
s = db.StringGet(key);
Assert.Equal("abc", s);
var latency = db.Ping();
Log("RedisLabs latency: {0:###,##0.##}ms", latency.TotalMilliseconds);
using (var file = File.Create("RedisLabs.zip"))
{
conn.ExportConfiguration(file);
}
}
}
public void SSLParseViaConfig_Issue883_ConfigString()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var configString = $"{TestConfig.Current.AzureCacheServer}:6380,password={TestConfig.Current.AzureCachePassword},connectRetry=3,connectTimeout=5000,syncTimeout=5000,defaultDatabase=0,ssl=true,abortConnect=false";
var options = ConfigurationOptions.Parse(configString);
options.CertificateValidation += ShowCertFailures(Writer);
using (var conn = ConnectionMultiplexer.Connect(options))
{
conn.GetDatabase().Ping();
}
}
public void AbortOnConnectFailFalseConnectTimeoutError()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var options = new ConfigurationOptions();
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
options.Ssl = true;
options.ConnectTimeout = 0;
options.Password = TestConfig.Current.AzureCachePassword;
using (var muxer = ConnectionMultiplexer.Connect(options))
{
var ex = Assert.Throws <RedisConnectionException>(() => muxer.GetDatabase().Ping());
Assert.Contains("ConnectTimeout", ex.Message);
}
}
public async Task SSLCertificateValidationError(bool isCertValidationSucceeded)
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var options = new ConfigurationOptions();
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
options.Ssl = true;
options.Password = TestConfig.Current.AzureCachePassword;
options.CertificateValidation += (sender, cert, chain, errors) => isCertValidationSucceeded;
options.AbortOnConnectFail = false;
using (var connection = ConnectionMultiplexer.Connect(options))
{
await RunBlockingSynchronousWithExtraThreadAsync(innerScenario).ForAwait();
void innerScenario()
{
connection.ConnectionFailed += (sender, e) =>
Assert.Equal(ConnectionFailureType.AuthenticationFailure, e.FailureType);
if (!isCertValidationSucceeded)
{
//validate that in this case it throws an certificatevalidation exception
var outer = Assert.Throws <RedisConnectionException>(() => connection.GetDatabase().Ping());
Assert.Equal(ConnectionFailureType.UnableToResolvePhysicalConnection, outer.FailureType);
Assert.NotNull(outer.InnerException);
var inner = Assert.IsType <RedisConnectionException>(outer.InnerException);
Assert.Equal(ConnectionFailureType.AuthenticationFailure, inner.FailureType);
Assert.NotNull(inner.InnerException);
var innerMost = Assert.IsType <AuthenticationException>(inner.InnerException);
Assert.Equal("The remote certificate is invalid according to the validation procedure.", innerMost.Message);
}
else
{
connection.GetDatabase().Ping();
}
}
// wait for a second for connectionfailed event to fire
await Task.Delay(1000).ForAwait();
}
}
public void ConnectToSSDB()
{
Skip.IfNoConfig(nameof(TestConfig.Config.SSDBServer), TestConfig.Current.SSDBServer);
var config = new ConfigurationOptions
{
EndPoints = { { TestConfig.Current.SSDBServer, TestConfig.Current.SSDBPort } },
CommandMap = CommandMap.SSDB
};
RedisKey key = Me();
using (var conn = ConnectionMultiplexer.Connect(config))
{
var db = conn.GetDatabase(0);
db.KeyDelete(key);
Assert.True(db.StringGet(key).IsNull);
db.StringSet(key, "abc");
Assert.Equal("abc", db.StringGet(key));
}
}
private ConnectionMultiplexer Create()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var options = new ConfigurationOptions();
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
options.Ssl = true;
options.ConnectTimeout = 5000;
options.Password = TestConfig.Current.AzureCachePassword;
options.TieBreaker = "";
var log = new StringWriter();
var conn = ConnectionMultiplexer.Connect(options, log);
var s = log.ToString();
Output.WriteLine(s);
Skip.IfMissingFeature(conn, nameof(RedisFeatures.Geo), r => r.Geo);
return(conn);
}
public Sentinel(ITestOutputHelper output)
{
Output = output;
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelServer), TestConfig.Current.SentinelServer);
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelSeviceName), TestConfig.Current.SentinelSeviceName);
var options = new ConfigurationOptions()
{
CommandMap = CommandMap.Sentinel,
EndPoints = { { TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort } },
AllowAdmin = true,
TieBreaker = "",
ServiceName = TestConfig.Current.SentinelSeviceName,
SyncTimeout = 5000
};
Conn = ConnectionMultiplexer.Connect(options, Console.Out);
Thread.Sleep(3000);
Assert.True(Conn.IsConnected);
Server = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPort);
}
public void AuthenticationFailureError()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
var options = new ConfigurationOptions();
options.EndPoints.Add(TestConfig.Current.AzureCacheServer);
options.Ssl = true;
options.Password = "";
options.AbortOnConnectFail = false;
using (var muxer = ConnectionMultiplexer.Connect(options))
{
muxer.ConnectionFailed += (object sender, ConnectionFailedEventArgs e) =>
Assert.Equal(ConnectionFailureType.AuthenticationFailure, e.FailureType);
var ex = Assert.Throws <RedisConnectionException>(() => muxer.GetDatabase().Ping());
var rde = (RedisConnectionException)ex.InnerException;
Assert.Equal(CommandStatus.WaitingToBeSent, ex.CommandStatus);
Assert.Equal(ConnectionFailureType.AuthenticationFailure, rde.FailureType);
Assert.Equal("Error: NOAUTH Authentication required. Verify if the Redis password provided is correct.", rde.InnerException.Message);
//wait for a second for connectionfailed event to fire
Thread.Sleep(1000);
}
}
public void SSLParseViaConfig_Issue883_ConfigObject()
{
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCacheServer), TestConfig.Current.AzureCacheServer);
Skip.IfNoConfig(nameof(TestConfig.Config.AzureCachePassword), TestConfig.Current.AzureCachePassword);
var options = new ConfigurationOptions
{
AbortOnConnectFail = false,
Ssl = true,
ConnectRetry = 3,
ConnectTimeout = 5000,
SyncTimeout = 5000,
DefaultDatabase = 0,
EndPoints = { { TestConfig.Current.AzureCacheServer, 6380 } },
Password = TestConfig.Current.AzureCachePassword
};
options.CertificateValidation += ShowCertFailures(Writer);
using (var conn = ConnectionMultiplexer.Connect(options))
{
conn.GetDatabase().Ping();
}
}
public Sentinel(ITestOutputHelper output) : base(output)
{
ConnectionLog = new StringWriter();
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelServer), TestConfig.Current.SentinelServer);
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelSeviceName), TestConfig.Current.SentinelSeviceName);
var options = new ConfigurationOptions()
{
CommandMap = CommandMap.Sentinel,
EndPoints =
{
{ TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortA },
{ TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortB },
{ TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortC }
},
AllowAdmin = true,
TieBreaker = "",
ServiceName = TestConfig.Current.SentinelSeviceName,
SyncTimeout = 5000
};
Conn = ConnectionMultiplexer.Connect(options, ConnectionLog);
for (var i = 0; i < 150; i++)
{
Thread.Sleep(20);
if (Conn.IsConnected && Conn.GetSentinelMasterConnection(ServiceOptions).IsConnected)
{
break;
}
}
Assert.True(Conn.IsConnected);
SentinelServerA = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortA);
SentinelServerB = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortB);
SentinelServerC = Conn.GetServer(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortC);
SentinelsServers = new IServer[] { SentinelServerA, SentinelServerB, SentinelServerC };
}
public SentinelBase(ITestOutputHelper output) : base(output)
{
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelServer), TestConfig.Current.SentinelServer);
Skip.IfNoConfig(nameof(TestConfig.Config.SentinelSeviceName), TestConfig.Current.SentinelSeviceName);
}
public void RedisLabsEnvironmentVariableClientCertificate(bool setEnv)
{
try
{
Skip.IfNoConfig(nameof(TestConfig.Config.RedisLabsSslServer), TestConfig.Current.RedisLabsSslServer);
Skip.IfNoConfig(nameof(TestConfig.Config.RedisLabsPfxPath), TestConfig.Current.RedisLabsPfxPath);
if (setEnv)
{
Environment.SetEnvironmentVariable("SERedis_ClientCertPfxPath", TestConfig.Current.RedisLabsPfxPath);
Environment.SetEnvironmentVariable("SERedis_IssuerCertPath", "redislabs_ca.pem");
// check env worked
Assert.Equal(TestConfig.Current.RedisLabsPfxPath, Environment.GetEnvironmentVariable("SERedis_ClientCertPfxPath"));
Assert.Equal("redislabs_ca.pem", Environment.GetEnvironmentVariable("SERedis_IssuerCertPath"));
}
int timeout = 5000;
if (Debugger.IsAttached)
{
timeout *= 100;
}
var options = new ConfigurationOptions
{
EndPoints = { { TestConfig.Current.RedisLabsSslServer, TestConfig.Current.RedisLabsSslPort } },
ConnectTimeout = timeout,
AllowAdmin = true,
CommandMap = CommandMap.Create(new HashSet <string> {
"subscribe", "unsubscribe", "cluster"
}, false)
};
if (!Directory.Exists(Me()))
{
Directory.CreateDirectory(Me());
}
#if LOGOUTPUT
ConnectionMultiplexer.EchoPath = Me();
#endif
options.Ssl = true;
RedisKey key = Me();
using (var conn = ConnectionMultiplexer.Connect(options))
{
if (!setEnv)
{
Assert.True(false, "Could not set environment");
}
var db = conn.GetDatabase();
db.KeyDelete(key, CommandFlags.FireAndForget);
string s = db.StringGet(key);
Assert.Null(s);
db.StringSet(key, "abc");
s = db.StringGet(key);
Assert.Equal("abc", s);
var latency = db.Ping();
Log("RedisLabs latency: {0:###,##0.##}ms", latency.TotalMilliseconds);
using (var file = File.Create("RedisLabs.zip"))
{
conn.ExportConfiguration(file);
}
}
}
catch (RedisConnectionException ex)
{
if (setEnv || ex.FailureType != ConnectionFailureType.UnableToConnect)
{
throw;
}
}
finally
{
Environment.SetEnvironmentVariable("SERedis_ClientCertPfxPath", null);
}
}
public async Task ConnectToSSLServer(bool useSsl, bool specifyHost)
{
var server = TestConfig.Current.SslServer;
int? port = TestConfig.Current.SslPort;
string password = "";
bool isAzure = false;
if (string.IsNullOrWhiteSpace(server) && useSsl)
{
// we can bounce it past azure instead?
server = TestConfig.Current.AzureCacheServer;
password = TestConfig.Current.AzureCachePassword;
port = null;
isAzure = true;
}
Skip.IfNoConfig(nameof(TestConfig.Config.SslServer), server);
var config = new ConfigurationOptions
{
AllowAdmin = true,
SyncTimeout = Debugger.IsAttached ? int.MaxValue : 5000,
Password = password,
};
var map = new Dictionary <string, string>
{
["config"] = null // don't rely on config working
};
if (!isAzure)
{
map["cluster"] = null;
}
config.CommandMap = CommandMap.Create(map);
if (port != null)
{
config.EndPoints.Add(server, port.Value);
}
else
{
config.EndPoints.Add(server);
}
if (useSsl)
{
config.Ssl = useSsl;
if (specifyHost)
{
config.SslHost = server;
}
config.CertificateValidation += (sender, cert, chain, errors) =>
{
Log("errors: " + errors);
Log("cert issued to: " + cert.Subject);
return(true); // fingers in ears, pretend we don't know this is wrong
};
}
var configString = config.ToString();
Log("config: " + configString);
var clone = ConfigurationOptions.Parse(configString);
Assert.Equal(configString, clone.ToString());
using (var log = new StringWriter())
using (var muxer = ConnectionMultiplexer.Connect(config, log))
{
Log("Connect log:");
lock (log)
{
Log(log.ToString());
}
Log("====");
muxer.ConnectionFailed += OnConnectionFailed;
muxer.InternalError += OnInternalError;
var db = muxer.GetDatabase();
await db.PingAsync().ForAwait();
using (var file = File.Create("ssl-" + useSsl + "-" + specifyHost + ".zip"))
{
muxer.ExportConfiguration(file);
}
RedisKey key = "SE.Redis";
const int AsyncLoop = 2000;
// perf; async
await db.KeyDeleteAsync(key).ForAwait();
var watch = Stopwatch.StartNew();
for (int i = 0; i < AsyncLoop; i++)
{
try
{
await db.StringIncrementAsync(key, flags : CommandFlags.FireAndForget).ForAwait();
}
catch (Exception ex)
{
Log($"Failure on i={i}: {ex.Message}");
throw;
}
}
// need to do this inside the timer to measure the TTLB
long value = (long)await db.StringGetAsync(key).ForAwait();
watch.Stop();
Assert.Equal(AsyncLoop, value);
Log("F&F: {0} INCR, {1:###,##0}ms, {2} ops/s; final value: {3}",
AsyncLoop,
watch.ElapsedMilliseconds,
(long)(AsyncLoop / watch.Elapsed.TotalSeconds),
value);
// perf: sync/multi-threaded
// TestConcurrent(db, key, 30, 10);
//TestConcurrent(db, key, 30, 20);
//TestConcurrent(db, key, 30, 30);
//TestConcurrent(db, key, 30, 40);
//TestConcurrent(db, key, 30, 50);
}
}
public void ConnectToSSLServer(bool useSsl, bool specifyHost)
{
Skip.IfNoConfig(nameof(TestConfig.Config.SslServer), TestConfig.Current.SslServer);
var config = new ConfigurationOptions
{
CommandMap = CommandMap.Create( // looks like "config" is disabled
new Dictionary <string, string>
{
["config"] = null,
["cluster"] = null
}
),
EndPoints = { { TestConfig.Current.SslServer, TestConfig.Current.SslPort } },
AllowAdmin = true,
SyncTimeout = Debugger.IsAttached ? int.MaxValue : 5000
};
if (useSsl)
{
config.Ssl = useSsl;
if (specifyHost)
{
config.SslHost = TestConfig.Current.SslServer;
}
config.CertificateValidation += (sender, cert, chain, errors) =>
{
Output.WriteLine("errors: " + errors);
Output.WriteLine("cert issued to: " + cert.Subject);
return(true); // fingers in ears, pretend we don't know this is wrong
};
}
var configString = config.ToString();
Output.WriteLine("config: " + configString);
var clone = ConfigurationOptions.Parse(configString);
Assert.Equal(configString, clone.ToString());
using (var log = new StringWriter())
using (var muxer = ConnectionMultiplexer.Connect(config, log))
{
Output.WriteLine("Connect log:");
Output.WriteLine(log.ToString());
Output.WriteLine("====");
muxer.ConnectionFailed += OnConnectionFailed;
muxer.InternalError += OnInternalError;
var db = muxer.GetDatabase();
db.Ping();
using (var file = File.Create("ssl-" + useSsl + "-" + specifyHost + ".zip"))
{
muxer.ExportConfiguration(file);
}
RedisKey key = "SE.Redis";
const int AsyncLoop = 2000;
// perf; async
db.KeyDelete(key, CommandFlags.FireAndForget);
var watch = Stopwatch.StartNew();
for (int i = 0; i < AsyncLoop; i++)
{
db.StringIncrement(key, flags: CommandFlags.FireAndForget);
}
// need to do this inside the timer to measure the TTLB
long value = (long)db.StringGet(key);
watch.Stop();
Assert.Equal(AsyncLoop, value);
Output.WriteLine("F&F: {0} INCR, {1:###,##0}ms, {2} ops/s; final value: {3}",
AsyncLoop,
(long)watch.ElapsedMilliseconds,
(long)(AsyncLoop / watch.Elapsed.TotalSeconds),
value);
// perf: sync/multi-threaded
TestConcurrent(db, key, 30, 10);
//TestConcurrent(db, key, 30, 20);
//TestConcurrent(db, key, 30, 30);
//TestConcurrent(db, key, 30, 40);
//TestConcurrent(db, key, 30, 50);
}
}