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); }