Merge branch '5.x' of https://github.com/elastic/elasticsearch-net into 5.x

Author: gmarz

src/Elasticsearch.Net/Auditing/AuditEvent.cs

@@ -18,6 +18,7 @@ public enum AuditEvent
 
 		MaxTimeoutReached,
 		MaxRetriesReached,
-		BadRequest
+		BadRequest,
+		NoNodesAttempted,
 	}
 }

src/Elasticsearch.Net/Configuration/ConnectionConfiguration.cs

@@ -143,6 +143,15 @@ private static void DefaultRequestDataCreated(RequestData response) { }
 		private Action<RequestData> _onRequestDataCreated = DefaultRequestDataCreated;
 		Action<RequestData> IConnectionConfigurationValues.OnRequestDataCreated => _onRequestDataCreated;
 
+		/// <summary>
+		/// The default predicate for <see cref="IConnectionPool"/> implementations that return true for <see cref="IConnectionPool.SupportsReseeding"/>
+		/// in which case master only nodes are excluded from API calls.
+		/// </summary>
+		private static bool DefaultReseedableNodePredicate(Node node) => !node.MasterOnlyNode;
+		private static bool DefaultNodePredicate(Node node) => true;
+		private Func<Node, bool> _nodePredicate = DefaultNodePredicate;
+		Func<Node, bool> IConnectionConfigurationValues.NodePredicate => _nodePredicate;
+
 		private readonly NameValueCollection _queryString = new NameValueCollection();
 		NameValueCollection IConnectionConfigurationValues.QueryStringParameters => _queryString;
 
@@ -176,6 +185,8 @@ protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection co
 			this._sniffOnConnectionFault = true;
 			this._sniffOnStartup = true;
 			this._sniffLifeSpan = TimeSpan.FromHours(1);
+			if (this._connectionPool.SupportsReseeding)
+				this._nodePredicate = DefaultReseedableNodePredicate;
 		}
 
 		private T Assign(Action<ConnectionConfiguration<T>> assigner) => Fluent.Assign((T)this, assigner);
@@ -363,6 +374,19 @@ public T BasicAuthentication(string userName, string password) =>
 		/// </summary>
 		public T EnableHttpPipelining(bool enabled = true) => Assign(a => a._enableHttpPipelining = enabled);
 
+		/// <summary>
+		/// Register a predicate to select which nodes that you want to execute API calls on. Note that sniffing requests omit this predicate and always execute on all nodes.
+		/// When using an <see cref="IConnectionPool"/> implementation that supports reseeding of nodes, this will default to omitting master only node from regular API calls.
+		/// When using static or single node connection pooling it is assumed the list of node you instantiate the client with should be taken verbatim.
+		/// </summary>
+		/// <param name="predicate">Return true if you want the node to be used for API calls</param>
+		public T NodePredicate(Func<Node, bool> predicate)
+		{
+			if (predicate == null) return (T) this;
+			this._nodePredicate = predicate;
+			return (T)this;
+		}
+
 		/// <summary>
 		/// Turns on settings that aid in debugging like DisableDirectStreaming() and PrettyJson()
 		/// so that the original request and response JSON can be inspected.

src/Elasticsearch.Net/Configuration/IConnectionConfigurationValues.cs

@@ -171,5 +171,12 @@ public interface IConnectionConfigurationValues : IDisposable
 		/// received.
 		/// </summary>
 		TimeSpan? KeepAliveInterval { get; }
+
+		/// <summary>
+		/// Register a predicate to select which nodes that you want to execute API calls on. Note that sniffing requests omit this predicate and always execute on all nodes.
+		/// When using an <see cref="IConnectionPool"/> implementation that supports reseeding of nodes, this will default to omitting master only node from regular API calls.
+		/// When using static or single node connection pooling it is assumed the list of node you instantiate the client with should be taken verbatim.
+		/// </summary>
+		Func<Node, bool> NodePredicate { get; }
 	}
 }

src/Elasticsearch.Net/ConnectionPool/IConnectionPool.cs

@@ -6,8 +6,8 @@ namespace Elasticsearch.Net
 	public interface IConnectionPool : IDisposable
 	{
 		/// <summary>
-		/// Returns a readonly constant view of all the nodes in the cluster, this might involve creating copies of the nodes e.g 
-		/// if you are using the sniffing connectionpool. If you do not need an isolated copy of the nodes please read `CreateView()` to completion
+		/// Returns a readonly constant view of all the nodes in the cluster, this might involve creating copies of the nodes e.g
+		/// if you are using the sniffing connectionpool. If you do not need an isolated copy of the nodes please read <see cref="CreateView"/> to completion
 		/// </summary>
 		IReadOnlyCollection<Node> Nodes { get; }
 
@@ -17,7 +17,7 @@ public interface IConnectionPool : IDisposable
 		/// in the connection settings
 		/// </summary>
 		int MaxRetries { get; }
-		
+
 		/// <summary>
 		/// Signals that this implemenation can accept new nodes
 		/// </summary>
@@ -50,4 +50,4 @@ public interface IConnectionPool : IDisposable
 		void Reseed(IEnumerable<Node> nodes);
 
 	}
-}
+}

src/Elasticsearch.Net/ConnectionPool/Node.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Purify;
 
 namespace Elasticsearch.Net
@@ -32,12 +34,22 @@ public Node(Uri uri)
 		/// <summary>Indicates whether this node is master eligible, defaults to true when unknown/unspecified</summary>
 		public bool MasterEligible { get; set; }
 
+		/// <summary>Indicates whether this node is allowed to run ingest pipelines, defaults to true when unknown/unspecified</summary>
+		public bool IngestEnabled { get; set; }
+
+		public bool MasterOnlyNode => this.MasterEligible && !this.HoldsData;
+
+		public bool ClientNode => !this.MasterEligible && !this.HoldsData;
+
 		/// <summary>The id of the node, defaults to null when unknown/unspecified</summary>
 		public string Id { get; set; }
 
 		/// <summary>The name of the node, defaults to null when unknown/unspecified</summary>
 		public string Name { get; set; }
 
+		private static readonly IReadOnlyDictionary<string, string> EmptySettings = new ReadOnlyDictionary<string, string>(new Dictionary<string, string>());
+		public IReadOnlyDictionary<string, string> Settings { get; set; } = EmptySettings;
+
 		/// <summary> The number of failed attempts trying to use this node, resets when a node is marked alive</summary>
 		public int FailedAttempts { get; private set; }
 
@@ -74,15 +86,17 @@ public Node Clone() =>
 				MasterEligible = this.MasterEligible,
 				FailedAttempts = this.FailedAttempts,
 				DeadUntil = this.DeadUntil,
-				IsAlive = this.IsAlive
+				IsAlive = this.IsAlive,
+				Settings = this.Settings,
+				IngestEnabled = this.IngestEnabled,
+				HttpEnabled = this.HttpEnabled
 			};
 
 
-		// ReSharper disable once PossibleNullReferenceException
-		public static bool operator ==(Node left, Node right) => left.Equals(right);
+		public static bool operator ==(Node left, Node right) =>
+			ReferenceEquals(left, null) ? ReferenceEquals(right, null) : left.Equals(right);
 
-		// ReSharper disable once PossibleNullReferenceException
-		public static bool operator !=(Node left, Node right) => !left.Equals(right);
+		public static bool operator !=(Node left, Node right) => !(left == right);
 
 		public static implicit operator Node(Uri uri) => new Node(uri);
 

src/Elasticsearch.Net/ConnectionPool/SingleNodeConnectionPool.cs

@@ -5,21 +5,31 @@ namespace Elasticsearch.Net
 {
 	public class SingleNodeConnectionPool : IConnectionPool
 	{
+		/// <inheritdoc/>
 		public int MaxRetries => 0;
 
+		/// <inheritdoc/>
 		public bool SupportsReseeding => false;
+
+		/// <inheritdoc/>
 		public bool SupportsPinging => false;
 
+		/// <inheritdoc/>
 		public void Reseed(IEnumerable<Node> nodes) { } //ignored
-		
+
+		/// <inheritdoc/>
 		public bool UsingSsl { get; }
 
+		/// <inheritdoc/>
 		public bool SniffedOnStartup { get { return true; } set {  } }
 
+		/// <inheritdoc/>
 		public IReadOnlyCollection<Node> Nodes { get; }
 
+		/// <inheritdoc/>
 		public DateTime LastUpdate { get; }
 
+		/// <inheritdoc/>
 		public SingleNodeConnectionPool(Uri uri, IDateTimeProvider dateTimeProvider = null)
 		{
 			var node = new Node(uri);
@@ -28,6 +38,7 @@ public SingleNodeConnectionPool(Uri uri, IDateTimeProvider dateTimeProvider = nu
 			this.LastUpdate = (dateTimeProvider ?? DateTimeProvider.Default).Now();
 		}
 
+		/// <inheritdoc/>
 		public IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null) => this.Nodes;
 
 		void IDisposable.Dispose() => this.DisposeManagedResources();

src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs

@@ -9,7 +9,10 @@ public class SniffingConnectionPool : StaticConnectionPool
 	{
 		private readonly ReaderWriterLockSlim _readerWriter = new ReaderWriterLockSlim();
 
+		/// <inheritdoc/>
 		public override bool SupportsReseeding => true;
+
+		/// <inheritdoc/>
 		public override bool SupportsPinging => true;
 
 		public SniffingConnectionPool(IEnumerable<Uri> uris, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
@@ -20,6 +23,13 @@ public SniffingConnectionPool(IEnumerable<Node> nodes, bool randomize = true, ID
 			: base(nodes, randomize, dateTimeProvider)
 		{ }
 
+		public SniffingConnectionPool(IEnumerable<Node> nodes, Func<Node, bool> predicate, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
+			: base(nodes, randomize, dateTimeProvider)
+		{ }
+
+		private static bool DefaultPredicate(Node node) => !node.MasterOnlyNode;
+
+		/// <inheritdoc/>
 		public override IReadOnlyCollection<Node> Nodes
 		{
 			get
@@ -38,6 +48,7 @@ public override IReadOnlyCollection<Node> Nodes
 			}
 		}
 
+		/// <inheritdoc/>
 		public override void Reseed(IEnumerable<Node> nodes)
 		{
 			if (!nodes.HasAny()) return;
@@ -60,6 +71,7 @@ public override void Reseed(IEnumerable<Node> nodes)
 			}
 		}
 
+		/// <inheritdoc/>
 		public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
 		{
 			try
@@ -79,4 +91,4 @@ protected override void DisposeManagedResources()
 			base.DisposeManagedResources();
 		}
 	}
-}
+}

src/Elasticsearch.Net/ConnectionPool/StaticConnectionPool.cs

@@ -13,19 +13,27 @@ public class StaticConnectionPool : IConnectionPool
 
 		protected List<Node> InternalNodes { get; set; }
 
+		/// <inheritdoc/>
 		public virtual IReadOnlyCollection<Node> Nodes => this.InternalNodes;
 
+		/// <inheritdoc/>
 		public int MaxRetries => this.InternalNodes.Count - 1;
 
+		/// <inheritdoc/>
 		public virtual bool SupportsReseeding => false;
+		/// <inheritdoc/>
 		public virtual bool SupportsPinging => true;
 
+		/// <inheritdoc/>
 		public virtual void Reseed(IEnumerable<Node> nodes) { } //ignored
 
+		/// <inheritdoc/>
 		public bool UsingSsl { get; }
 
+		/// <inheritdoc/>
 		public bool SniffedOnStartup { get; set; }
 
+		/// <inheritdoc/>
 		public DateTime LastUpdate { get; protected set; }
 
 		public StaticConnectionPool(IEnumerable<Uri> uris, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
@@ -101,4 +109,4 @@ public virtual IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = nul
 
 		protected virtual void DisposeManagedResources() { }
 	}
-}
+}

src/Elasticsearch.Net/Exceptions/ElasticsearchClientException.cs

@@ -44,8 +44,9 @@ public string DebugInformation
 				{
 					failureReason = "Unrecoverable/Unexpected " + this.AuditTrail.Last().Event.GetStringValue();
 				}
+				var path = Request.Uri != null ? Request.Uri.ToString() : Request.Path + " on an empty node, likely a node predicate on ConnectionSettings not matching ANY nodes";
 
-				sb.AppendLine($"# FailureReason: {failureReason} while attempting {Request.Method.GetStringValue()} {Request.Uri}");
+				sb.AppendLine($"# FailureReason: {failureReason} while attempting {Request.Method.GetStringValue()} on {path}");
 				if (this.Response != null)
 					ResponseStatics.DebugInformationBuilder(this.Response, sb);
 				else

src/Elasticsearch.Net/Responses/ElasticsearchResponse.cs

@@ -48,7 +48,7 @@ public static void DebugAuditTrail(List<Audit> auditTrail, StringBuilder sb)
 				sb.Append($" - [{a.i + 1}] {audit.Event.GetStringValue()}:");
 				if (audit.Node?.Uri != null) sb.Append($" Node: {audit.Node.Uri}");
 				if (audit.Exception != null) sb.Append($" Exception: {audit.Exception.GetType().Name}");
-				sb.AppendLine($" Took: {(audit.Ended - audit.Started)}");
+				sb.AppendLine($" Took: {(audit.Ended - audit.Started).ToString()}");
 			}
 		}
 	}