public void Test_That_Key_XXXXX_Maps_To_VBucket_389()
{
const int actual = 389;
IKeyMapper mapper = new VBucketKeyMapper(_servers, _vBucketServerMap, _bucketConfig.Rev, _bucketConfig.Name);
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.AreEqual(vBucket.Index, actual);
}
public void VBucket_HasCorrectBucketname()
{
var expected = "travel-sample";
IKeyMapper mapper = new VBucketKeyMapper(_servers, _vBucketServerMap, _bucketConfig.Rev, expected);
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.AreEqual(expected, vBucket.BucketName);
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replica_Count_Is_Equal()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = bucketConfig.VBucketServerMap.
ServerList.
Select(server => new Server(ObjectFactory.CreateIOStrategy(server), new Node(), new ClientConfiguration())).
Cast<IServer>().
ToList();
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap);
var vBucket = (IVBucket)mapper.MapKey("somekey");
const int expected = 3;
Assert.AreEqual(expected, vBucket.Replicas.Count());
}
public void WhenForwardMapIsAvailable_AndRevisionIsSame_OperationUsesForwardMapVBucket()
{
var controller = new Mock<IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var server1 = new Mock<IServer>();
server1.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic>());
server1.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var server2 = new Mock<IServer>();
server2.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic>());
server2.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Parse("255.255.0.0"), 8091));
var vBucketServerMap = new VBucketServerMap
{
ServerList = new[]
{
"localhost:8901",
"255.255.0.0:8091"
},
VBucketMap = new[] {new[] {0}},
VBucketMapForward = new[] {new[] {1}}
};
var keyMapper = new VBucketKeyMapper(new Dictionary<IPAddress, IServer>
{
{ IPAddress.Loopback, server1.Object},
{ IPAddress.Parse("255.255.0.0"), server2.Object}
}, vBucketServerMap, 2, "default");
var configInfo = new Mock<IConfigInfo>();
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper);
configInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary<uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
var op = new Get<dynamic>("thekey", null, new DefaultTranscoder(), 100);
op.LastConfigRevisionTried = 2;
var result = executor.SendWithRetry(op);
Assert.AreEqual(op.VBucket.LocatePrimary().EndPoint, keyMapper.GetVBucketsForwards().First().Value.LocatePrimary().EndPoint);
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replicas_Are_Equal()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = bucketConfig.VBucketServerMap.
ServerList.
Select(server => new Server(ObjectFactory.CreateIOStrategy(server), new Node(), new ClientConfiguration())).
Cast<IServer>().
ToList();
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap);
var vBucket = (IVBucket)mapper.MapKey("somekey");
var index = mapper.GetIndex("somekey");
var expected = bucketConfig.VBucketServerMap.VBucketMap[index];
for (var i = 0; i < vBucket.Replicas.Length; i++)
{
Assert.AreEqual(vBucket.Replicas[i], expected[i+1]);
}
}
public override void LoadConfig()
{
Lock.EnterWriteLock();
try
{
Log.Info(m => m("o3-Creating the Servers list using rev#{0}", BucketConfig.Rev));
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var servers = new Dictionary<IPAddress, IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
var connectionPool = ConnectionPoolFactory(clientBucketConfig.PoolConfiguration,endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var server = new Core.Server(ioStrategy, adapter, ClientConfig, BucketConfig, Transcoder)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
UpdateServices(servers);
var old = Interlocked.Exchange(ref Servers, servers);
var vBucketKeyMapper = new VBucketKeyMapper(Servers, BucketConfig.VBucketServerMap, BucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
finally
{
Lock.ExitWriteLock();
}
}
public void When_Primary_Index_Is_Greater_Than_Cluster_Count_Random_Server_Returned()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-negative-one-primary.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = bucketConfig.VBucketServerMap.
ServerList.
Select(s => new Server(ObjectFactory.CreateIOStrategy(s), new Node(), new ClientConfiguration())).
Cast<IServer>().
ToList();
//remove one server
servers.RemoveAt(1);
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap);
//maps to -1 primary
const string key = "somekey23";
var vBucket = (IVBucket)mapper.MapKey(key);
var server = vBucket.LocatePrimary();
Assert.IsNotNull(server);
}
public void Test_That_HashAlgorithm_Default_Type_Is_Crc32()
{
IKeyMapper mapper = new VBucketKeyMapper(_servers, _vBucketServerMap);
Assert.IsInstanceOf<Crc32>(mapper.HashAlgorithm);
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
/// <param name="force">True to force the reconfiguration.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
var nodes = bucketConfig.GetNodes();
if (BucketConfig == null || !nodes.AreEqual(_bucketConfig.GetNodes()) || !Servers.Any() || force)
{
Log.InfoFormat("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev);
var queryUris = new ConcurrentBag<FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary<IPAddress, IServer>();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
Log.InfoFormat("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev);
IServer server;
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
uri.ConfigureServicePoint(ClientConfig);
queryUris.Add(uri);
}
if (adapter.IsDataNode) //a data node so create a connection pool
{
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioService = IOServiceFactory(connectionPool);
server = new Core.Server(ioService, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
}
else
{
server = new Core.Server(null, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache);
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0} for rev#{1}. Exception: {2}", endpoint, bucketConfig.Rev, e);
}
}
UpdateServices(servers);
//for caching uri's
Interlocked.Exchange(ref QueryUris, queryUris);
var old = Interlocked.Exchange(ref Servers, servers);
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
if (old != null)
{
foreach (var server in old.Values)
{
Log.InfoFormat("Disposing node {0} from rev#{1}", server.EndPoint, server.Revision);
server.Dispose();
}
old.Clear();
}
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap,
bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_LocateReplica_Returns_Correct_Server()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = bucketConfig.VBucketServerMap.
ServerList.
Select(server => new Server(ObjectFactory.CreateIOStrategy(server), new Node(), new ClientConfiguration())).
Cast<IServer>().
ToList();
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap);
var vBucket = (IVBucket)mapper.MapKey("somekey");
foreach (var index in vBucket.Replicas)
{
var server = vBucket.LocateReplica(index);
Assert.IsNotNull(server);
var expected = bucketConfig.VBucketServerMap.ServerList[index];
Assert.AreEqual(server.EndPoint.Address.ToString(), expected.Split(':').First());
}
}
public void Test_That_HashAlgorithm_Is_Not_Null()
{
IKeyMapper mapper = new VBucketKeyMapper(_servers, _vBucketServerMap);
Assert.IsNotNull(mapper.HashAlgorithm);
}
public void When_Primary_Index_Is_Greater_Than_Cluster_Count_Random_Server_Returned()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-negative-one-primary.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = new Dictionary<IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(node.GetIPAddress(),
new Server(new FakeIOStrategy(node.GetIPEndPoint(), new FakeConnectionPool(), false),
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
//remove one server
servers.Remove(_vBucketServerMap.IPEndPoints.Skip(1).First().Address);
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
//maps to -1 primary
const string key = "somekey23";
var vBucket = (IVBucket)mapper.MapKey(key);
var primary = vBucket.LocatePrimary();
Assert.IsNotNull(primary);
}
public void ReadFromReplica_WhenKeyNotFound_ReturnsKeyNotFound()
{
var controller = new Mock<IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var server1 = new Mock<IServer>();
server1.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic> { Status = ResponseStatus.KeyNotFound });
server1.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var server2 = new Mock<IServer>();
server2.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic> {Status = ResponseStatus.KeyNotFound});
server2.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Parse("255.255.0.0"), 8091));
var vBucketServerMap = new VBucketServerMap
{
ServerList = new[]
{
"localhost:8901",
"255.255.0.0:8091"
},
VBucketMap = new[] { new[] { 0, 1 } },
VBucketMapForward = new[] { new[] { 1 } }
};
var keyMapper = new VBucketKeyMapper(new Dictionary<IPAddress, IServer>
{
{ IPAddress.Loopback, server1.Object},
{ IPAddress.Parse("255.255.0.0"), server2.Object}
}, vBucketServerMap, 3, "default");
var configInfo = new Mock<IConfigInfo>();
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper);
configInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary<uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
var op = new ReplicaRead<dynamic>("thekey", null, new DefaultTranscoder(), 100);
var result = executor.ReadFromReplica(op);
Assert.AreEqual(ResponseStatus.KeyNotFound, result.Status);
}
public void Test_That_HashAlgorithm_Default_Type_Can_Be_Overridden()
{
IKeyMapper mapper = new VBucketKeyMapper(new HMACMD5(), _servers, _vBucketServerMap);
Assert.IsInstanceOf<HMACMD5>(mapper.HashAlgorithm);
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public void LoadConfig(IOStrategy ioStrategy)
{
var supportsEnhancedDurability = false;
try
{
Lock.EnterWriteLock();
Log.Info(m => m("o2-Creating the Servers list using rev#{0}", BucketConfig.Rev));
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var servers = new Dictionary<IPAddress, IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
IServer server = null;
if (Equals(ioStrategy.EndPoint, endpoint) || nodes.Count() == 1)
{
server = new Core.Server(ioStrategy, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache);
supportsEnhancedDurability = ioStrategy.SupportsEnhancedDurability;
SupportsEnhancedDurability = supportsEnhancedDurability;
}
else
{
var poolConfig = ClientConfig.BucketConfigs[BucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfig, endpoint);
var newIoStrategy = IOStrategyFactory(connectionPool);
server = new Core.Server(newIoStrategy, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
SupportsEnhancedDurability = supportsEnhancedDurability;
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
UpdateServices(servers);
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", BucketConfig.Rev));
var old = Interlocked.Exchange(ref Servers, servers);
var vBucketKeyMapper = new VBucketKeyMapper(Servers, BucketConfig.VBucketServerMap, BucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
finally
{
Lock.ExitWriteLock();
}
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replicas_Are_Equal()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = new Dictionary<IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(node.GetIPAddress(),
new Server(new FakeIOStrategy(node.GetIPEndPoint(), new FakeConnectionPool(), false),
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
var vBucket = (IVBucket)mapper.MapKey("somekey");
var index = mapper.GetIndex("somekey");
var expected = bucketConfig.VBucketServerMap.VBucketMap[index];
for (var i = 0; i < vBucket.Replicas.Length; i++)
{
Assert.AreEqual(vBucket.Replicas[i], expected[i+1]);
}
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replica_Count_Is_Equal()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = new Dictionary<IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(node.GetIPAddress(),
new Server(new FakeIOStrategy(node.GetIPEndPoint(), new FakeConnectionPool(), false),
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
var vBucket = (IVBucket)mapper.MapKey("somekey");
const int expected = 3;
Assert.AreEqual(expected, vBucket.Replicas.Count());
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
/// <param name="force">True to force the reconfiguration.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
if (BucketConfig == null || !BucketConfig.AreNodesEqual(bucketConfig) || !Servers.Any() || force)
{
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary<IPAddress, IServer>();
var nodes = bucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
Log.Info(
m =>
m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(),
bucketConfig.Rev));
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig, Transcoder)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
UpdateServices(servers);
var old = Interlocked.Exchange(ref Servers, servers);
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap,
bucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public void LoadConfig(IIOService ioService)
{
var supportsEnhancedDurability = false;
try
{
Lock.EnterWriteLock();
Log.Info(m => m("o2-Creating the Servers list using rev#{0}", BucketConfig.Rev));
var queryUris = new ConcurrentBag<FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var servers = new Dictionary<IPAddress, IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
IServer server = null;
if (Equals(ioService.EndPoint, endpoint) || nodes.Count() == 1)
{
server = new Core.Server(ioService, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache);
supportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsEnhancedDurability = supportsEnhancedDurability;
if (server.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
uri.ConfigureServicePoint(ClientConfig);
queryUris.Add(uri);
}
}
else
{
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
uri.ConfigureServicePoint(ClientConfig);
queryUris.Add(uri);
}
if (adapter.IsDataNode) //a data node so create a connection pool
{
var poolConfiguration = ClientConfig.BucketConfigs[BucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var newIoService = IOServiceFactory(connectionPool);
server = new Core.Server(newIoService, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
//Note: "ioService has" already made a HELO command to check if
//the cluster supports enhanced durability so we are reusing the flag
//instead of having "newIoService" do it again, later.
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
}
else
{
server = new Core.Server(null, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache);
}
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
UpdateServices(servers);
//for caching uri's
Interlocked.Exchange(ref QueryUris, queryUris);
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", BucketConfig.Rev));
var old = Interlocked.Exchange(ref Servers, servers);
var vBucketKeyMapper = new VBucketKeyMapper(Servers, BucketConfig.VBucketServerMap, BucketConfig.Rev);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
finally
{
Lock.ExitWriteLock();
}
}
public void TestMapKey()
{
IKeyMapper mapper = new VBucketKeyMapper(_servers, _vBucketServerMap, _bucketConfig.Rev, _bucketConfig.Name);
var vBucket = mapper.MapKey(Key);
Assert.IsNotNull(vBucket);
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_LocateReplica_Returns_Correct_Server()
{
var json = File.ReadAllText(@"Data\\Configuration\\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = new Dictionary<IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(node.GetIPAddress(),
new Server(new FakeIOStrategy(node.GetIPEndPoint(), new FakeConnectionPool(), false),
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
var vBucket = (IVBucket)mapper.MapKey("somekey");
foreach (var index in vBucket.Replicas)
{
var server = vBucket.LocateReplica(index);
Assert.IsNotNull(server);
var expected = bucketConfig.VBucketServerMap.ServerList[index];
Assert.AreEqual(server.EndPoint.Address.ToString(), expected.Split(':').First());
}
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public override void LoadConfig()
{
Lock.EnterWriteLock();
try
{
Log.LogInformation("o3-Creating the Servers list using rev#{0}", BucketConfig.Rev);
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var searchUris = new ConcurrentBag<FailureCountingUri>();
var queryUris = new ConcurrentBag<FailureCountingUri>();
var servers = new Dictionary<IPAddress, IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
IServer server;
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
uri.ConfigureServicePoint(ClientConfig);
searchUris.Add(uri);
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
uri.ConfigureServicePoint(ClientConfig);
queryUris.Add(uri);
}
if (adapter.IsDataNode) //a data node so create a connection pool
{
var uri = UrlUtil.GetBaseUri(adapter, clientBucketConfig);
var poolConfiguration = ClientConfig.BucketConfigs[BucketConfig.Name].ClonePoolConfiguration(uri);
var connectionPool = ConnectionPoolFactory(poolConfiguration.Clone(uri), endpoint);
var newIoService = IOServiceFactory(connectionPool, _loggerFactory);
server = new Core.Server(newIoService, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache, Log)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
SupportsEnhancedDurability = newIoService.SupportsEnhancedDurability;
}
else
{
server = new Core.Server(null, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache, Log);
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.LogError("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
UpdateServices(servers);
//for caching uri's
Interlocked.Exchange(ref QueryUris, queryUris);
Interlocked.Exchange(ref SearchUris, searchUris);
var old = Interlocked.Exchange(ref Servers, servers);
var vBucketKeyMapper = new VBucketKeyMapper(Servers, BucketConfig.VBucketServerMap, BucketConfig.Rev, BucketConfig.Name, Log);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
finally
{
Lock.ExitWriteLock();
}
}
public void When_Primary_Is_Negative_Random_Server_Returned()
{
var json = ResourceHelper.ReadResource(@"Data\Configuration\config-with-negative-one-primary.json");
var bucketConfig = JsonConvert.DeserializeObject<BucketConfig>(json);
var servers = new Dictionary<IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(node.GetIPAddress(),
new Server(new FakeIOService(node.GetIPEndPoint(), new FakeConnectionPool(), false),
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap, bucketConfig.Rev, bucketConfig.Name);
//maps to -1 primary
const string key = "somekey0";
var vBucket = (IVBucket)mapper.MapKey(key);
Assert.AreEqual(-1, vBucket.Primary);
var primary = vBucket.LocatePrimary();
Assert.IsNotNull(primary);
}
