correct spelling of eligible

Author: russcam

src/Elasticsearch.Net/ConnectionPool/Node.cs

@@ -14,7 +14,7 @@ public Node(Uri uri)
 			this.Uri = uri.Purify();
 			this.IsAlive = true;
 			this.HoldsData = true;
-			this.MasterEligable = true;
+			this.MasterEligible = true;
 			this.IsResurrected = true;
 		}
 
@@ -26,8 +26,8 @@ public Node(Uri uri)
 		/// <summary>Indicates whether this node holds data, defaults to true when unknown/unspecified</summary>
 		public bool HoldsData { get; set; }
 
-		/// <summary>Indicates whether this node is master eligable, defaults to true when unknown/unspecified</summary>
-		public bool MasterEligable { get; set; }
+		/// <summary>Indicates whether this node is master eligible, defaults to true when unknown/unspecified</summary>
+		public bool MasterEligible { get; set; }
 
 		/// <summary>The id of the node, defaults to null when unknown/unspecified</summary>
 		public string Id { get; set; } 
@@ -68,7 +68,7 @@ public Node Clone() =>
 				Id = this.Id,
 				Name = this.Name,
 				HoldsData = this.HoldsData,
-				MasterEligable = this.MasterEligable,
+				MasterEligible = this.MasterEligible,
 				FailedAttempts = this.FailedAttempts,
 				DeadUntil = this.DeadUntil,
 				IsAlive = this.IsAlive

src/Elasticsearch.Net/Transport/Pipeline/RequestPipeline.cs

@@ -288,7 +288,7 @@ private void ThrowBadAuthPipelineExceptionWhenNeeded<TReturn>(ElasticsearchRespo
 		public IEnumerable<Node> SniffNodes => this._connectionPool
 			.CreateView((e, n)=> { using (new Auditable(e, this.AuditTrail, this._dateTimeProvider) { Node = n }) {} })
 			.ToList()
-			.OrderBy(n => n.MasterEligable ? n.Uri.Port : int.MaxValue);
+			.OrderBy(n => n.MasterEligible ? n.Uri.Port : int.MaxValue);
 
 		public void SniffOnConnectionFailure()
 		{

src/Elasticsearch.Net/Transport/Sniff/SniffResponse.cs

@@ -16,7 +16,7 @@ public IEnumerable<Node> ToNodes(bool forceHttp = false)
 				{
 					Name = kv.Value.name,
 					Id = kv.Key,
-					MasterEligable = kv.Value.MasterEligable,
+					MasterEligible = kv.Value.MasterEligible,
 					HoldsData = kv.Value.HoldsData,
 				};
 		}
@@ -34,7 +34,7 @@ internal class SniffNode
 		public string build { get; set; }
 		public IDictionary<string, string> settings { get; set; }
 
-		internal bool MasterEligable => !((this.settings?.ContainsKey("node.master")).GetValueOrDefault(false) && Convert.ToBoolean(this.settings["node.master"]) == false);
+		internal bool MasterEligible => !((this.settings?.ContainsKey("node.master")).GetValueOrDefault(false) && Convert.ToBoolean(this.settings["node.master"]) == false);
 		internal bool HoldsData => !((this.settings?.ContainsKey("node.data")).GetValueOrDefault(false) && Convert.ToBoolean(this.settings["node.data"]) == false);
 	}
 

src/Nest/Document/Multiple/Reindex/ElasticClient-Reindex.cs

@@ -7,8 +7,8 @@ public partial interface IElasticClient
         /// <summary>
         /// Helper method that allows you to reindex from one index into another using SCAN and SCROLL.
         /// </summary>
-        /// <param name="from">the index that documents should be reindexed from</param>
-        /// <param name="to">the index that documents should be reindexed to</param>
+        /// <param name="from">the index that documents will be reindexed from</param>
+        /// <param name="to">the index that documents will be reindexed to</param>
         /// <param name="selector">the descriptor to describe the reindex operation</param>
         /// <returns>An IObservable&lt;IReindexResponse&lt;T&gt;$gt; you can subscribe to to listen to the progress of the reindex process</returns>
         IObservable<IReindexResponse<T>> Reindex<T>(IndexName from, IndexName to, Func<ReindexDescriptor<T>, IReindexRequest> selector = null)
@@ -27,8 +27,8 @@ public partial class ElasticClient
         /// <summary>
         /// Helper method that allows you to reindex from one index into another using SCAN and SCROLL.
         /// </summary>
-        /// <param name="from">the index that documents should be reindexed from</param>
-        /// <param name="to">the index that documents should be reindexed to</param>
+        /// <param name="from">the index that documents will be reindexed from</param>
+        /// <param name="to">the index that documents will be reindexed to</param>
         /// <param name="selector">the descriptor to describe the reindex operation</param>
         /// <returns>An IObservable&lt;IReindexResponse&lt;T&gt;$gt; you can subscribe to to listen to the progress of the reindex process</returns>
         public IObservable<IReindexResponse<T>> Reindex<T>(IndexName from, IndexName to, Func<ReindexDescriptor<T>, IReindexRequest> selector = null)

src/Tests/ClientConcepts/ConnectionPooling/BuildingBlocks/ConnectionPooling.Doc.cs

@@ -87,13 +87,13 @@ [U] public void Sniffing()
 
 			/** Or using an enumerable of `Node`
 			* A major benefit here is you can include known node roles when seeding 
-			* NEST can use this information to favour sniffing on master eligable nodes first
-			* and take master only nodes out of rotation for issueing client calls on.
+			* NEST can use this information to favour sniffing on master eligible nodes first
+			* and take master only nodes out of rotation for issuing client calls on.
 			*/
 			var nodes = uris.Select(u=>new Node(u));
 			pool = new SniffingConnectionPool(nodes);
 
-			/** This type of pool is hardwirted to optout out sniffing*/
+			/** This type of pool is hardwired to opt out of sniffing*/
 			pool.SupportsReseeding.Should().BeTrue();
 
 			/** but supports pinging when enabled */

src/Tests/ClientConcepts/ConnectionPooling/BuildingBlocks/KeepingTrackOfNodes.Doc.cs

@@ -18,8 +18,8 @@ [U] public void Creating()
 			node.Uri.Should().NotBeNull();
 			node.Uri.Port.Should().Be(9200);
 
-			/** By default master eligable and holds data is presumed to be true **/
-			node.MasterEligable.Should().BeTrue();
+			/** By default master eligible and holds data is presumed to be true **/
+			node.MasterEligible.Should().BeTrue();
 			node.HoldsData.Should().BeTrue();
 			/** Is resurrected is true on first usage, hints to the transport that a ping might be useful */
 			node.IsResurrected.Should().BeTrue();
@@ -69,8 +69,8 @@ [U] public void MarkNodes()
 		[U] public void Equality()
 		{
 			/** Nodes are considered equal if they have the same endpoint no matter what other metadata is associated */
-			var node = new Node(new Uri("http://localhost:9200")) { MasterEligable = false };
-			var nodeAsMaster = new Node(new Uri("http://localhost:9200")) { MasterEligable = true };
+			var node = new Node(new Uri("http://localhost:9200")) { MasterEligible = false };
+			var nodeAsMaster = new Node(new Uri("http://localhost:9200")) { MasterEligible = true };
 			(node == nodeAsMaster).Should().BeTrue();
 			(node != nodeAsMaster).Should().BeFalse();
 			var uri = new Uri("http://localhost:9200");

src/Tests/ClientConcepts/ConnectionPooling/Sniffing/OnConnectionFailure.doc.cs

@@ -21,12 +21,12 @@ [U] public async Task DoesASniffAfterConnectionFailure()
 		{
 			/**
 			* Here we seed our connection with 5 known nodes 9200-9204 of which we think
-			* 9202, 9203, 9204 are master eligable nodes. Our virtualized cluster will throw once when doing 
+			* 9202, 9203, 9204 are master eligible nodes. Our virtualized cluster will throw once when doing 
 			* a search on 9201. This should a sniff to be kicked off.
 			*/
 			var audit = new Auditor(() => Framework.Cluster
 				.Nodes(5)
-				.MasterEligable(9202, 9203, 9204)
+				.MasterEligible(9202, 9203, 9204)
 				.ClientCalls(r => r.SucceedAlways())
 				.ClientCalls(r => r.OnPort(9201).Fails(Once))
 				/**
@@ -36,15 +36,15 @@ [U] public async Task DoesASniffAfterConnectionFailure()
 				*/
 				.Sniff(p => p.SucceedAlways(Framework.Cluster
 					.Nodes(3)
-					.MasterEligable(9200, 9202)
+					.MasterEligible(9200, 9202)
 					.ClientCalls(r => r.OnPort(9201).Fails(Once))
 					/**
 					* After this second failure on 9201 another sniff will be returned a cluster that no 
 					* longer fails but looks completely different (9210-9212) we should be able to handle this
 					*/
 					.Sniff(s => s.SucceedAlways(Framework.Cluster
 						.Nodes(3, 9210)
-						.MasterEligable(9210, 9212)
+						.MasterEligible(9210, 9212)
 						.ClientCalls(r => r.SucceedAlways())
 						.Sniff(r => r.SucceedAlways())
 					))
@@ -95,15 +95,15 @@ [U] public async Task DoesASniffAfterConnectionFailureOnPing()
 			*/
 			var audit = new Auditor(() => Framework.Cluster
 				.Nodes(5)
-				.MasterEligable(9202, 9203, 9204)
+				.MasterEligible(9202, 9203, 9204)
 				.Ping(r => r.OnPort(9201).Fails(Once))
 				.Sniff(p => p.SucceedAlways(Framework.Cluster
 					.Nodes(3)
-					.MasterEligable(9200, 9202)
+					.MasterEligible(9200, 9202)
 					.Ping(r => r.OnPort(9201).Fails(Once))
 					.Sniff(s => s.SucceedAlways(Framework.Cluster
 						.Nodes(3, 9210)
-						.MasterEligable(9210, 9211)
+						.MasterEligible(9210, 9211)
 						.Ping(r => r.SucceedAlways())
 						.Sniff(r => r.SucceedAlways())
 					))

src/Tests/ClientConcepts/ConnectionPooling/Sniffing/OnStaleClusterState.doc.cs

@@ -24,15 +24,15 @@ public async Task ASniffOnStartupHappens()
 		{
 			var audit = new Auditor(() => Framework.Cluster
 				.Nodes(10)
-				.MasterEligable(9202, 9203, 9204)
+				.MasterEligible(9202, 9203, 9204)
 				.ClientCalls(r => r.SucceedAlways())
 				.Sniff(s => s.SucceedAlways(Framework.Cluster
 					.Nodes(100)
-					.MasterEligable(9202, 9203, 9204)
+					.MasterEligible(9202, 9203, 9204)
 					.ClientCalls(r => r.SucceedAlways())
 					.Sniff(ss => ss.SucceedAlways(Framework.Cluster
 						.Nodes(10)
-						.MasterEligable(9202, 9203, 9204)
+						.MasterEligible(9202, 9203, 9204)
 						.ClientCalls(r => r.SucceedAlways())
 					))
 				))

src/Tests/ClientConcepts/ConnectionPooling/Sniffing/OnStartup.doc.cs

@@ -120,9 +120,9 @@ public async Task SniffPrefersMasterNodes()
 		{
 			var audit = new Auditor(() => Framework.Cluster
 				.Nodes(new[] {
-					new Node(new Uri("http://localhost:9200")) { MasterEligable = false },
-					new Node(new Uri("http://localhost:9201")) { MasterEligable = false },
-					new Node(new Uri("http://localhost:9202")) { MasterEligable = true },
+					new Node(new Uri("http://localhost:9200")) { MasterEligible = false },
+					new Node(new Uri("http://localhost:9201")) { MasterEligible = false },
+					new Node(new Uri("http://localhost:9202")) { MasterEligible = true },
 				})
 				.Sniff(s => s.Succeeds(Always))
 				.SniffingConnectionPool()
@@ -142,9 +142,9 @@ public async Task SniffPrefersMasterNodesButStillFailsOver()
 		{
 			var audit = new Auditor(() => Framework.Cluster
 				.Nodes(new[] {
-					new Node(new Uri("http://localhost:9200")) { MasterEligable = true },
-					new Node(new Uri("http://localhost:9201")) { MasterEligable = true },
-					new Node(new Uri("http://localhost:9202")) { MasterEligable = false },
+					new Node(new Uri("http://localhost:9200")) { MasterEligible = true },
+					new Node(new Uri("http://localhost:9201")) { MasterEligible = true },
+					new Node(new Uri("http://localhost:9202")) { MasterEligible = false },
 				})
 				.Sniff(s => s.Fails(Always))
 				.Sniff(s => s.OnPort(9202).Succeeds(Always))

src/Tests/ClientConcepts/ConnectionPooling/Sniffing/RoleDetection.doc.cs

@@ -16,7 +16,7 @@ public class RoleDetection
 	{
 		/** == Sniffing role detection
 		* 
-		* When we sniff the custer state we detect the role of the node whether its master eligable and holds data
+		* When we sniff the custer state we detect the role of the node whether its master eligible and holds data
 		* We use this information when selecting a node to perform an API call on.
 		*/
 		[U, SuppressMessage("AsyncUsage", "AsyncFixer001:Unnecessary async/await usage", Justification = "Its a test")]
@@ -26,7 +26,7 @@ public async Task DetectsMasterNodes()
 				.Nodes(10)
 				.Sniff(s => s.Fails(Always))
 				.Sniff(s => s.OnPort(9202)
-					.Succeeds(Always, Framework.Cluster.Nodes(8).MasterEligable(9200, 9201, 9202))
+					.Succeeds(Always, Framework.Cluster.Nodes(8).MasterEligible(9200, 9201, 9202))
 				)
 				.SniffingConnectionPool()
 				.AllDefaults()
@@ -36,13 +36,13 @@ public async Task DetectsMasterNodes()
 				{
 					pool.Should().NotBeNull();
 					pool.Nodes.Should().HaveCount(10);
-					pool.Nodes.Where(n => n.MasterEligable).Should().HaveCount(10);
+					pool.Nodes.Where(n => n.MasterEligible).Should().HaveCount(10);
 				},
 				AssertPoolAfterCall = (pool) =>
 				{
 					pool.Should().NotBeNull();
 					pool.Nodes.Should().HaveCount(8);
-					pool.Nodes.Where(n => n.MasterEligable).Should().HaveCount(3);
+					pool.Nodes.Where(n => n.MasterEligible).Should().HaveCount(3);
 				}
 			};
 			await audit.TraceStartup();
@@ -103,11 +103,11 @@ public RealWorldRoleDetection(SniffRoleDetectionCluster cluster)
 		[I] public async Task SniffPicksUpRoles()
 		{
 			var node = SniffAndReturnNode();
-			node.MasterEligable.Should().BeTrue();
+			node.MasterEligible.Should().BeTrue();
 			node.HoldsData.Should().BeFalse();
 
 			node = await SniffAndReturnNodeAsync();
-			node.MasterEligable.Should().BeTrue();
+			node.MasterEligible.Should().BeTrue();
 			node.HoldsData.Should().BeFalse();
 		}