public void When_Replica_Index_Postive_LocatePrimary_Returns_It()
{
var server = new Server(
new FakeIOService(IPEndPointExtensions.GetEndPoint("127.0.0.1:8091"),
new FakeConnectionPool(), false),
new NodeAdapter(new Node {
Hostname = "127.0.0.1"
},
new NodeExt()),
new ClientConfiguration(),
new BucketConfig {
Name = "default"
},
new FakeTranscoder());
var vbucket =
new VBucket(new Dictionary <IPAddress, IServer>
{
{ IPEndPointExtensions.GetEndPoint("127.0.0.1:10210").Address, server },
{ IPEndPointExtensions.GetEndPoint("127.0.0.2:10210").Address, server }
},
100, -1, new[] { 0 }, 0, new VBucketServerMap {
ServerList = new[] { "127.0.0.1:10210", "127.0.0.2:10210" }
});
var found = vbucket.LocatePrimary();
Assert.IsNotNull(found);
}
public void Test_Authenticate(bool isAuthenticated, bool isEncrypted, bool isSigned)
{
var endpoint = IPEndPointExtensions.GetEndPoint(TestConfiguration.Settings.Hostname, 11207);
var bootstrapUri = new Uri($@"https://{endpoint.Address}:8091/pools");
var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
socket.Connect(endpoint);
var poolConfig = new PoolConfiguration {
UseSsl = true, Uri = bootstrapUri, ClientConfiguration = new ClientConfiguration()
};
var sslStream = new Mock <SslStream>(new MemoryStream(), true, new RemoteCertificateValidationCallback(ServerCertificateValidationCallback));
sslStream.Setup(x => x.IsAuthenticated).Returns(isAuthenticated);
sslStream.Setup(x => x.IsEncrypted).Returns(isEncrypted);
sslStream.Setup(x => x.IsSigned).Returns(isSigned);
var connPool = new Mock <IConnectionPool <IConnection> >();
connPool.Setup(x => x.Configuration).Returns(poolConfig);
var conn = new SslConnection(connPool.Object, socket, sslStream.Object, new DefaultConverter(),
new BufferAllocator(1024, 1024));
if (isAuthenticated && isEncrypted && isSigned)
{
Assert.DoesNotThrow(conn.Authenticate);
}
else
{
Assert.Throws <AuthenticationException>(conn.Authenticate);
}
}
public IPEndPoint GetMemcachedEndPoint()
{
var hostName = Hostname.Replace(HostToken, LocalHost);
hostName = hostName.Replace(ViewPort, Ports.Direct.ToString(CultureInfo.InvariantCulture));
return(IPEndPointExtensions.GetEndPoint(hostName));
}
public override void LoadConfig()
{
var servers = new List <IServer>();
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
var connectionPool = ConnectionPoolFactory(clientBucketConfig.PoolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var server = new Core.Server(ioStrategy, adapter, ClientConfig, BucketConfig);
var saslMechanism = SaslFactory(BucketConfig.Name, BucketConfig.Password, ioStrategy, Transcoder);
ioStrategy.SaslMechanism = saslMechanism;
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers));
}
public void When_Replica_Index_Postive_LocatePrimary_Returns_It()
{
var mockBucketConfig = new Mock <IBucketConfig>();
var server = new Server(
new FakeIOService(IPEndPointExtensions.GetEndPoint("127.0.0.1:8091"),
new FakeConnectionPool(), false),
new NodeAdapter(new Node {
Hostname = "127.0.0.1"
}, new NodeExt(), mockBucketConfig.Object),
new FakeTranscoder(),
ContextFactory.GetCouchbaseContext());
var vbucket =
new VBucket(new Dictionary <IPEndPoint, IServer>
{
{ IPEndPointExtensions.GetEndPoint("127.0.0.1:10210"), server },
{ IPEndPointExtensions.GetEndPoint("127.0.0.2:10210"), server }
},
100, -1, new[] { 0 }, 0, new VBucketServerMap {
ServerList = new[] { "127.0.0.1:10210", "127.0.0.2:10210" }
}, "default");
var found = vbucket.LocatePrimary();
Assert.IsNotNull(found);
}
public void When_Hostname_Is_Provided_IPAdress_Is_Returned()
{
var hostname = "127.0.0.1:8091";
var expected = "127.0.0.1";
var actual = IPEndPointExtensions.GetEndPoint(hostname);
Assert.AreEqual(expected, actual.Address.ToString());
}
/// <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, bool force = false)
{
try
{
Lock.EnterWriteLock();
if (bucketConfig == null)
{
throw new ArgumentNullException("bucketConfig");
}
if (BucketConfig == null || !BucketConfig.Nodes.AreEqual <Node>(bucketConfig.Nodes) || !Servers.Any() ||
force)
{
Log.Info(m => m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(), bucketConfig.Rev));
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new List <IServer>();
var nodes = bucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var saslMechanism = SaslFactory(bucketConfig.Name, bucketConfig.Password, ioStrategy, Converter);
ioStrategy.SaslMechanism = saslMechanism;
var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig);
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
}
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
Interlocked.Exchange(ref KeyMapper, new VBucketKeyMapper(Servers, _bucketConfig.VBucketServerMap)
{
Rev = _bucketConfig.Rev
});
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
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 List <IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
IServer server = null;
if (Equals(ioStrategy.EndPoint, endpoint) || nodes.Count() == 1)
{
server = new Core.Server(ioStrategy, adapter, ClientConfig, BucketConfig);
}
else
{
var poolConfig = ClientConfig.BucketConfigs[BucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfig, endpoint);
var newIoStrategy = IOStrategyFactory(connectionPool);
var saslMechanism = SaslFactory(BucketConfig.Name, BucketConfig.Password, newIoStrategy, Converter);
newIoStrategy.SaslMechanism = saslMechanism;
server = new Core.Server(newIoStrategy, adapter, ClientConfig, BucketConfig);
}
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", BucketConfig.Rev));
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
Interlocked.Exchange(ref KeyMapper, new VBucketKeyMapper(Servers, BucketConfig.VBucketServerMap)
{
Rev = BucketConfig.Rev
});
}
finally
{
Lock.ExitWriteLock();
}
}
/// <summary>
/// Gets the <see cref="T:System.Net.IPEndPoint" /> for the KV port for this node.
/// </summary>
/// <param name="port">The port for the <see cref="T:System.Net.IPEndPoint" /></param>
/// <returns>
/// An <see cref="T:System.Net.IPEndPoint" /> with the port passed in.
/// </returns>
public IPEndPoint GetIPEndPoint(int port)
{
var key = Hostname + ":" + port;
if (!_cachedEndPoints.TryGetValue(key, out var endPoint))
{
endPoint = IPEndPointExtensions.GetEndPoint(Hostname, port);
IsIPv6 = endPoint.AddressFamily == AddressFamily.InterNetworkV6;
_cachedEndPoints.TryAdd(key, endPoint);
}
return(endPoint);
}
/// <summary>
/// Gets the <see cref="IPEndPoint" /> for the KV port for this node.
/// </summary>
/// <param name="port">The port for the <see cref="IPEndPoint" /></param>
/// <returns>
/// An <see cref="IPEndPoint" /> with the port passed in.
/// </returns>
public IPEndPoint GetIPEndPoint(int port)
{
var key = Hostname + ":" + port;
IPEndPoint endPoint;
if (!_cachedEndPoints.TryGetValue(key, out endPoint))
{
endPoint = IPEndPointExtensions.GetEndPoint(Hostname + ":" + port);
_cachedEndPoints.TryAdd(key, endPoint);
}
return(endPoint);
}
public void When_NodeExt_And_UseSsl_Is_True_And_IPv6_IPEndpoint_Uses_Port_11207()
{
var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\config-with-nodes-ext.json");
var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson);
var clientConfig = new BucketConfiguration {
UseSsl = true
};
const string expected = "192.168.56.101:11207";
var actual = IPEndPointExtensions.GetEndPoint(serverConfig.NodesExt[0].Hostname);
Assert.AreEqual(expected, actual.ToString());
}
public void When_Node_And_UseSsl_Is_True_IPEndPoint_Uses_Port_11207()
{
var serverConfigJson = File.ReadAllText("Data\\Configuration\\config-with-nodes-ext.json");
var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson);
var clientConfig = new BucketConfiguration {
UseSsl = true
};
const string expected = "192.168.56.101:11207";
var actual = IPEndPointExtensions.GetEndPoint(serverConfig.Nodes[0], clientConfig, serverConfig);
Assert.AreEqual(expected, actual.ToString());
}
public void When_NodeAdapter_And_UseSsl_Is_True_IPEndPoint_Uses_Port_11210()
{
var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\config-with-nodes-ext.json");
var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson);
var clientConfig = new BucketConfiguration {
UseSsl = false
};
const string expected = "192.168.56.102:11210";
var actual = IPEndPointExtensions.GetEndPoint(serverConfig.GetNodes()[0], clientConfig, serverConfig);
Assert.AreEqual(expected, actual.ToString());
}
// ReSharper disable once InconsistentNaming
private void EnsureIPEndPointsAreLoaded()
{
lock (_syncObj)
{
if (_ipEndPoints == null || !_ipEndPoints.Any())
{
_ipEndPoints = new List <IPEndPoint>();
foreach (var server in ServerList)
{
_ipEndPoints.Add(IPEndPointExtensions.GetEndPoint(server));
}
}
}
}
public void When_LocalHost_And_CB251_Verify_Ports()
{
var bucketConfig =
JsonConvert.DeserializeObject <BucketConfig>(
File.ReadAllText("Data\\Configuration\\carrier-publication-config.json"));
var nodes = bucketConfig.GetNodes();
Assert.AreEqual(8091, nodes[0].MgmtApi);
Assert.AreEqual(8092, nodes[0].Views);
Assert.AreEqual(18091, nodes[0].MgmtApiSsl);
Assert.AreEqual(18092, nodes[0].ViewsSsl);
Assert.AreEqual(11210, nodes[0].KeyValue);
Assert.AreEqual(11207, nodes[0].KeyValueSsl);
Assert.AreEqual(IPEndPointExtensions.GetEndPoint(@"127.0.0.1:8092"), nodes[0].GetIPEndPoint(8092));
}
public void Test_Authenticate_With_Ssl()
{
var endpoint = IPEndPointExtensions.GetEndPoint(TestConfiguration.Settings.Hostname, 11207);
var bootstrapUri = new Uri($@"https://{endpoint.Address}:8091/pools");
var connFactory = DefaultConnectionFactory.GetGeneric <SslConnection>();
var poolFactory = ConnectionPoolFactory.GetFactory();
ClientConfiguration.IgnoreRemoteCertificateNameMismatch = true;
var poolConfig = new PoolConfiguration {
UseSsl = true, Uri = bootstrapUri, ClientConfiguration = new ClientConfiguration()
};
var pool = poolFactory(poolConfig, endpoint);
var conn = connFactory((IConnectionPool <SslConnection>)pool, new DefaultConverter(), new BufferAllocator(1024 * 16, 1024 * 16));
Assert.IsTrue(conn.IsConnected);
}
internal IVBucket GetVBucket()
{
var bucketConfig = ConfigUtil.ServerConfig.Buckets.First(x => x.Name == "default");
var vBucketServerMap = bucketConfig.VBucketServerMap;
var servers = new Dictionary <IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(IPEndPointExtensions.GetEndPoint(node.Hostname + ":" + node.KeyValue).Address,
new Server(_ioService,
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
var vBucketMap = vBucketServerMap.VBucketMap.First();
var primary = vBucketMap[0];
var replicas = new int[] { vBucketMap[1] };
return(new VBucket(servers, 0, primary, replicas, bucketConfig.Rev, vBucketServerMap));
}
internal IVBucket GetVBucket()
{
var bucketConfig = ConfigUtil.ServerConfig.Buckets.First(x => x.Name == "default");
var vBucketServerMap = bucketConfig.VBucketServerMap;
var servers = new Dictionary <IPEndPoint, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(IPEndPointExtensions.GetEndPoint(node.Hostname + ":" + node.KeyValue),
new Server(IOService,
node,
new FakeTranscoder(),
ContextFactory.GetCouchbaseContext(bucketConfig)));
}
var vBucketMap = vBucketServerMap.VBucketMap.First();
var primary = vBucketMap[0];
var replicas = new [] { vBucketMap[1] };
return(new VBucket(servers, 0, primary, replicas, bucketConfig.Rev, vBucketServerMap, "default"));
}
public void LoadConfig_When_Reused_Server_Use_Latest_NodeAdapter_Settings()
{
var initialConfig = JsonConvert.DeserializeObject <BucketConfig>(
ResourceHelper.ReadResource(@"Data\config-rev-46.json"));
var mockConnectionPool = new Mock <IConnectionPool>();
var mockIoService = new Mock <IIOService>();
mockIoService.Setup(x => x.ConnectionPool).Returns(mockConnectionPool.Object);
mockIoService.Setup(x => x.SupportsEnhancedDurability).Returns(true);
var mockSasl = new Mock <ISaslMechanism>();
var clientConfig = new ClientConfiguration();
var context = new CouchbaseConfigContext(
initialConfig,
clientConfig,
p => mockIoService.Object,
(a, b) => mockConnectionPool.Object,
(a, b, c, d) => mockSasl.Object,
new DefaultTranscoder(),
null, null);
context.LoadConfig();
var server = context.GetServers().First(x => Equals(x.EndPoint, IPEndPointExtensions.GetEndPoint("172.23.120.212", 0)));
Assert.IsFalse(server.IsQueryNode);
var newConfig = JsonConvert.DeserializeObject <BucketConfig>(
ResourceHelper.ReadResource(@"Data\config-rev-60.json"));
// load first config with single node
context.LoadConfig(newConfig);
server = context.GetServers().First(x => Equals(x.EndPoint, IPEndPointExtensions.GetEndPoint("172.23.120.212", 0)));
Assert.IsTrue(server.IsQueryNode);
}
public void Test_IPv6(string ip, AddressFamily addressFamily)
{
var endPoint = IPEndPointExtensions.GetEndPoint(ip);
Assert.AreEqual(addressFamily, endPoint.AddressFamily);
}
