internal static IRedisClientsManager InitRedisClientManager(string clusterName, string clusterNodes,
string redisConnectionString)
{
lock (SyncObj)
{
if (_redisClientsManager == null)
{
if (string.IsNullOrWhiteSpace(clusterName) ||
string.IsNullOrWhiteSpace(clusterNodes))
{
_redisClientsManager = new RedisManagerPool(redisConnectionString);
}
else
{
var sentinelHosts = clusterNodes.Split(',');
var sentinel = new RedisSentinel(sentinelHosts, clusterName);
sentinel.HostFilter = host => redisConnectionString.Fmt(host);
sentinel.RedisManagerFactory =
(master, slaves) => new PooledRedisClientManager(master, slaves);
_redisClientsManager = sentinel.Start();
}
}
}
return(_redisClientsManager);
}
public void Execute()
{
string AddPassword(string host) => $"password@{host}";
var sentinelHosts = new[] { "127.0.0.1:26380", "127.0.0.1:26381", "127.0.0.1:26382" };
var sentinel = new RedisSentinel(sentinelHosts.Map(AddPassword), masterName: "mymaster")
{
HostFilter = AddPassword,
SentinelHostFilter = AddPassword,
};
var manager = sentinel.Start();
sentinel.OnWorkerError = Console.WriteLine;
while (true)
{
try
{
const string RedisKey = "my Name";
using var client = manager.GetClient();
var result = client.Get <string>(RedisKey);
Console.WriteLine("Redis Key: {0} \t Port: {1}", result, client.Port);
}
catch (Exception ex)
{
Console.WriteLine("Error {0}".Fmt(ex.Message));
}
Thread.Sleep(3000);
}
}
public void Can_connect_to_GoogleCloud_3SentinelSetup()
{
var sentinel = new RedisSentinel(GoogleCloudSentinelHosts, masterName: "master")
{
IpAddressMap = {
{"10.240.34.152", "146.148.77.31"},
{"10.240.203.193","130.211.139.141"},
{"10.240.209.52", "107.178.218.53"},
}
};
var redisManager = sentinel.Start();
using (var client = redisManager.GetClient())
{
"{0}:{1}".Print(client.Host, client.Port);
client.FlushAll();
client.SetEntry("Sentinel3Setup", "GoogleCloud");
var result = client.GetEntry("Sentinel3Setup");
Assert.That(result, Is.EqualTo("GoogleCloud"));
}
using (var readOnly = redisManager.GetReadOnlyClient())
{
"{0}:{1}".Print(readOnly.Host, readOnly.Port);
var result = readOnly.GetEntry("Sentinel3Setup");
Assert.That(result, Is.EqualTo("GoogleCloud"));
}
}
private void Connect()
{
if (_sentinel != null)
{
return;
}
_connectionLock.Wait();
try {
if (_sentinel == null)
{
// sentinel settings
_sentinel = new RedisSentinel(_options.Hosts, _options.MasterGroup)
{
ScanForOtherSentinels = _options.ScanForOtherSentinels,
RedisManagerFactory = (master, slaves) => new RedisManagerPool(master),
// set the client connection string
HostFilter = host => {
var h = String.Empty;
h += String.IsNullOrWhiteSpace(_options.AuthPass) ? "" : $"{_options.AuthPass}@";
h += $"{host}?db=1&RetryTimeout=5000";
return(h);
},
};
// start monitoring
_manager = _sentinel.Start();
}
} finally {
_connectionLock.Release();
}
}
public void Can_Connect_Sentinel_Test()
{
var sentinelHosts = new string[]
{
"10.110.76.178:26379",
};
var sentinel = new RedisSentinel(sentinelHosts, "host6379")
{
OnFailover = manager =>
{
"Redis Managers were Failed Over to new hosts".Print();
},
OnWorkerError = ex =>
{
"Worker error: {0}".Print(ex);
},
OnSentinelMessageReceived = (channel, msg) =>
{
"Received '{0}' on channel '{1}' from Sentinel".Print(channel, msg);
},
//HostFilter = host => $"redis123456@{host}"
HostFilter = host => $"{host}?password=redis123456",
};
var redisManager = sentinel.Start(); // 尝试与哨兵服务器进行通信(检查服务器是否可用)
var redisClient = redisManager.GetClient(); // 尝试连接服务器
var foo2 = redisClient.Get <string>("foo2");
redisClient.Dispose();
Assert.True(foo2 == "f2");
}
public void Disconnect_Test()
{
using (var rcClient = new RedisSentinel(ip, 20002))
{
var info = rcClient.Ping();
}
}
public void Execute()
{
var sentinelHosts = new[] { "127.0.0.1:26380", "127.0.0.1:26381", "127.0.0.1:26382" };
var sentinel = new RedisSentinel(sentinelHosts, masterName: "mymaster");
sentinel.HostFilter = host => "password@{0}".Fmt(host);
var manager = sentinel.Start();
sentinel.OnWorkerError = exception => Console.WriteLine(exception);
while (true)
{
try
{
const string RedisKey = "my Name";
using (var client = manager.GetClient())
{
var result = client.Get <string>(RedisKey);
Console.WriteLine("Redis Key: {0} \t Port: {1}", result, client.Port);
}
}
catch (Exception ex)
{
Console.WriteLine("Error {0}".Fmt(ex.Message));
}
Thread.Sleep(3000);
}
}
public void Disconnect_Test()
{
using (var rcClient = new RedisSentinel(ip, 20002))
{
var info = rcClient.Ping();
}
}
public void Register(IAppHost appHost)
{
var container = appHost.GetContainer();
var appSettings = appHost.AppSettings;
var connections = appSettings.Get <Dictionary <string, string> >("connectionStrings");
#if DEBUG
var sentinelHosts = new[] { connections.GetValueOrDefault("Sentinel0"), connections.GetValueOrDefault("Sentinel1"), connections.GetValueOrDefault("Sentinel2") };
var sentinel = new RedisSentinel(sentinelHosts, masterName: appSettings.GetString("redis.mastername"))
{
RedisManagerFactory = (master, slaves) => new RedisManagerPool(master, new RedisPoolConfig()
{
MaxPoolSize = 20
}),
HostFilter = host => "{0}?db=0".Fmt(host)
};
container.Register <IRedisClientsManager>(c => sentinel.Start());
#else
var redisManager = new RedisManagerPool(connections.GetValueOrDefault("Sentinel0"), new RedisPoolConfig()
{
MaxPoolSize = 20,
});
container.Register <IRedisClientsManager>(c => redisManager);
#endif
}
/// <summary>
/// 创建 Redis 连接池管理对象。
/// </summary>
private static void CreateManager()
{
string[] sentinelServerHosts = SplitServerHosts(_redisConfiguration.SentinelServerHosts, ",");
var redisSentinel = new RedisSentinel(sentinelServerHosts, _redisConfiguration.MasterName);
_redisClientsManager = redisSentinel.Start();
}
private async Task ConnectAsync(CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
if (_sentinel != null)
{
return;
}
await _connectionLock.WaitAsync(token);
try {
if (_sentinel == null)
{
// sentinel settings
_sentinel = new RedisSentinel(_options.Hosts, _options.MasterGroup)
{
ScanForOtherSentinels = _options.ScanForOtherSentinels,
RedisManagerFactory = (master, slaves) => new RedisManagerPool(master),
// set the client connection string
HostFilter = host => {
var h = String.Empty;
h += String.IsNullOrWhiteSpace(_options.AuthPass) ? "" : $"{_options.AuthPass}@";
h += $"{host}?db=1&RetryTimeout=5000";
return(h);
},
};
// start monitoring
_manager = await Task.Run(() => _sentinel.Start()).ConfigureAwait(false);
}
} finally {
_connectionLock.Release();
}
}
public void Ping_Test()
{
using (RedisSentinel rsc = new RedisSentinel(ip, port))
{
var result = rsc.Ping();
Assert.IsTrue(result);
}
}
public void Ping_Test()
{
using (RedisSentinel rsc = new RedisSentinel(ip, port))
{
var result = rsc.Ping();
Assert.IsTrue(result);
}
}
public void Can_Get_Redis_ClientsManager()
{
using (var sentinel = new RedisSentinel(Config.SentinelHosts, Config.SentinelMasterName)) {
var clientsManager = sentinel.Start();
using (var client = clientsManager.GetClient()) {
Assert.That(client.GetHostString(), Is.EqualTo(Config.Sentinel6380));
}
}
}
/// <summary>
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// </summary>
public override void Configure(Container container)
{
var appSettings = new AppSettings();
JsConfig.EmitCamelCaseNames = true;
JsConfig <DateTime> .SerializeFn = dateObj => string.Format("{0:yyyy-MM-ddTHH:mm:ss.000}", dateObj);
JsConfig <TimeSpan> .SerializeFn = timeSpan => string.Format("{0:00}:{1:00}", timeSpan.Hours, timeSpan.Minutes);
JsConfig <DBNull> .SerializeFn = dbNull => string.Empty;
#if DEBUG
var sentinelHosts = new[] { ConfigUtils.GetConnectionString("Sentinel0"), ConfigUtils.GetConnectionString("Sentinel1"), ConfigUtils.GetConnectionString("Sentinel2") };
var sentinel = new RedisSentinel(sentinelHosts, masterName: "mymaster");
sentinel.RedisManagerFactory = (master, slaves) => new RedisManagerPool(master, new RedisPoolConfig()
{
MaxPoolSize = 20
});
sentinel.HostFilter = host => "{0}?db=0".Fmt(host);
container.Register <IRedisClientsManager>(c => sentinel.Start());
#else
var redisManager = new RedisManagerPool(ConfigUtils.GetConnectionString("Sentinel0"), new RedisPoolConfig()
{
MaxPoolSize = 20,
});
container.Register <IRedisClientsManager>(c => redisManager);
#endif
//Configuring
ConfigureDb(container, appSettings);
ConfigureLogging(container, appSettings);
ConfigureAuth(container, appSettings);
ConfigureFilter(container, appSettings);
ConfigureValidation(container, appSettings);
ConfigureExceptionFormat(container, appSettings);
ConfigureConverter(container, appSettings);
//ConfigureGateway(container, appSettings);
SetConfig(new HostConfig
{
HandlerFactoryPath = "api",
//EnableFeatures = Feature.All.Remove(disableFeatures), //all formats except of JSV and SOAP
DebugMode = true, //Show StackTraces in service responses during development
WriteErrorsToResponse = false, //Disable exception handling
DefaultContentType = MimeTypes.Json, //Change default content type
AllowJsonpRequests = true, //Enable JSONP requests
RestrictAllCookiesToDomain = appSettings.GetString("rootDomain")
});
//Plugins
Plugins.Add(new PostmanFeature());
Plugins.Add(new CorsFeature());
Plugins.Add(new ValidationFeature());
Plugins.Add(new CommonFeature());
}
public void Maxclients()
{
for (int i = 0; i < 100; i++)
{
RedisSentinel rsc = new RedisSentinel(ip, port);
var result = rsc.Ping();
Assert.IsTrue(result);
}
}
protected override RedisSentinel CreateSentinel()
{
var sentinel = new RedisSentinel(SentinelHosts)
{
IpAddressMap =
{
{ "127.0.0.1", "10.0.0.9" },
}
};
return(sentinel);
}
public void Maxclients()
{
for (int i = 0; i < 100; i++)
{
RedisSentinel rsc = new RedisSentinel(ip, port);
var result = rsc.Ping();
Assert.IsTrue(result);
}
}
public void Can_specify_db_on_RedisSentinel()
{
using (var sentinel = new RedisSentinel(Config.SentinelHosts, Config.SentinelMasterName)) {
sentinel.HostFilter = host => string.Format("{0}?db=1", host);
using (var clientsManager = sentinel.Start()) {
using (var client = clientsManager.GetClient()) {
Assert.That(client.Db, Is.EqualTo(1));
}
}
}
}
public void Run_sentinel_for_10_minutes()
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var sentinelHost = "{0}:{1}".Fmt(TestConfig.SentinelHost, TestConfig.RedisSentinelPort);
var sentinel = new RedisSentinel(sentinelHost, TestConfig.MasterName)
{
OnFailover = manager =>
{
"Redis Managers Failed Over to new hosts".Print();
},
OnWorkerError = ex =>
{
"Worker error: {0}".Print(ex);
},
OnSentinelMessageReceived = (channel, msg) =>
{
"Received '{0}' on channel '{1}' from Sentinel".Print(channel, msg);
},
};
var redisManager = sentinel.Start();
var aTimer = new Timer
{
Interval = 1000,
Enabled = true
};
aTimer.Elapsed += (sender, args) =>
{
"Incrementing key".Print();
string key = null;
using (var redis = redisManager.GetClient())
{
var counter = redis.Increment("key", 1);
key = "key" + counter;
"Set key {0} in read/write client".Print(key);
redis.SetEntry(key, "value" + 1);
}
using (var redis = redisManager.GetClient())
{
"Get key {0} in read-only client...".Print(key);
var value = redis.GetEntry(key);
"{0} = {1}".Print(key, value);
}
};
Thread.Sleep(TimeSpan.FromMinutes(10));
}
public void Does_scan_for_other_active_sentinels()
{
using var sentinel = new RedisSentinel(SentinelHosts[0])
{
ScanForOtherSentinels = true
};
var clientsManager = sentinel.Start();
Assert.That(sentinel.SentinelHosts, Is.EquivalentTo(SentinelHosts));
using var client = clientsManager.GetClient();
Assert.That(client.GetHostString(), Is.EqualTo(MasterHosts[0]));
}
public void Can_Get_Redis_ClientsManager()
{
var sentinel = new RedisSentinel(new[] { "{0}:{1}".Fmt(TestConfig.SingleHost, TestConfig.RedisSentinelPort) }, TestConfig.MasterName);
var clientsManager = sentinel.Setup();
var client = clientsManager.GetClient();
Assert.AreEqual(client.Host, "127.0.0.1");
Assert.AreEqual(client.Port, TestConfig.RedisPort);
client.Dispose();
sentinel.Dispose();
}
public void Can_Get_Redis_ClientsManager()
{
var sentinel = new RedisSentinel(new[] { "{0}:{1}".Fmt(TestConfig.SingleHost, TestConfig.RedisSentinelPort) }, TestConfig.MasterName);
var clientsManager = sentinel.Setup();
var client = clientsManager.GetClient();
Assert.AreEqual(client.Host, "127.0.0.1");
Assert.AreEqual(client.Port, TestConfig.RedisPort);
client.Dispose();
sentinel.Dispose();
}
public static RedisSentinel CreateGCloudSentinel()
{
var sentinel = new RedisSentinel(GoogleCloudSentinelHosts, masterName: "master")
{
IpAddressMap =
{
{"10.240.34.152", "146.148.77.31"},
{"10.240.203.193", "130.211.139.141"},
{"10.240.209.52", "107.178.218.53"},
}
};
return sentinel;
}
protected override RedisSentinel CreateSentinel()
{
var sentinel = new RedisSentinel(SentinelHosts, "master")
{
IpAddressMap =
{
{ "10.240.109.243", "130.211.149.172" },
{ "10.240.201.29", "130.211.191.163" },
{ "10.240.200.252", "146.148.61.165" },
}
};
return(sentinel);
}
public void Can_specify_db_on_RedisSentinel()
{
var sentinelHosts = new[] { "{0}:{1}".Fmt(TestConfig.SentinelHost, TestConfig.RedisSentinelPort) };
var sentinel = new RedisSentinel(sentinelHosts, TestConfig.MasterName)
{
HostFilter = host => "{0}?db=1".Fmt(host)
};
using (var clientsManager = sentinel.Setup())
using (var client = clientsManager.GetClient())
{
Assert.That(client.Db, Is.EqualTo(1));
}
}
protected override RedisSentinel CreateSentinel()
{
var sentinel = new RedisSentinel(SentinelHosts, "master")
{
IpAddressMap =
{
{ "10.240.34.152", "146.148.77.31" },
{ "10.240.203.193", "130.211.139.141" },
{ "10.240.209.52", "107.178.218.53" },
}
};
return(sentinel);
}
public static RedisSentinel CreateGCloudSentinel()
{
var sentinel = new RedisSentinel(GoogleCloudSentinelHosts, masterName: "master")
{
IpAddressMap =
{
{ "10.240.34.152", "146.148.77.31" },
{ "10.240.203.193", "130.211.139.141" },
{ "10.240.209.52", "107.178.218.53" },
}
};
return(sentinel);
}
private static IRedisClientsManager GetSentinelAwareClientManager(NameValueCollection config)
{
var master = config["master"];
if (String.IsNullOrEmpty(master))
{
throw new RedisSessionStoreException("Redis sentinel master name is null or empty");
}
var hosts = ResolveSentinelHosts(config);
var sentinel = new RedisSentinel(hosts, master);
var redisClientsManager = sentinel.Setup();
return(redisClientsManager);
}
public void Does_scan_for_other_active_sentinels()
{
using (var sentinel = new RedisSentinel(Config.Sentinel26380)
{
ScanForOtherSentinels = true
}) {
var clientsManager = sentinel.Start();
Assert.That(sentinel.SentinelHosts, Is.EquivalentTo(Config.SentinelHosts));
using (var client = clientsManager.GetClient()) {
Assert.That(client.GetHostString(), Is.EqualTo(Config.Sentinel6380));
}
}
}
public void Can_connect_to_3SentinelSetup()
{
var sentinel = new RedisSentinel(SentinelHosts);
var redisManager = sentinel.Start();
using (var client = redisManager.GetClient())
{
client.FlushAll();
client.SetValue("Sentinel3Setup", "IntranetSentinel");
var result = client.GetValue("Sentinel3Setup");
Assert.That(result, Is.EqualTo("IntranetSentinel"));
}
}
public void Can_connect_to_3SentinelSetup()
{
var sentinel = new RedisSentinel(SentinelHosts);
var redisManager = sentinel.Start();
using (var client = redisManager.GetClient())
{
client.FlushAll();
client.SetEntry("Sentinel3Setup", "IntranetSentinel");
var result = client.GetEntry("Sentinel3Setup");
Assert.That(result, Is.EqualTo("IntranetSentinel"));
}
}
public void Can_specify_Timeout_on_RedisManager()
{
using (var sentinel = new RedisSentinel(Config.SentinelHosts, Config.SentinelMasterName)) {
sentinel.RedisManagerFactory = (masters, slaves) => new PooledRedisClientManager(masters, slaves)
{
IdleTimeoutSecs = 20
};
using (var clientsManager = (PooledRedisClientManager)sentinel.Start()) {
using (var client = clientsManager.GetClient()) {
Assert.That(clientsManager.IdleTimeoutSecs, Is.EqualTo(20));
Assert.That(((RedisNativeClient)client).IdleTimeoutSecs, Is.EqualTo(20));
}
}
}
}
private static IRedisClientsManager GetRedisClientsManager()
{
//var sentinelHosts = new[] { "somredis01.zerochaos.local:26379","somredis02.zerochaos.local:26379","somredis03.zerochaos.local:26379" };
var sentinelHosts = new[] { "supdevredis01.zcdev.local:26379", "supdevredis01.zcdev.local:26380", "supdevredis01.zcdev.local:26381" };
//var sentinelHosts = new[] { "supredis01.zcdev.local:26379", "supredis01.zcdev.local:26380", "supredis01.zcdev.local:26381" };
var sentinel = new RedisSentinel(sentinelHosts, masterName: "zcredismaster");
if (redisManager != null)
{
return(redisManager);
}
else
{
// By default RedisSentinel uses a PooledRedisClientManager
return(sentinel.Start());
}
}
public void Can_connect_to_RedisSentinel()
{
RedisConfig.AssumeServerVersion = 4000;
var sentinel = new RedisSentinel("52.7.181.87:26379")
{
IpAddressMap =
{
{ "127.0.0.1", "52.7.181.87" }
}
};
var redisManager = sentinel.Start();
using (var client = redisManager.GetClient())
{
Assert.That(client.Ping());
}
}
public void Can_specify_Timeout_on_RedisManager()
{
var sentinel = new RedisSentinel(new[] { "{0}:{1}".Fmt(TestConfig.SentinelHost, TestConfig.RedisSentinelPort) }, TestConfig.MasterName)
{
RedisManagerFactory =
{
OnInit = r => {
((PooledRedisClientManager)r).IdleTimeOutSecs = 20;
}
}
};
using (var clientsManager = (PooledRedisClientManager)sentinel.Setup())
using (var client = clientsManager.GetClient())
{
Assert.That(clientsManager.IdleTimeOutSecs, Is.EqualTo(20));
Assert.That(((RedisNativeClient)client).IdleTimeOutSecs, Is.EqualTo(20));
}
}
public void Execute()
{
RedisConfig.DisableVerboseLogging = true;
var sentinel = new RedisSentinel(Config.SentinelHosts, Config.SentinelMasterName);
var redisManager = sentinel.Start();
using (var client = redisManager.GetClient()) {
client.FlushAll();
}
using (var client = redisManager.GetClient()) {
Console.WriteLine(client.IncrementValue("counter").ToString());
}
Console.WriteLine("Force 'SENTINEL failover mymaster'...");
try {
using (var client = redisManager.GetClient()) {
Console.WriteLine(client.IncrementValue("counter").ToString());
}
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
try {
using (var client = redisManager.GetClient()) {
Console.WriteLine(client.IncrementValue("counter").ToString());
}
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
try {
using (var client = redisManager.GetClient()) {
Console.WriteLine(client.IncrementValue("counter").ToString());
}
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
}
public static RedisSentinel CreateSentinel()
{
var sentinel = new RedisSentinel(SentinelHosts);
return sentinel;
}
public void Can_specify_Timeout_on_RedisManager()
{
var sentinel = new RedisSentinel(new[] { "{0}:{1}".Fmt(TestConfig.SentinelHost, TestConfig.RedisSentinelPort) }, TestConfig.MasterName)
{
RedisManagerFactory = {
OnInit = r => {
((PooledRedisClientManager)r).IdleTimeOutSecs = 20;
}
}
};
using (var clientsManager = (PooledRedisClientManager)sentinel.Setup())
using (var client = clientsManager.GetClient())
{
Assert.That(clientsManager.IdleTimeOutSecs, Is.EqualTo(20));
Assert.That(((RedisNativeClient)client).IdleTimeOutSecs, Is.EqualTo(20));
}
}
public void Run_sentinel_for_10_minutes()
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled:true);
var sentinelHost = "{0}:{1}".Fmt(TestConfig.SentinelHost, TestConfig.RedisSentinelPort);
var sentinel = new RedisSentinel(sentinelHost, TestConfig.MasterName)
{
OnFailover = manager =>
{
"Redis Managers Failed Over to new hosts".Print();
},
OnWorkerError = ex =>
{
"Worker error: {0}".Print(ex);
},
OnSentinelMessageReceived = (channel, msg) =>
{
"Received '{0}' on channel '{1}' from Sentinel".Print(channel, msg);
},
};
var redisManager = sentinel.Start();
var aTimer = new Timer
{
Interval = 1000,
Enabled = true
};
aTimer.Elapsed += (sender, args) =>
{
"Incrementing key".Print();
string key = null;
using (var redis = redisManager.GetClient())
{
var counter = redis.Increment("key", 1);
key = "key" + counter;
"Set key {0} in read/write client".Print(key);
redis.SetEntry(key, "value" + 1);
}
using (var redis = redisManager.GetClient())
{
"Get key {0} in read-only client...".Print(key);
var value = redis.GetEntry(key);
"{0} = {1}".Print(key, value);
}
};
Thread.Sleep(TimeSpan.FromMinutes(10));
}
public void Can_specify_db_on_RedisSentinel()
{
var sentinelHosts = new[] {"{0}:{1}".Fmt(TestConfig.SentinelHost, TestConfig.RedisSentinelPort)};
var sentinel = new RedisSentinel(sentinelHosts, TestConfig.MasterName) {
HostFilter = host => "{0}?db=1".Fmt(host)
};
using (var clientsManager = sentinel.Setup())
using (var client = clientsManager.GetClient())
{
Assert.That(client.Db, Is.EqualTo(1));
}
}
public void Does_scan_for_other_active_sentinels()
{
using (var sentinel = new RedisSentinel(SentinelHosts[0]) {
ScanForOtherSentinels = true
})
{
var clientsManager = sentinel.Start();
Assert.That(sentinel.SentinelHosts, Is.EquivalentTo(SentinelHosts));
using (var client = clientsManager.GetClient())
{
Assert.That(client.GetHostString(), Is.EqualTo(MasterHosts[0]));
}
}
}
