public SearchClient(IBucketConfig bucketConfig, ClientConfiguration clientConfig, IDataMapper dataMapper, ILogger logger) { _bucketConfig = bucketConfig; _clientConfig = clientConfig; DataMapper = dataMapper; Log = logger; }
/// <summary> /// Loads the current configuration setting the internal state of this configuration context. /// </summary> /// <param name="bucketConfig"></param> public override void LoadConfig(IBucketConfig bucketConfig) { if (bucketConfig == null) throw new ArgumentNullException("bucketConfig"); if (BucketConfig == null || !BucketConfig.Nodes.AreEqual<Node>(bucketConfig.Nodes)) { var servers = new List<IServer>(); foreach (var node in bucketConfig.Nodes) { var endpoint = GetEndPoint(node, bucketConfig); try { var connectionPool = ConnectionPoolFactory(ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration, endpoint); var ioStrategy = IOStrategyFactory(connectionPool); var server = new Core.Server(ioStrategy, node, ClientConfig); var saslMechanism = SaslFactory(bucketConfig.Name, bucketConfig.Password, ioStrategy, Converter); 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)); Interlocked.Exchange(ref _bucketConfig, bucketConfig); }
/// <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("bucketConfig"); if (BucketConfig == null || !BucketConfig.Nodes.AreEqual<Node>(bucketConfig.Nodes) || force) { var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name]; var servers = new Dictionary<IPAddress, IServer>(); var nodes = bucketConfig.GetNodes(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { if (adapter.IsDataNode) //a data node so create a connection pool { 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); } } //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; var old = Interlocked.Exchange(ref Servers, servers); if (old != null) { foreach (var server in old.Values) { server.Dispose(); } old.Clear(); } } Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers)); Interlocked.Exchange(ref _bucketConfig, bucketConfig); }
public MemcachedConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool, IIOService> ioServiceFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IIOService, ITypeTranscoder, ISaslMechanism> saslFactory, ITypeTranscoder transcoder) : base(bucketConfig, clientConfig, ioServiceFactory, connectionPoolFactory, saslFactory, transcoder) { }
public CouchbaseConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool, IOStrategy> ioStrategyFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IOStrategy, ITypeTranscoder, ISaslMechanism> saslFactory, ITypeTranscoder transcoder) : base(bucketConfig, clientConfig, ioStrategyFactory, connectionPoolFactory, saslFactory, transcoder) { }
/// <summary> /// Gets an <see cref="IPEndPoint"/> instance for a given Node and <see cref="IBucketConfig"/> /// </summary> /// <param name="node"></param> /// <param name="bucketConfig"></param> /// <returns></returns> protected IPEndPoint GetEndPoint(Node node, IBucketConfig bucketConfig) { const string couchbasePort = "8091"; const string blah = "$HOST"; var address = node.Hostname.Replace(blah, bucketConfig.SurrogateHost); address = address.Replace(couchbasePort, node.Ports.Direct.ToString(CultureInfo.InvariantCulture)); return UriExtensions.GetEndPoint(address); }
public MemcachedConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool, IOStrategy> ioStrategyFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IOStrategy, IByteConverter, ISaslMechanism> saslFactory, IByteConverter converter, ITypeSerializer serializer) : base(bucketConfig, clientConfig, ioStrategyFactory, connectionPoolFactory, saslFactory, converter, serializer) { }
public MemcachedConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool,ILoggerFactory, IIOService> ioServiceFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IIOService, ITypeTranscoder, ISaslMechanism> saslFactory, ITypeTranscoder transcoder, ILoggerFactory loggerFactory) : base(bucketConfig, clientConfig, ioServiceFactory, connectionPoolFactory, saslFactory, transcoder, loggerFactory) { _loggerFactory = loggerFactory; Log = _loggerFactory.CreateLogger<MemcachedConfigContext>(); }
public CouchbaseConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool, IIOService> ioServiceFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IIOService, ITypeTranscoder, ISaslMechanism> saslFactory, ITypeTranscoder transcoder) : base(bucketConfig, clientConfig, ioServiceFactory, connectionPoolFactory, saslFactory, transcoder) { //for caching query plans QueryCache = new ConcurrentDictionary<string, QueryPlan>(); }
/// <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) { try { Lock.EnterWriteLock(); if (bucketConfig == null) throw new ArgumentNullException("bucketConfig"); if (BucketConfig == null || !BucketConfig.Nodes.AreEqual<Node>(bucketConfig.Nodes) || !Servers.Any()) { Log.Info(m => m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(), bucketConfig.Rev)); var servers = new List<IServer>(); var nodes = bucketConfig.Nodes; for (var i = 0; i < nodes.Length; i++) { var ip = bucketConfig.VBucketServerMap.ServerList[i]; var endpoint = GetEndPoint(ip, bucketConfig); try { var connectionPool = ConnectionPoolFactory(ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration, endpoint); var ioStrategy = IOStrategyFactory(connectionPool); var saslMechanism = SaslFactory(bucketConfig.Name, bucketConfig.Password, ioStrategy, Converter); ioStrategy.SaslMechanism = saslMechanism; var server = new Core.Server(ioStrategy, nodes[i], ClientConfig); servers.Add(server); } catch (Exception e) { Log.ErrorFormat("Could not add server {0}. Exception: {1}", ip, 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 }); } 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> public override void LoadConfig(IBucketConfig bucketConfig, bool force = false) { if (bucketConfig == null) throw new ArgumentNullException("bucketConfig"); if (BucketConfig == null || !BucketConfig.Nodes.AreEqual<Node>(bucketConfig.Nodes) || force) { var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name]; var servers = new Dictionary<IPAddress, IServer>(); var nodes = bucketConfig.GetNodes(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { 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); } } 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); if (old != null) { foreach (var server in old.Values) { server.Dispose(); } old.Clear(); } } Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers)); Interlocked.Exchange(ref _bucketConfig, bucketConfig); }
protected ConfigContextBase(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool, IOStrategy> ioStrategyFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IOStrategy, ITypeTranscoder, ISaslMechanism> saslFactory, ITypeTranscoder transcoder) { _bucketConfig = bucketConfig; _clientConfig = clientConfig; IOStrategyFactory = ioStrategyFactory; ConnectionPoolFactory = connectionPoolFactory; _creationTime = DateTime.Now; SaslFactory = saslFactory; Transcoder = transcoder; }
public void SetUp() { _bucketConfig = ConfigUtil.ServerConfig.Buckets.First(x=>x.Name =="default"); _vBucketServerMap = _bucketConfig.VBucketServerMap; _servers = new Dictionary<IPAddress, IServer>(); foreach (var node in _bucketConfig.GetNodes()) { _servers.Add(node.GetIPAddress(), new Server(new FakeIOService(node.GetIPEndPoint(), new FakeConnectionPool(), false), node, new ClientConfiguration(), _bucketConfig, new FakeTranscoder())); } }
public static IPEndPoint GetEndPoint(NodeExt nodeExt, BucketConfiguration bucketConfig, IBucketConfig serverConfig) { var address = nodeExt.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(ClientConfiguration.UseInterNetworkV6Addresses); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = bucketConfig.UseSsl ? nodeExt.Services.KvSSL : nodeExt.Services.KV; return new IPEndPoint(ipAddress, port); }
protected ConfigContextBase(IBucketConfig bucketConfig, ClientConfiguration clientConfig, Func<IConnectionPool, ILoggerFactory, IIOService> ioServiceFactory, Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory, Func<string, string, IIOService, ITypeTranscoder, ISaslMechanism> saslFactory, ITypeTranscoder transcoder, ILoggerFactory loggerFactory) { _loggerFactory = loggerFactory; Log = _loggerFactory.CreateLogger<ConfigContextBase>(); _bucketConfig = bucketConfig; _clientConfig = clientConfig; IOServiceFactory = ioServiceFactory; ConnectionPoolFactory = connectionPoolFactory; _creationTime = DateTime.Now; SaslFactory = saslFactory; Transcoder = transcoder; }
public static IPEndPoint GetEndPoint(Node node, BucketConfiguration clientConfig, IBucketConfig serverConfig) { var address = node.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = clientConfig.UseSsl ? node.Ports.SslDirect : node.Ports.Direct; return new IPEndPoint(ipAddress, port); }
public static IPEndPoint GetEndPoint(INodeAdapter adapter, BucketConfiguration clientConfig, IBucketConfig server) { var address = adapter.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(ClientConfiguration.UseInterNetworkV6Addresses); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = clientConfig.UseSsl ? adapter.KeyValueSsl : adapter.KeyValue; return new IPEndPoint(ipAddress, port); }
public static IPEndPoint GetEndPoint(NodeExt nodeExt, BucketConfiguration bucketConfig, IBucketConfig serverConfig) { var address = nodeExt.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = bucketConfig.UseSsl ? nodeExt.Services.KvSSL : nodeExt.Services.KV; return(new IPEndPoint(ipAddress, port)); }
/// <summary> /// Updates the internal bootstrap url with the new list from a server configuration. /// </summary> /// <param name="bucketConfig">A new server configuration</param> internal void UpdateBootstrapList(IBucketConfig bucketConfig) { foreach (var node in bucketConfig.Nodes) { var uri = new Uri(string.Concat("http://", node.Hostname, "/pools")); ConfigLock.EnterWriteLock(); try { if (!Servers.Contains(uri)) { uri.ConfigureServicePoint(this); Servers.Add(uri); } } finally { ConfigLock.ExitWriteLock(); } } }
public bool AreNodesEqual(IBucketConfig other) { return Nodes.AreEqual(other.Nodes); }
/// <summary> /// Raised when a configuration update has occurred. All observers will be notified of the changes. /// </summary> /// <param name="bucketConfig">The new configuration.</param> void ConfigChangedHandler(IBucketConfig bucketConfig) { try { ConfigLock.EnterWriteLock(); IConfigObserver configObserver; if (!ConfigObservers.TryGetValue(bucketConfig.Name, out configObserver)) { // Observer has been unregistered return; } IConfigInfo configInfo; if (Configs.TryGetValue(configObserver.Name, out configInfo)) { var staleBucketConfig = configInfo.BucketConfig; Log.LogInformation("Config changed new Rev#{0} | old Rev#{1} HTTP: {2}", bucketConfig.Rev, staleBucketConfig.Rev, JsonConvert.SerializeObject(bucketConfig)); if (bucketConfig.Rev > staleBucketConfig.Rev) { configInfo.LoadConfig(bucketConfig); } } else { configInfo = CreateConfigInfo(bucketConfig); Configs.TryAdd(bucketConfig.Name, configInfo); } try { ClientConfig.UpdateBootstrapList(bucketConfig); configObserver.NotifyConfigChanged(configInfo); } catch (Exception e) { Log.LogError(e.Message); } SignalCountdownEvent(); } finally { ConfigLock.ExitWriteLock(); } }
void ErrorOccurredHandler(IBucketConfig bucketConfig) { //TODO provide implementation to begin the bootstrapping procss from the beginning }
internal static CouchbaseConfigContext GetCouchbaseContext(ClientConfiguration clientConfig, IBucketConfig bucketConfig) { return(new CouchbaseConfigContext(bucketConfig, clientConfig, null, null, null, null, null, null)); }
public void LoadConfig(IBucketConfig bucketConfig, bool force = false) { throw new NotImplementedException(); }
public Server(IIOService ioService, IViewClient viewClient, IQueryClient queryClient, INodeAdapter nodeAdapter, ClientConfiguration clientConfiguration, ITypeTranscoder transcoder, IBucketConfig bucketConfig) { if (ioService != null) { _ioService = ioService; _ioService.ConnectionPool.Owner = this; } _nodeAdapter = nodeAdapter; _clientConfiguration = clientConfiguration; _bucketConfiguration = clientConfiguration.BucketConfigs[bucketConfig.Name]; _timingEnabled = _clientConfiguration.EnableOperationTiming; _typeTranscoder = transcoder; _bucketConfig = bucketConfig; //services that this node is responsible for IsMgmtNode = _nodeAdapter.MgmtApi > 0; IsDataNode = _nodeAdapter.KeyValue > 0; IsQueryNode = _nodeAdapter.N1QL > 0; IsIndexNode = _nodeAdapter.IndexAdmin > 0; IsViewNode = _nodeAdapter.Views > 0; //View and query clients ViewClient = viewClient; QueryClient = queryClient; CachedViewBaseUri = UrlUtil.GetViewBaseUri(_nodeAdapter, _bucketConfiguration); CachedQueryBaseUri = UrlUtil.GetN1QLBaseUri(_nodeAdapter, _bucketConfiguration); if (IsDataNode || IsQueryNode) { _lastIOErrorCheckedTime = DateTime.Now; //On initialization, data nodes are authenticated, so they can start in a down state. //If the node is down immediately start the timer, otherwise disable it. if (IsDataNode) { _isDown = _ioService.ConnectionPool.InitializationFailed; } Log.InfoFormat("Initialization {0} for node {1}", _isDown ? "failed" : "succeeded", EndPoint); //timer and node status _heartBeatTimer = new Timer(_clientConfiguration.NodeAvailableCheckInterval) { Enabled = _isDown }; _heartBeatTimer.Elapsed += _heartBeatTimer_Elapsed; } }
/// <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 abstract void LoadConfig(IBucketConfig bucketConfig, bool force = false);
internal CouchbaseHttpClient(ClientConfiguration config, IBucketConfig bucketConfig) : this(CreateClientHandler(bucketConfig.Name, config.HasCredentials ? config.GetCredentials(bucketConfig.Name, AuthContext.BucketKv).Value : bucketConfig.Password, config)) { DefaultRequestHeaders.ExpectContinue = config.Expect100Continue; }
public void NotifyConfigPublished(IBucketConfig bucketConfig, bool force = false) { EnqueueConfigForProcessing(bucketConfig); }
/// <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)) { //The services list may have changed even though the //connections can be reused so use the latest settings cachedServer.LoadNodeAdapter(adapter); 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(); } }
/// <summary> /// Enqueues the configuration for processing by the configuration thread "CT"; Any thread can "Produce" a configuration for processing. /// </summary> /// <param name="config">The cluster map to check.</param> public void EnqueueConfigForProcessing(IBucketConfig config) { Log.Debug("Queueing config rev#{0} for [{1}].", config.Rev, config.Name); _configQueue.Add(config); }
public void UpdateConfig(IBucketConfig bucketConfig, bool force = false) { IConfigObserver configObserver; if (ConfigObservers != null && ConfigObservers.TryGetValue(bucketConfig.Name, out configObserver)) { IConfigInfo configInfo; if (Configs.TryGetValue(bucketConfig.Name, out configInfo)) { var lockTaken = false; try { Monitor.TryEnter(configInfo, ref lockTaken); if (!lockTaken) return; var oldBucketConfig = configInfo.BucketConfig; if (bucketConfig.Rev > oldBucketConfig.Rev || !bucketConfig.Equals(oldBucketConfig) || force) { Log.LogInformation("Config changed (forced:{0}) new Rev#{1} | old Rev#{2} CCCP: {3}", force, bucketConfig.Rev, oldBucketConfig.Rev, JsonConvert.SerializeObject(bucketConfig)); //Set the password on the new server configuration var clientBucketConfig = GetOrCreateConfiguration(bucketConfig.Name); bucketConfig.Password = clientBucketConfig.Password; configInfo.LoadConfig(bucketConfig, force); ClientConfig.UpdateBootstrapList(bucketConfig); configObserver.NotifyConfigChanged(configInfo); } } finally { if (lockTaken) { Monitor.Exit(configInfo); } } } else { throw new ConfigNotFoundException(bucketConfig.Name); } } else { Log.LogWarning("No ConfigObserver found for bucket [{0}]", bucketConfig.Name); } }
public Server(IIOService ioService, INodeAdapter nodeAdapter, ClientConfiguration clientConfiguration, IBucketConfig bucketConfig, ITypeTranscoder transcoder) : this(ioService, null, null, null, null, null, null, nodeAdapter, clientConfiguration, transcoder, bucketConfig) { }
public void LoadConfig(IBucketConfig bucketConfig) { throw new NotImplementedException(); }
public static IPEndPoint GetEndPoint(Node node, BucketConfiguration clientConfig, IBucketConfig serverConfig) { var address = node.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(ClientConfiguration.UseInterNetworkV6Addresses); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = clientConfig.UseSsl ? node.Ports.SslDirect : node.Ports.Direct; return(new IPEndPoint(ipAddress, port)); }
void UpdateBootstrapList(IBucketConfig bucketConfig) { lock (SyncObject) { foreach (var node in bucketConfig.Nodes) { var uri = new Uri(string.Concat("http://", node.Hostname, "/pools")); if (!_clientConfig.Servers.Contains(uri)) { _clientConfig.Servers.Add(uri); } } } }
/// <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) { var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name]; var servers = new Dictionary <IPAddress, IServer>(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { Log.Info( m => m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(), bucketConfig.Rev)); IServer server; if (adapter.IsDataNode) //a data node so create a connection pool { var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration; var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint); var ioStrategy = IOStrategyFactory(connectionPool); server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache) { SaslFactory = SaslFactory }; server.CreateSaslMechanismIfNotExists(); 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); var old = Interlocked.Exchange(ref Servers, servers); Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev)); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); if (old != null) { foreach (var server in old.Values) { server.Dispose(); } old.Clear(); } } else { if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force) { Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev)); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); } } } catch (Exception e) { Log.Error(e); } finally { Lock.ExitWriteLock(); } }
/// <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)) { //The services list may have changed even though the //connections can be reused so use the latest settings cachedServer.LoadNodeAdapter(adapter); 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); }
/// <summary> /// Creates a Bucket specific <see cref="IConfigInfo"/> instance. /// </summary> /// <param name="bucketConfig">The <see cref="IBucketConfig"/> to use for client configuration.</param> /// <returns></returns> IConfigInfo CreateConfigInfo(IBucketConfig bucketConfig) { IConfigInfo configInfo; switch (bucketConfig.NodeLocator.ToEnum<NodeLocatorEnum>()) { case NodeLocatorEnum.VBucket: configInfo = new CouchbaseConfigContext(bucketConfig, ClientConfig, IOServiceFactory, ConnectionPoolFactory, SaslFactory, Transcoder, _loggerFactory); break; case NodeLocatorEnum.Ketama: configInfo = new MemcachedConfigContext(bucketConfig, ClientConfig, IOServiceFactory, ConnectionPoolFactory, SaslFactory, Transcoder, _loggerFactory); break; default: throw new ArgumentOutOfRangeException(); } configInfo.LoadConfig(); return configInfo; }
private static AuthenticatingHttpClientHandler CreateClientHandler(ClientConfiguration clientConfiguration, IBucketConfig bucketConfig) { Log.Debug("Creating CouchbaseClientHandler."); if (clientConfiguration.HasCredentials && clientConfiguration.Authenticator.AuthenticatorType == AuthenticatorType.Password) { var credentials = clientConfiguration.Authenticator.GetCredentials(AuthContext.BucketKv).First(); return(CreateClientHandler(credentials.Key, credentials.Value, clientConfiguration)); } if (bucketConfig != null) { return(CreateClientHandler(bucketConfig.Name, bucketConfig.Password, clientConfiguration)); } // This is not a bucket-specific client, use no authentication if there are not cluster level credentials return(CreateClientHandler(null, null, clientConfiguration)); }
public void NotifyConfigPublished(IBucketConfig bucketConfig, bool force = false) { var provider = _configProviders.FirstOrDefault(x => x is CarrierPublicationProvider); if (provider != null) { var carrierPublicationProvider = provider as CarrierPublicationProvider; if (carrierPublicationProvider != null) { carrierPublicationProvider.UpdateConfig(bucketConfig, force); } } }
internal static MemcachedConfigContext GetMemcachedContext(ClientConfiguration clientConfig, IBucketConfig bucketConfig) { return(new MemcachedConfigContext(bucketConfig, clientConfig, null, null, null, null, null, null)); }
internal static CouchbaseConfigContext GetCouchbaseContext(IBucketConfig bucketConfig) { var clientConfig = new ClientConfiguration(); return(GetCouchbaseContext(clientConfig, bucketConfig)); }
/// <summary> /// Raised when a configuration update has occurred. All observers will be notified of the changes. /// </summary> /// <param name="bucketConfig">The new configuration.</param> void ConfigChangedHandler(IBucketConfig bucketConfig) { UpdateConfig(bucketConfig); }
public bool IsVBucketServerMapEqual(IBucketConfig other) { return VBucketServerMap.Equals(other.VBucketServerMap); }
public static IPEndPoint GetEndPoint(INodeAdapter adapter, BucketConfiguration clientConfig, IBucketConfig server) { var address = adapter.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = clientConfig.UseSsl ? adapter.KeyValueSsl : adapter.KeyValue; return(new IPEndPoint(ipAddress, port)); }
internal static MemcachedConfigContext GetMemcachedContext(IBucketConfig bucketConfig) { var clientConfig = new ClientConfiguration(); return(GetMemcachedContext(clientConfig, bucketConfig)); }
/// <summary> /// Loads the most updated configuration creating any resources as needed. /// </summary> /// <param name="bucketConfig">The latest <see cref="IBucketConfig"/> /// that will drive the recreation if the configuration context.</param> /// <param name="force">True to force the reconfiguration.</param> public override void LoadConfig(IBucketConfig bucketConfig, bool force = false) { try { Lock.EnterWriteLock(); if (BucketConfig == null || !BucketConfig.AreNodesEqual(bucketConfig) || !Servers.Any() || force) { var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name]; var servers = new Dictionary<IPAddress, IServer>(); var nodes = bucketConfig.GetNodes(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { Log.Info( m => m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(), bucketConfig.Rev)); var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration; var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint); var ioStrategy = IOStrategyFactory(connectionPool); var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig, Transcoder) { SaslFactory = SaslFactory }; server.CreateSaslMechanismIfNotExists(); servers.Add(endpoint.Address, server); } catch (Exception e) { Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e); } } UpdateServices(servers); var old = Interlocked.Exchange(ref Servers, servers); Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev)); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); if (old != null) { foreach (var server in old.Values) { server.Dispose(); } old.Clear(); } } else { if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force) { Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev)); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); } } } catch (Exception e) { Log.Error(e); } finally { Lock.ExitWriteLock(); } }
/// <summary> /// Loads the most updated configuration creating any resources as needed. /// </summary> /// <param name="bucketConfig">The latest <see cref="IBucketConfig"/> /// that will drive the recreation if the configuration context.</param> /// <param name="force">True to force the reconfiguration.</param> public override void LoadConfig(IBucketConfig bucketConfig, bool force = false) { try { Lock.EnterWriteLock(); var nodes = bucketConfig.GetNodes(); if (BucketConfig == null || !nodes.AreEqual(_bucketConfig.GetNodes()) || !Servers.Any() || force) { Log.InfoFormat("o1-Creating the Servers {0} list using rev#{1}", nodes.Count, bucketConfig.Rev); var queryUris = new ConcurrentBag<FailureCountingUri>(); var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name]; var servers = new Dictionary<IPAddress, IServer>(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { Log.InfoFormat("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev); IServer server; if (adapter.IsQueryNode) { var uri = UrlUtil.GetFailureCountingBaseUri(adapter, clientBucketConfig); uri.ConfigureServicePoint(ClientConfig); queryUris.Add(uri); } if (adapter.IsDataNode) //a data node so create a connection pool { var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration; var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint); var ioService = IOServiceFactory(connectionPool); server = new Core.Server(ioService, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache) { SaslFactory = SaslFactory }; server.CreateSaslMechanismIfNotExists(); SupportsEnhancedDurability = ioService.SupportsEnhancedDurability; } else { server = new Core.Server(null, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache); } servers.Add(endpoint.Address, server); } catch (Exception e) { Log.ErrorFormat("Could not add server {0} for rev#{1}. Exception: {2}", endpoint, bucketConfig.Rev, e); } } UpdateServices(servers); //for caching uri's Interlocked.Exchange(ref QueryUris, queryUris); var old = Interlocked.Exchange(ref Servers, servers); Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev)); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); if (old != null) { foreach (var server in old.Values) { Log.InfoFormat("Disposing node {0} from rev#{1}", server.EndPoint, server.Revision); server.Dispose(); } old.Clear(); } } else { if (BucketConfig == null || !BucketConfig.IsVBucketServerMapEqual(bucketConfig) || force) { Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev)); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); } } } catch (Exception e) { Log.Error(e); } finally { Lock.ExitWriteLock(); } }
internal Configuration.Server.Serialization.Services GetServicePorts(NodeExt nodeExt, IBucketConfig bucketConfig) { if (UseAlternateNetwork(nodeExt, bucketConfig) && nodeExt.AlternateAddresses?.External?.Ports != null) { return(nodeExt.AlternateAddresses.External.Ports); } return(nodeExt?.Services); }
//used by all http services internal CouchbaseHttpClient(ClientConfiguration config, IBucketConfig bucketConfig) : this(CreateClientHandler(config, bucketConfig)) { DefaultRequestHeaders.ExpectContinue = config.Expect100Continue; }
public QueryClient(HttpClient httpClient, IDataMapper dataMapper, IBucketConfig bucketConfig, ClientConfiguration clientConfig) : this(httpClient, dataMapper, bucketConfig, clientConfig, new ConcurrentDictionary <string, QueryPlan>()) { }
/// <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 <IPAddress, IServer>(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { Log.Info("Creating node {0} for rev#{1}", endpoint, bucketConfig.Rev); 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 connectionPool = ConnectionPoolFactory(poolConfiguration.Clone(uri), endpoint); var ioService = IOServiceFactory(connectionPool); server = new Core.Server(ioService, adapter, ClientConfig, bucketConfig, Transcoder, QueryCache) { SaslFactory = SaslFactory }; server.CreateSaslMechanismIfNotExists(); SupportsEnhancedDurability = ioService.SupportsEnhancedDurability; SupportsSubdocXAttributes = ioService.SupportsSubdocXAttributes; SupportsEnhancedAuthentication = ioService.SupportsEnhancedAuthentication; SupportsKvErrorMap = ioService.SupportsKvErrorMap; } 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} 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); var old = Interlocked.Exchange(ref Servers, servers); Log.Info("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev); var vBucketKeyMapper = new VBucketKeyMapper(Servers, bucketConfig.VBucketServerMap, bucketConfig.Rev, bucketConfig.Name); Interlocked.Exchange(ref KeyMapper, vBucketKeyMapper); Interlocked.Exchange(ref _bucketConfig, bucketConfig); if (old != null) { foreach (var server in old.Values) { Log.Info("Disposing node {0} from rev#{1}", server.EndPoint, server.Revision); server.Dispose(); } old.Clear(); } } 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.VBucketServerMap, 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(); } }