Rename InOrder to FailOver.

While not a load balancing technique, "FailOver" is the more common term for always trying the first server and only trying the second server if the first fails.

Author: bgrainger

docs/content/connection-options.md

@@ -199,8 +199,8 @@ These are the other options that MySqlConnector supports. They are set to sensib
       <dl>
         <dt>RoundRobin</dt>
         <dd>Each new connection opened for this connection pool uses the next host name (sequentially with wraparound). Requires <code>Pooling=True</code>. This is the default if <code>Pooling=True</code>.</dd>
-        <dt>InOrder</dt>
-        <dd>Each new connection tries the hosts in order, starting with the first one. This is the default if <code>Pooling=False</code>.</dd>
+        <dt>FailOver</dt>
+        <dd>Each new connection tries to connect to the first host; subsequent hosts are used only if connecting to the first one fails. This is the default if <code>Pooling=False</code>.</dd>
         <dt>Random</dt>
         <dd>Servers are tried in a random order.</dd>
         <dt>LeastConnections</dt>

docs/content/tutorials/migrating-from-connector-net.md

@@ -38,7 +38,7 @@ MySqlConnector has some different default connection string options:
   <tr>
     <td><code>LoadBalance</code></td>
     <td>Default is <code>RoundRobin</code></td>
-    <td>(not configurable, effective default is <code>InOrder</code>)</td>
+    <td>(not configurable, effective default is <code>FailOver</code>)</td>
     <td>Connector/NET currently has <a href="https://bugs.mysql.com/bug.php?id=81650" title="MySQL bug #81650">a bug</a> that prevents multiple host names being used.</td>
   </tr>
   <tr>

src/MySqlConnector/Core/ConnectionPool.cs

@@ -351,7 +351,7 @@ private ConnectionPool(ConnectionSettings cs)
 					m_hostSessions[hostName] = 0;
 			}
 			m_loadBalancer = cs.ConnectionType != ConnectionType.Tcp ? null :
-				cs.HostNames.Count == 1 || cs.LoadBalance == MySqlLoadBalance.InOrder ? InOrderLoadBalancer.Instance :
+				cs.HostNames.Count == 1 || cs.LoadBalance == MySqlLoadBalance.FailOver ? FailOverLoadBalancer.Instance :
 				cs.LoadBalance == MySqlLoadBalance.Random ? RandomLoadBalancer.Instance :
 				cs.LoadBalance == MySqlLoadBalance.LeastConnections ? new LeastConnectionsLoadBalancer(this) :
 				(ILoadBalancer) new RoundRobinLoadBalancer();

src/MySqlConnector/Core/ILoadBalancer.cs

@@ -12,13 +12,13 @@ internal interface ILoadBalancer
 		IEnumerable<string> LoadBalance(IReadOnlyList<string> hosts);
 	}
 
-	internal sealed class InOrderLoadBalancer : ILoadBalancer
+	internal sealed class FailOverLoadBalancer : ILoadBalancer
 	{
-		public static ILoadBalancer Instance { get; } = new InOrderLoadBalancer();
+		public static ILoadBalancer Instance { get; } = new FailOverLoadBalancer();
 
 		public IEnumerable<string> LoadBalance(IReadOnlyList<string> hosts) => hosts;
 
-		private InOrderLoadBalancer()
+		private FailOverLoadBalancer()
 		{
 		}
 	}

src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnection.cs

@@ -357,9 +357,9 @@ private async Task<ServerSession> CreateSessionAsync(IOBehavior ioBehavior, Canc
 					}
 					else
 					{
-						// only "in order" and "random" load balancers supported without connection pooling
+						// only "fail over" and "random" load balancers supported without connection pooling
 						var loadBalancer = m_connectionSettings.LoadBalance == MySqlLoadBalance.Random && m_connectionSettings.HostNames.Count > 1 ?
-							RandomLoadBalancer.Instance : InOrderLoadBalancer.Instance;
+							RandomLoadBalancer.Instance : FailOverLoadBalancer.Instance;
 
 						var session = new ServerSession();
 						await session.ConnectAsync(m_connectionSettings, loadBalancer, ioBehavior, linkedSource.Token).ConfigureAwait(false);

src/MySqlConnector/MySql.Data.MySqlClient/MySqlLoadBalance.cs

@@ -3,14 +3,14 @@ namespace MySql.Data.MySqlClient
 	public enum MySqlLoadBalance
 	{
 		/// <summary>
-		/// Servers are tried sequentially, across multiple calls to <see cref="MySqlConnection.Open"/>.
+		/// Each new connection opened for a connection pool uses the next host name (sequentially with wraparound).
 		/// </summary>
 		RoundRobin,
 
 		/// <summary>
-		/// Servers are tried in order, starting with the first one, for each call to <see cref="MySqlConnection.Open"/>.
+		/// Each new connection tries to connect to the first host; subsequent hosts are used only if connecting to the first one fails.
 		/// </summary>
-		InOrder,
+		FailOver,
 
 		/// <summary>
 		/// Servers are tried in random order.

tests/MySqlConnector.Tests/LoadBalancerTests.cs

@@ -7,9 +7,9 @@ namespace MySqlConnector.Tests
 	public class LoadBalancerTests
 	{
 		[Fact]
-		public void InOrder()
+		public void FailOver()
 		{
-			var loadBalancer = InOrderLoadBalancer.Instance;
+			var loadBalancer = FailOverLoadBalancer.Instance;
 			var input = new[] { "a", "b", "c", "d" };
 			Assert.Equal(new[] { "a", "b", "c", "d" }, loadBalancer.LoadBalance(input));
 			Assert.Same(input, loadBalancer.LoadBalance(input));