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 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));
}
internal override async Task Bootstrap(params ClusterNode[] bootstrapNodes)
{
//should never happen
if (bootstrapNodes == null)
{
throw new ArgumentNullException(nameof(bootstrapNodes));
}
var bootstrapNode = bootstrapNodes.FirstOrDefault();
//fetch the cluster map to avoid race condition with streaming http
BucketConfig = await _httClusterMap.GetClusterMapAsync(
Name, bootstrapNode.BootstrapUri, CancellationToken.None).ConfigureAwait(false);
KeyMapper = new KetamaKeyMapper(BucketConfig, Configuration);
//reuse the bootstrapNode
BucketNodes.AddOrUpdate(bootstrapNode.EndPoint, bootstrapNode, (key, node) => bootstrapNode);
bootstrapNode.Configuration = Configuration;
//the initial bootstrapping endpoint;
await bootstrapNode.SelectBucket(Name).ConfigureAwait(false);
Manifest = await bootstrapNode.GetManifest().ConfigureAwait(false);
LoadManifest();
LoadClusterMap(BucketConfig.GetNodes()).ConfigureAwait(false).GetAwaiter().GetResult();
bootstrapNode.Owner = this;
}
public async Task ProcessClusterMapAsync(IBucket bucket, BucketConfig config)
{
foreach (var nodeAdapter in config.GetNodes())
{
var endPoint = nodeAdapter.GetIpEndPoint(ClusterOptions.EnableTls);
if (TryGetNode(endPoint, out IClusterNode bootstrapNode))
{
Log.LogDebug($"Using existing node {endPoint} for bucket {bucket.Name} using rev#{config.Rev}");
await bootstrapNode.SelectBucket(bucket.Name);
bootstrapNode.NodesAdapter = nodeAdapter;
bootstrapNode.BuildServiceUris();
SupportsCollections = bootstrapNode.Supports(ServerFeatures.Collections);
continue; //bootstrap node is skipped because it already went through these steps
}
Log.LogDebug($"Creating node {endPoint} for bucket {bucket.Name} using rev#{config.Rev}");
var node = await ClusterNode.CreateAsync(this, endPoint);
node.Owner = bucket;
await node.SelectBucket(bucket.Name);
node.NodesAdapter = nodeAdapter;
node.BuildServiceUris();
SupportsCollections = node.Supports(ServerFeatures.Collections);
AddNode(node);
}
PruneNodes(config);
}
public async Task InitializeAsync()
{
// DNS-SRV
if (ClusterOptions.IsValidDnsSrv())
{
try
{
var bootstrapUri = ClusterOptions.ConnectionString.GetDnsBootStrapUri();
var servers = await ClusterOptions.DnsResolver.GetDnsSrvEntriesAsync(bootstrapUri);
if (servers.Any())
{
Log.LogInformation($"Successfully retrieved DNS SRV entries: [{string.Join(",", servers)}]");
ClusterOptions.WithServers(servers);
}
}
catch (Exception exception)
{
Log.LogInformation(exception, "Error trying to retrieve DNS SRV entries.");
}
}
foreach (var server in ClusterOptions.Servers)
{
var bsEndpoint = server.GetIpEndPoint(ClusterOptions.KvPort, ClusterOptions.EnableIPV6Addressing);
var node = await ClusterNode.CreateAsync(this, bsEndpoint);
node.BootstrapUri = server;
GlobalConfig = await node.GetClusterMap();
if (GlobalConfig == null) //TODO NCBC-1966 xerror info is being hidden, so on failure this will not be null
{
AddNode(node); //GCCP is not supported - pre-6.5 server fall back to CCCP like SDK 2
}
else
{
foreach (var nodeAdapter in GlobalConfig.GetNodes()) //Initialize cluster nodes for global services
{
if (server.Host.Equals(nodeAdapter.Hostname)) //this is the bootstrap node so update
{
node.BootstrapUri = server;
node.NodesAdapter = nodeAdapter;
node.BuildServiceUris();
AddNode(node);
}
else
{
var endpoint = nodeAdapter.GetIpEndPoint(ClusterOptions.UseSsl);
var newNode = await ClusterNode.CreateAsync(this, endpoint);
newNode.BootstrapUri = server;
newNode.NodesAdapter = nodeAdapter;
newNode.BuildServiceUris();
AddNode(newNode);
}
}
}
}
}
internal async Task InitializeAsync()
{
//try to connect via GCCP
foreach (var uri in _clusterOptions.Servers)
{
try
{
var endPoint = uri.GetIpEndPoint(11210, false);
var bootstrapNode = await GetClusterNode(endPoint, uri).ConfigureAwait(false);
//note this returns bucketConfig, but clusterConfig will be returned once server supports GCCP
_clusterConfig = await bootstrapNode.GetClusterMap().ConfigureAwait(false);
if (_clusterConfig == null)//TODO fix bug NCBC-1966 - hiding XError when no error map (and others)
{
//No GCCP but we connected - save connections and info for connecting later
_clusterOptions.GlobalNodes.Add(bootstrapNode);
}
else
{
foreach (var nodesExt in _clusterConfig.GetNodes())
{
//This is the bootstrap node so we update it
if (uri.Host == nodesExt.Hostname)
{
bootstrapNode.NodesAdapter = nodesExt;
bootstrapNode.BuildServiceUris();
_clusterOptions.GlobalNodes.Add(bootstrapNode);
}
else
{
endPoint = IpEndPointExtensions.GetEndPoint(nodesExt.Hostname, 11210);
var clusterNode = await GetClusterNode(endPoint, uri).ConfigureAwait(false);
clusterNode.NodesAdapter = nodesExt;
clusterNode.BuildServiceUris();
_clusterOptions.GlobalNodes.Add(clusterNode);
}
}
// get cluster capabilities
UpdateClusterCapabilities(_clusterConfig.GetClusterCapabilities());
_hasBootStrapped = true;
}
}
catch (AuthenticationException e)
{
//auth failed so bubble up exception and clean up resources
Log.LogError(e, @"Could not authenticate user {_clusterOptions.UserName}");
while (_clusterOptions.GlobalNodes.TryTake(out IClusterNode clusterNode))
{
clusterNode.Dispose();
}
throw;
}
}
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public override void LoadConfig()
{
var servers = new Dictionary <IPEndPoint, IServer>();
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
if (adapter.IsDataNode) //a data node so create a connection pool
{
var uri = UrlUtil.GetBaseUri(adapter, clientBucketConfig);
var connectionPool = ConnectionPoolFactory(clientBucketConfig.ClonePoolConfiguration(uri), endpoint);
connectionPool.SaslMechanism = SaslFactory(UserName, Password, connectionPool, Transcoder);
connectionPool.Initialize();
var ioService = IOServiceFactory(connectionPool);
var server = new Core.Server(ioService, adapter, ClientConfig, BucketConfig, Transcoder);
servers.Add(endpoint, server);
}
}
catch (Exception e)
{
Log.Error("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
//If servers is empty that means we could not initialize _any_ nodes
//We fail-fast here so that the problem can be indentified and handled.
if (!servers.Any())
{
throw new CouchbaseBootstrapException(ExceptionUtil.BootStrapFailedMsg);
}
//for kv requests
var newDataNodes = servers
.Where(x => x.Value.IsDataNode)
.Select(x => x.Value)
.ToList();
Interlocked.Exchange(ref DataNodes, newDataNodes);
IsDataCapable = newDataNodes.Count > 0;
var old = Interlocked.Exchange(ref Servers, servers);
Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers));
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
public async Task ProcessClusterMapAsync(BucketBase bucket, BucketConfig config)
{
var ipEndPointService = ServiceProvider.GetRequiredService <IIpEndPointService>();
foreach (var nodeAdapter in config.GetNodes())
{
var endPoint = await ipEndPointService.GetIpEndPointAsync(nodeAdapter, CancellationToken).ConfigureAwait(false);
if (Nodes.TryGet(endPoint, out var bootstrapNode))
{
if (bootstrapNode.Owner == null)
{
_logger.LogDebug(
"Using existing node {endPoint} for bucket {bucket.Name} using rev#{config.Rev}",
_redactor.SystemData(endPoint), _redactor.MetaData(bucket.Name), config.Rev);
if (bootstrapNode.HasKv)
{
await bootstrapNode.SelectBucketAsync(bucket, CancellationToken).ConfigureAwait(false);
}
bootstrapNode.NodesAdapter = nodeAdapter;
SupportsCollections = bootstrapNode.Supports(ServerFeatures.Collections);
bucket.Nodes.Add(bootstrapNode);
continue;
}
}
if (bucket.Nodes.TryGet(endPoint, out var bucketNode))
{
continue;
}
_logger.LogDebug("Creating node {endPoint} for bucket {bucket.Name} using rev#{config.Rev}",
_redactor.SystemData(endPoint), _redactor.MetaData(bucket.Name), config.Rev);
var node = await _clusterNodeFactory.CreateAndConnectAsync(
// We want the BootstrapEndpoint to use the host name, not just the IP
new HostEndpoint(nodeAdapter.Hostname, endPoint.Port),
CancellationToken).ConfigureAwait(false);
node.NodesAdapter = nodeAdapter;
if (node.HasKv)
{
await node.SelectBucketAsync(bucket, CancellationToken).ConfigureAwait(false);
}
SupportsCollections = node.Supports(ServerFeatures.Collections);
AddNode(node);
bucket.Nodes.Add(node);//may remove
}
await PruneNodesAsync(config).ConfigureAwait(false);
}
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();
}
}
internal override void ConfigUpdated(object sender, BucketConfigEventArgs e)
{
if (e.Config.Name == Name && e.Config.Rev > BucketConfig.Rev)
{
BucketConfig = e.Config;
KeyMapper = new KetamaKeyMapper(BucketConfig, ClusterOptions);
if (BucketConfig.ClusterNodesChanged)
{
LoadClusterMap(BucketConfig.GetNodes()).ConfigureAwait(false).GetAwaiter().GetResult();
Prune(BucketConfig);
}
}
}
private IList <IPEndPoint> GetIpEndPoints(BucketConfig config)
{
var ipEndPoints = new List <IPEndPoint>();
foreach (var node in config.GetNodes())
{
if (node.IsDataNode)
{
ipEndPoints.Add(node.GetIpEndPoint());
}
}
return(ipEndPoints);
}
private IList <HostEndpointWithPort> GetEndPoints(BucketConfig config)
{
var endPoints = new List <HostEndpointWithPort>();
foreach (var node in config.GetNodes().Where(p => p.IsKvNode))
{
//log any alternate address mapping
_logger.LogInformation(node.ToString());
endPoints.Add(HostEndpointWithPort.Create(node, _clusterOptions));
}
return(endPoints);
}
public override void LoadConfig()
{
var servers = new Dictionary <IPAddress, IServer>();
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
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);
}
}
//for kv requests
var newDataNodes = servers
.Where(x => x.Value.IsDataNode)
.Select(x => x.Value)
.ToList();
Interlocked.Exchange(ref DataNodes, newDataNodes);
IsDataCapable = newDataNodes.Count > 0;
var old = Interlocked.Exchange(ref Servers, servers);
Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers));
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
private async Task <IList <IPEndPoint> > GetIpEndPointsAsync(BucketConfig config, CancellationToken cancellationToken)
{
var ipEndPoints = new List <IPEndPoint>();
foreach (var node in config.GetNodes().Where(p => p.IsKvNode))
{
var ipEndPoint = await _ipEndPointService.GetIpEndPointAsync(node, cancellationToken);
if (ipEndPoint == null)
{
throw new InvalidOperationException("IP endpoint lookup failed.");
}
ipEndPoints.Add(ipEndPoint);
}
return(ipEndPoints);
}
internal override async Task Bootstrap(params ClusterNode[] bootstrapNodes)
{
//should never happen
if (bootstrapNodes == null)
{
throw new ArgumentNullException(nameof(bootstrapNodes));
}
List <NodeAdapter> nodeAdapters = null;
var bootstrapNode = bootstrapNodes.First();
//reuse the bootstrapNode
BucketNodes.AddOrUpdate(bootstrapNode.EndPoint, bootstrapNode, (key, node) => bootstrapNode);
bootstrapNode.Configuration = Configuration;
//the initial bootstrapping endpoint;
await bootstrapNode.SelectBucket(Name).ConfigureAwait(false);
Manifest = await bootstrapNode.GetManifest().ConfigureAwait(false);
SupportsCollections = bootstrapNode.Supports(ServerFeatures.Collections);
BucketConfig = await bootstrapNode.GetClusterMap().ConfigureAwait(false);
KeyMapper = new VBucketKeyMapper(BucketConfig);
nodeAdapters = BucketConfig.GetNodes();
if (nodeAdapters.Count == 1)
{
var nodeAdapter = nodeAdapters.First();
bootstrapNode.NodesAdapter = nodeAdapter;
}
else
{
bootstrapNode.NodesAdapter =
nodeAdapters.Find(x => x.Hostname == bootstrapNode.BootstrapUri.Host);
}
LoadManifest();
LoadClusterMap(nodeAdapters).ConfigureAwait(false).GetAwaiter().GetResult();
bootstrapNode.Owner = this;
}
public async Task PruneNodesAsync(BucketConfig config)
{
var ipEndpointService = ServiceProvider.GetRequiredService <IIpEndPointService>();
var existingEndpoints = await config.GetNodes().ToAsyncEnumerable()
.SelectAwait(p => ipEndpointService.GetIpEndPointAsync(p, CancellationToken))
.ToListAsync(CancellationToken).ConfigureAwait(false);
_logger.LogDebug("ExistingEndpoints: {endpoints}, revision {revision}.", existingEndpoints, config.Rev);
var removedEndpoints = Nodes.Where(x =>
!existingEndpoints.Any(y => x.KeyEndPoints.Any(z => z.Address.Equals(y.Address))));
_logger.LogDebug("RemovedEndpoints: {endpoints}, revision {revision}", removedEndpoints, config.Rev);
foreach (var node in removedEndpoints)
{
RemoveNode(node);
}
}
private async Task <IList <IPEndPoint> > GetIpEndPointsAsync(BucketConfig config, CancellationToken cancellationToken)
{
var ipEndPoints = new List <IPEndPoint>();
foreach (var node in config.GetNodes().Where(p => p.IsKvNode))
{
//log any alternate address mapping
_logger.LogInformation(node.ToString());
var ipEndPoint = await _ipEndPointService.GetIpEndPointAsync(node, cancellationToken).ConfigureAwait(false);
if (ipEndPoint == null)
{
throw new InvalidOperationException("IP endpoint lookup failed.");
}
ipEndPoints.Add(ipEndPoint);
}
return(ipEndPoints);
}
internal override async Task Bootstrap(params IClusterNode[] bootstrapNodes)
{
var bootstrapNode = bootstrapNodes.FirstOrDefault();
//fetch the cluster map to avoid race condition with streaming http
BucketConfig = await _httpClusterMap.GetClusterMapAsync(
Name, bootstrapNode.BootstrapUri, CancellationToken.None).ConfigureAwait(false);
KeyMapper = new KetamaKeyMapper(BucketConfig, ClusterOptions);
//reuse the bootstrapNode
BucketNodes.AddOrUpdate(bootstrapNode.EndPoint, bootstrapNode, (key, node) => bootstrapNode);
bootstrapNode.ClusterOptions = ClusterOptions;
//the initial bootstrapping endpoint;
await bootstrapNode.SelectBucket(Name).ConfigureAwait(false);
LoadManifest();
LoadClusterMap(BucketConfig.GetNodes()).ConfigureAwait(false).GetAwaiter().GetResult();
bootstrapNode.Owner = this;
}
public async Task ProcessClusterMapAsync(IBucket bucket, BucketConfig config)
{
foreach (var nodeAdapter in config.GetNodes())
{
var endPoint = nodeAdapter.GetIpEndPoint(ClusterOptions.UseSsl);
if (TryGetNode(endPoint, out IClusterNode bootstrapNode))
{
await bootstrapNode.SelectBucket(bucket.Name);
bootstrapNode.NodesAdapter = nodeAdapter;
bootstrapNode.BuildServiceUris();
continue; //bootstrap node is skipped because it already went through these steps
}
var node = await ClusterNode.CreateAsync(this, endPoint);
await node.SelectBucket(bucket.Name);
node.NodesAdapter = nodeAdapter;
node.BuildServiceUris();
AddNode(node);
}
PruneNodes(config);
}
/// <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.Info("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev);
var searchUris = new ConcurrentBag <FailureCountingUri>();
var queryUris = new ConcurrentBag <FailureCountingUri>();
var analyticsUris = new ConcurrentBag <FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary <IPEndPoint, IServer>();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
//The node does not have to be created or swapped out so reuse the existing mode
if (Servers.TryGetValue(endpoint, out IServer cachedServer))
{
Log.Info("Reusing node {0} for rev#{1}", endpoint, bucketConfig.Rev);
servers.Add(endpoint, cachedServer);
}
else
{
Log.Info("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev);
IServer server;
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 ioService = CreateIOService(poolConfiguration, endpoint);
server = new Core.Server(ioService, adapter, Transcoder, QueryCache, this);
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
SupportsEnhancedAuthentication = ioService.SupportsEnhancedAuthentication;
SupportsKvErrorMap = ioService.SupportsKvErrorMap;
}
else
{
server = new Core.Server(null, adapter, Transcoder, QueryCache, this);
}
servers.Add(endpoint, server);
}
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
searchUris.Add(uri);
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
queryUris.Add(uri);
}
if (adapter.IsAnalyticsNode)
{
var uri = UrlUtil.GetFailureCountingAnalyticsUri(adapter, clientBucketConfig);
analyticsUris.Add(uri);
}
}
catch (Exception e)
{
Log.Error("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);
Interlocked.Exchange(ref SearchUris, searchUris);
Interlocked.Exchange(ref AnalyticsUris, analyticsUris);
SwapServers(servers);
Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers,
bucketConfig.GetBucketServerMap(clientBucketConfig.UseSsl),
bucketConfig.Rev,
bucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
else
{
if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force)
{
Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers,
bucketConfig.GetBucketServerMap(ClientConfig.BucketConfigs[bucketConfig.Name].UseSsl),
bucketConfig.Rev,
bucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
//only the revision changed so update to it
if (bucketConfig.Rev > BucketConfig.Rev)
{
Log.Info("Only the revision changed from using rev#{0} to rev#{1}", BucketConfig.Rev, bucketConfig.Rev);
BucketConfig.Rev = bucketConfig.Rev;
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public override void LoadConfig()
{
Lock.EnterWriteLock();
try
{
Log.Info("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 analyticsUris = new ConcurrentBag <FailureCountingUri>();
var servers = new Dictionary <IPEndPoint, 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);
searchUris.Add(uri);
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
queryUris.Add(uri);
}
if (adapter.IsAnalyticsNode)
{
var uri = UrlUtil.GetFailureCountingAnalyticsUri(adapter, clientBucketConfig);
analyticsUris.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 newIoService = CreateIOService(poolConfiguration, endpoint);
server = new Core.Server(newIoService, adapter, Transcoder, QueryCache, this);
SupportsEnhancedDurability = newIoService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = newIoService.SupportsSubdocXAttributes;
SupportsEnhancedAuthentication = newIoService.SupportsEnhancedAuthentication;
SupportsKvErrorMap = newIoService.SupportsKvErrorMap;
}
else
{
server = new Core.Server(null, adapter, Transcoder, QueryCache, this);
}
servers.Add(endpoint, server);
}
catch (Exception e)
{
Log.Error("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);
Interlocked.Exchange(ref AnalyticsUris, analyticsUris);
SwapServers(servers);
var vBucketKeyMapper = new VBucketKeyMapper(Servers,
BucketConfig.GetBucketServerMap(clientBucketConfig.UseSsl),
BucketConfig.Rev,
BucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
}
finally
{
Lock.ExitWriteLock();
}
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public void LoadConfig(IIOService ioService)
{
try
{
Lock.EnterWriteLock();
Log.Info("o2-Creating the Servers list using rev#{0}", BucketConfig.Rev);
var searchUris = new ConcurrentBag <FailureCountingUri>();
var queryUris = new ConcurrentBag <FailureCountingUri>();
var analyticsUris = new ConcurrentBag <FailureCountingUri>();
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var servers = new Dictionary <IPEndPoint, IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
IServer server = null;
//The node does not have to be created or swapped out so reuse the existing mode
if (Servers.TryGetValue(endpoint, out IServer cachedServer))
{
Log.Info("Reusing node {0} for rev#{1}", endpoint, BucketConfig.Rev);
servers.Add(endpoint, cachedServer);
}
else
{
Log.Info("Creating node {0} for rev#{1}", endpoint, BucketConfig.Rev);
if (Equals(ioService.EndPoint, endpoint) || nodes.Count == 1)
{
server = new Core.Server(ioService, adapter, Transcoder, QueryCache, this);
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
SupportsEnhancedAuthentication = ioService.SupportsEnhancedAuthentication;
SupportsKvErrorMap = ioService.SupportsKvErrorMap;
}
else
{
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 newIoService = CreateIOService(poolConfiguration, endpoint);
server = new Core.Server(newIoService, adapter, Transcoder, QueryCache, this);
//Note: "ioService has" already made a HELO command to check what features
//the cluster supports (eg enhanced durability) so we are reusing the flag
//instead of having "newIoService" do it again, later.
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
SupportsEnhancedAuthentication = ioService.SupportsEnhancedAuthentication;
SupportsKvErrorMap = ioService.SupportsKvErrorMap;
}
else
{
server = new Core.Server(null, adapter, Transcoder, QueryCache, this);
}
}
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
queryUris.Add(uri);
}
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
searchUris.Add(uri);
}
if (adapter.IsAnalyticsNode)
{
var uri = UrlUtil.GetFailureCountingAnalyticsUri(adapter, clientBucketConfig);
analyticsUris.Add(uri);
}
servers.Add(endpoint, server);
}
catch (Exception e)
{
Log.Error("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);
Interlocked.Exchange(ref AnalyticsUris, analyticsUris);
SwapServers(servers);
Log.Info("Creating the KeyMapper list using rev#{0}", BucketConfig.Rev);
var vBucketKeyMapper = new VBucketKeyMapper(Servers,
BucketConfig.GetBucketServerMap(clientBucketConfig.UseSsl),
BucketConfig.Rev,
BucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
}
finally
{
Lock.ExitWriteLock();
}
}
public async Task ProcessClusterMapAsync(BucketBase bucket, BucketConfig config)
{
var ipEndPointService = ServiceProvider.GetRequiredService <IIpEndPointService>();
foreach (var nodeAdapter in config.GetNodes())
{
//log any alternate address mapping
_logger.LogInformation(nodeAdapter.ToString());
var endPoint = await ipEndPointService.GetIpEndPointAsync(nodeAdapter, CancellationToken).ConfigureAwait(false);
if (Nodes.TryGet(endPoint, out var bootstrapNode))
{
if (bootstrapNode.Owner == null && bucket.BucketType != BucketType.Memcached)
{
_logger.LogDebug(
"Using existing node {endPoint} for bucket {bucket.Name} using rev#{config.Rev}",
_redactor.SystemData(endPoint), _redactor.MetaData(bucket.Name), config.Rev);
if (bootstrapNode.HasKv)
{
await bootstrapNode.SelectBucketAsync(bucket, CancellationToken).ConfigureAwait(false);
SupportsCollections = bootstrapNode.Supports(ServerFeatures.Collections);
}
bootstrapNode.Owner = bucket;
bootstrapNode.NodesAdapter = nodeAdapter;
bucket.Nodes.Add(bootstrapNode);
continue;
}
if (bootstrapNode.Owner != null && bootstrapNode.BucketType == BucketType.Memcached)
{
_logger.LogDebug("Adding memcached node for endpoint {endpoint} using rev#{revision} for bucket {bucketName}.", _redactor.SystemData(endPoint), config.Rev, _redactor.MetaData(config.Name));
bootstrapNode.NodesAdapter = nodeAdapter;
bucket.Nodes.Add(bootstrapNode);
continue;
}
}
//If the node already exists for the endpoint, ignore it.
if (bucket.Nodes.TryGet(endPoint, out var bucketNode))
{
_logger.LogDebug("The node already exists for the endpoint {endpoint} using rev#{revision} for bucket {bucketName}.", _redactor.SystemData(endPoint), config.Rev, _redactor.MetaData(config.Name));
bucketNode.NodesAdapter = nodeAdapter;
continue;
}
_logger.LogDebug("Creating node {endPoint} for bucket {bucketName} using rev#{revision}",
_redactor.SystemData(endPoint), _redactor.MetaData(bucket.Name), config.Rev);
var bucketType = config.NodeLocator == "ketama" ? BucketType.Memcached : BucketType.Couchbase;
var node = await _clusterNodeFactory.CreateAndConnectAsync(
// We want the BootstrapEndpoint to use the host name, not just the IP
new HostEndpoint(nodeAdapter.Hostname, endPoint.Port),
bucketType,
nodeAdapter,
CancellationToken).ConfigureAwait(false);
if (node.HasKv)
{
await node.SelectBucketAsync(bucket, CancellationToken).ConfigureAwait(false);
SupportsCollections = node.Supports(ServerFeatures.Collections);
}
AddNode(node);
bucket.Nodes.Add(node);//may remove
}
await PruneNodesAsync(config).ConfigureAwait(false);
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
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 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.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 newIoStrategy = IOStrategyFactory(connectionPool);
server = new Core.Server(newIoStrategy, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
SupportsEnhancedDurability = newIoStrategy.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);
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();
}
}
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public void LoadConfig(IIOService ioService)
{
try
{
Lock.EnterWriteLock();
Log.Info("o2-Creating the Servers list using rev#{0}", BucketConfig.Rev);
var searchUris = new ConcurrentBag <FailureCountingUri>();
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;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
queryUris.Add(uri);
}
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
searchUris.Add(uri);
}
}
else
{
if (adapter.IsSearchNode)
{
var uri = UrlUtil.GetFailureCountinSearchBaseUri(adapter, clientBucketConfig);
searchUris.Add(uri);
}
if (adapter.IsQueryNode)
{
var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig);
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);
server = new Core.Server(newIoService, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
//Note: "ioService has" already made a HELO command to check what features
//the cluster supports (eg enhanced durability) so we are reusing the flag
//instead of having "newIoService" do it again, later.
SupportsEnhancedDurability = ioService.SupportsEnhancedDurability;
SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes;
}
else
{
server = new Core.Server(null, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache);
}
}
servers.Add(endpoint.Address, server);
}
catch (Exception e)
{
Log.Error("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);
Log.Info("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, BucketConfig.Name);
Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper);
if (old != null)
{
foreach (var server in old.Values)
{
server.Dispose();
}
old.Clear();
}
}
finally
{
Lock.ExitWriteLock();
}
}
/// <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
{
if (adapter.IsDataNode) //a data node so create a connection pool
{
var poolConfiguration = ClientConfig.BucketConfigs[BucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var newIoStrategy = IOStrategyFactory(connectionPool);
server = new Core.Server(newIoStrategy, adapter, ClientConfig, BucketConfig, Transcoder, QueryCache)
{
SaslFactory = SaslFactory
};
server.CreateSaslMechanismIfNotExists();
//Note: "ioStrategy has" already made a HELO command to check if
//the cluster supports enhanced durability so we are reusing the flag
//instead of having "newIoStrategy" do it again, later.
SupportsEnhancedDurability = ioStrategy.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);
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();
}
}
/// <summary>
/// Loads the current configuration setting the internal state of this configuration context.
/// </summary>
/// <param name="bucketConfig"></param>
/// <param name="force">True to force a reconfiguration.</param>
/// <exception cref="CouchbaseBootstrapException">Condition.</exception>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
if (bucketConfig == null)
{
throw new ArgumentNullException(nameof(bucketConfig));
}
var nodes = bucketConfig.GetNodes();
if (BucketConfig == null || !nodes.AreEqual(BucketConfig.GetNodes()) || force)
{
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new Dictionary <IPEndPoint, IServer>();
Log.Info("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev);
foreach (var adapter in nodes)
{
var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl);
try
{
if (adapter.IsDataNode) //a data node so create a connection pool
{
if (Servers.TryGetValue(endpoint, out IServer cachedServer))
{
servers.Add(endpoint, cachedServer);
}
else
{
var uri = UrlUtil.GetBaseUri(adapter, clientBucketConfig);
var ioService = CreateIOService(clientBucketConfig.ClonePoolConfiguration(uri),
endpoint);
var server = new Core.Server(ioService, adapter, Transcoder, this);
servers.Add(endpoint, server);
}
}
}
catch (Exception e)
{
Log.Error("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
//If servers is empty that means we could not initialize _any_ nodes
//We fail-fast here so that the problem can be indentified and handled.
if (!servers.Any())
{
throw new CouchbaseBootstrapException(ExceptionUtil.BootStrapFailedMsg);
}
var newDataNodes = servers
.Where(x => x.Value.IsDataNode)
.Select(x => x.Value)
.ToList();
Interlocked.Exchange(ref DataNodes, newDataNodes);
IsDataCapable = newDataNodes.Count > 0;
SwapServers(servers);
}
Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers));
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
}
