public void When_Primary_Is_Negative_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()));
}
var mapper = new VBucketKeyMapper(servers, bucketConfig.VBucketServerMap, bucketConfig.Rev);
//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);
}
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 FakeIOService(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 TestMapKey()
{
IKeyMapper mapper = new VBucketKeyMapper(_servers, _vBucketServerMap, _bucketConfig.Rev, _bucketConfig.Name);
var vBucket = mapper.MapKey(Key);
Assert.IsNotNull(vBucket);
}
internal override async Task BootstrapAsync(IClusterNode node)
{
try
{
node.Owner = this;
await node.SelectBucket(this.Name);
if (Context.SupportsCollections)
{
Manifest = await node.GetManifest().ConfigureAwait(false);
}
//we still need to add a default collection
LoadManifest();
BucketConfig = await node.GetClusterMap().ConfigureAwait(false);
KeyMapper = new VBucketKeyMapper(BucketConfig);
await Context.ProcessClusterMapAsync(this, BucketConfig);
}
catch (Exception e)
{
CaptureException(e);
}
}
public void LoadConfig(IOStrategy ioStrategy)
{
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);
}
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)
{
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);
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 FakeIOService(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]);
}
}
/// <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>
public override void LoadConfig(IBucketConfig bucketConfig)
{
if (bucketConfig == null)
{
throw new ArgumentNullException("bucketConfig");
}
if (BucketConfig == null || !BucketConfig.Nodes.AreEqual <Node>(bucketConfig.Nodes))
{
Log.Info(m => m("Creating the Servers list using rev#{0}", bucketConfig.Rev));
var nodes = bucketConfig.Nodes;
for (var i = 0; i < nodes.Length; i++)
{
var ip = bucketConfig.VBucketServerMap.ServerList[i];
var endpoint = GetEndPoint(ip, bucketConfig);
var connectionPool = ConnectionPoolFactory(ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var saslMechanism = SaslFactory(bucketConfig.Name, bucketConfig.Password, ioStrategy, Converter);
saslMechanism.IOStrategy = ioStrategy;
var server = new Core.Server(ioStrategy, nodes[i], ClientConfig);//this should be a Func factory...a functory
Servers.Add(server);
}
}
if (BucketConfig == null || !BucketConfig.VBucketServerMap.Equals(bucketConfig.VBucketServerMap))
{
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
KeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap);
}
BucketConfig = bucketConfig;
}
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 FakeIOService(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());
}
}
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 Setup()
{
_key = new string('0', KeySize);
_keyMapper = new VBucketKeyMapper(
new BucketConfig(),
new VBucketServerMap(new VBucketServerMapDto(), new List <IPEndPoint>()),
new VBucketFactory(new NullLogger <VBucket>()));
}
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 TestMapKey(int index, string key)
{
var config = ResourceHelper.ReadResource <BucketConfig>(@"Documents\config.json");
IKeyMapper mapper = new VBucketKeyMapper(config, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (VBucket)mapper.MapKey(key);
Assert.Equal(index, vBucket.Index);
}
public void Test_That_Key_XXXXX_Maps_To_VBucket_389()
{
const int actual = 389;
var config = ResourceHelper.ReadResource <BucketConfig>(@"Documents\config.json");
IKeyMapper mapper = new VBucketKeyMapper(config, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.Equal(vBucket.Index, actual);
}
public void TestMapKey(int index, string key)
{
var config = ResourceHelper.ReadResource <BucketConfig>(@"Documents\config.json");
IKeyMapper mapper = new VBucketKeyMapper(config);
var vBucket = (VBucket)mapper.MapKey(key);
Assert.Equal(index, vBucket.Index);
}
public void VBucket_HasCorrectBucketname()
{
var expected = "default";
var config = ResourceHelper.ReadResource <BucketConfig>(@"Documents\config.json");
IKeyMapper mapper = new VBucketKeyMapper(config, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.Equal(expected, vBucket.BucketName);
}
public void VBucket_Supports_LocalHost()
{
var expected = "default";
var config = ResourceHelper.ReadResource <BucketConfig>(@"Documents\configs\config-localhost.json");
config.ReplacePlaceholderWithBootstrapHost(new Uri("http://127.0.0.1"));
IKeyMapper mapper = new VBucketKeyMapper(config, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.Equal(expected, vBucket.BucketName);
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replica_Count_Is_Equal()
{
var json = ResourceHelper.ReadResource(@"Data\Configuration\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject <BucketConfig>(json);
var mapper = new VBucketKeyMapper(bucketConfig, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey("somekey");
const int expected = 3;
Assert.Equal(expected, vBucket.Replicas.Count());
}
public void TestMapKey(int index, string key)
{
var config = ResourceHelper.ReadResource(@"Documents\config.json",
InternalSerializationContext.Default.BucketConfig);
var vBucketServerMap = new VBucketServerMap(config.VBucketServerMap);
IKeyMapper mapper = new VBucketKeyMapper(config, vBucketServerMap,
new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (VBucket)mapper.MapKey(key);
Assert.Equal(index, vBucket.Index);
}
public void Test_That_Key_XXXXX_Maps_To_VBucket_389()
{
const int actual = 389;
var config = ResourceHelper.ReadResource(@"Documents\config.json",
InternalSerializationContext.Default.BucketConfig);
var vBucketServerMap = new VBucketServerMap(config.VBucketServerMap);
IKeyMapper mapper = new VBucketKeyMapper(config, vBucketServerMap,
new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.Equal(vBucket.Index, actual);
}
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);
}
internal override void ConfigUpdated(object sender, BucketConfigEventArgs e)
{
if (e.Config.Name == Name && (BucketConfig == null || e.Config.Rev > BucketConfig.Rev))
{
BucketConfig = e.Config;
if (BucketConfig.VBucketMapChanged)
{
KeyMapper = new VBucketKeyMapper(BucketConfig);
}
if (BucketConfig.ClusterNodesChanged)
{
Task.Run(async() => await Context.ProcessClusterMapAsync(this, BucketConfig)).GetAwaiter().GetResult();
}
}
}
public void VBucket_HasCorrectBucketname()
{
var expected = "default";
var config = ResourceHelper.ReadResource(@"Documents\config.json",
InternalSerializationContext.Default.BucketConfig);
var vBucketServerMap = new VBucketServerMap(config.VBucketServerMap);
IKeyMapper mapper = new VBucketKeyMapper(config, vBucketServerMap,
new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.Equal(expected, vBucket.BucketName);
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replica_Count_Is_Equal()
{
var bucketConfig = ResourceHelper.ReadResource(@"Data\Configuration\config-with-replicas-complete.json",
InternalSerializationContext.Default.BucketConfig);
var vBucketServerMap = GetServerMap(bucketConfig.VBucketServerMap);
var mapper = new VBucketKeyMapper(bucketConfig, vBucketServerMap,
new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey("somekey");
const int expected = 3;
Assert.Equal(expected, vBucket.Replicas.Count());
}
internal override void ConfigUpdated(object sender, BucketConfigEventArgs e)
{
if (e.Config.Name == Name && e.Config.Rev > BucketConfig.Rev)
{
BucketConfig = e.Config;
if (BucketConfig.VBucketMapChanged)
{
KeyMapper = new VBucketKeyMapper(BucketConfig);
}
if (BucketConfig.ClusterNodesChanged)
{
LoadClusterMap(BucketConfig.GetNodes()).ConfigureAwait(false).GetAwaiter().GetResult();
Prune(BucketConfig);
}
}
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_Replicas_Are_Equal()
{
var json = ResourceHelper.ReadResource(@"Data\Configuration\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject <BucketConfig>(json);
var mapper = new VBucketKeyMapper(bucketConfig, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
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.Equal(vBucket.Replicas[i], expected[i + 1]);
}
}
public void WhenForwardMapIsAvailable_AndRevisionIsZero_OperationUsesVBucket()
{
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, 1, "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 = 0;
var result = executor.SendWithRetry(op);
Assert.AreEqual(op.VBucket.LocatePrimary().EndPoint, keyMapper.GetVBuckets().First().Value.LocatePrimary().EndPoint);
}
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 VBucket_Supports_LocalHost()
{
var expected = "default";
var config = ResourceHelper.ReadResource(@"Documents\configs\config-localhost.json",
InternalSerializationContext.Default.BucketConfig);
config.ReplacePlaceholderWithBootstrapHost("127.0.0.1");
var vBucketServerMap = new VBucketServerMap(config.VBucketServerMap);
IKeyMapper mapper = new VBucketKeyMapper(config, vBucketServerMap,
new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey(Key);
Assert.Equal(expected, vBucket.BucketName);
}
public void When_BucketConfig_Has_Replicas_VBucketKeyMapper_LocateReplica_Returns_Correct_Server()
{
var json = ResourceHelper.ReadResource(@"Data\Configuration\config-with-replicas-complete.json");
var bucketConfig = JsonConvert.DeserializeObject <BucketConfig>(json);
var mapper = new VBucketKeyMapper(bucketConfig, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
var vBucket = (IVBucket)mapper.MapKey("somekey");
foreach (var index in vBucket.Replicas)
{
var server = vBucket.LocateReplica(index);
Assert.NotNull(server);
var expected = bucketConfig.VBucketServerMap.ServerList[index];
Assert.Equal(server.Address.ToString(), expected.Split(':').First());
}
}
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 mapper = new VBucketKeyMapper(bucketConfig, new VBucketFactory(new Mock <ILogger <VBucket> >().Object));
//maps to -1 primary
const string key = "somekey0";
var vBucket = (IVBucket)mapper.MapKey(key);
Assert.Equal(-1, vBucket.Primary);
var primary = vBucket.LocatePrimary();
Assert.NotNull(primary);
}
