Make non-destructive replacements to replica

Author: mythz

README.md

@@ -141,7 +141,7 @@ Any connections required after the maximum Pool size has been reached will be cr
 ### PooledRedisClientManager
 
 If you prefer to define options on the Client Manager itself or you want to provide separate Read/Write and ReadOnly 
-(i.e. Master and Slave) redis-servers, use the `PooledRedisClientManager` instead:
+(i.e. Master and Replica) redis-servers, use the `PooledRedisClientManager` instead:
 
 ```csharp
 container.Register<IRedisClientsManager>(c => 
@@ -248,7 +248,7 @@ By default RedisSentinel uses a `PooledRedisClientManager`, this can be changed
 newer `RedisManagerPool` with:
 
 ```csharp
-sentinel.RedisManagerFactory = (master,slaves) => new RedisManagerPool(master);
+sentinel.RedisManagerFactory = (master,replicas) => new RedisManagerPool(master);
 ```
 
 ### Start monitoring Sentinels

src/ServiceStack.Redis/BasicRedisClientManager.ICacheClient.cs

@@ -19,13 +19,13 @@ namespace ServiceStack.Redis
 	/// <summary>
 	/// BasicRedisClientManager for ICacheClient
 	/// 
-	/// For more interoperabilty I'm also implementing the ICacheClient on
+	/// For more interoperability I'm also implementing the ICacheClient on
 	/// this cache client manager which has the affect of calling 
 	/// GetCacheClient() for all write operations and GetReadOnlyCacheClient() 
 	/// for the read ones.
 	/// 
-	/// This works well for master-slave replication scenarios where you have 
-	/// 1 master that replicates to multiple read slaves.
+	/// This works well for master-replica replication scenarios where you have 
+	/// 1 master that replicates to multiple read replicas.
 	/// </summary>
 	public partial class BasicRedisClientManager
 		: ICacheClient

src/ServiceStack.Redis/BasicRedisResolver.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using ServiceStack.Logging;
-using ServiceStack.Text;
 
 namespace ServiceStack.Redis
 {
@@ -16,21 +15,15 @@ public class BasicRedisResolver : IRedisResolver, IRedisResolverExtended
         public int ReadOnlyHostsCount { get; private set; }
 
         private RedisEndpoint[] masters;
-        private RedisEndpoint[] slaves;
+        private RedisEndpoint[] replicas;
 
-        public RedisEndpoint[] Masters
-        {
-            get { return masters; }
-        }
-        public RedisEndpoint[] Slaves
-        {
-            get { return slaves; }
-        }
+        public RedisEndpoint[] Masters => masters;
+        public RedisEndpoint[] Replicas => replicas;
 
-        public BasicRedisResolver(IEnumerable<RedisEndpoint> masters, IEnumerable<RedisEndpoint> slaves)
+        public BasicRedisResolver(IEnumerable<RedisEndpoint> masters, IEnumerable<RedisEndpoint> replicas)
         {
             ResetMasters(masters.ToList());
-            ResetSlaves(slaves.ToList());
+            ResetSlaves(replicas.ToList());
             ClientFactory = RedisConfig.ClientFactory;
         }
 
@@ -56,13 +49,13 @@ public virtual void ResetSlaves(IEnumerable<string> hosts)
             ResetSlaves(hosts.ToRedisEndPoints());
         }
 
-        public virtual void ResetSlaves(List<RedisEndpoint> newSlaves)
+        public virtual void ResetSlaves(List<RedisEndpoint> newReplicas)
         {
-            slaves = (newSlaves ?? TypeConstants<RedisEndpoint>.EmptyList).ToArray();
-            ReadOnlyHostsCount = slaves.Length;
+            replicas = (newReplicas ?? TypeConstants<RedisEndpoint>.EmptyList).ToArray();
+            ReadOnlyHostsCount = replicas.Length;
 
             if (log.IsDebugEnabled)
-                log.Debug("New Redis Slaves: " + string.Join(", ", slaves.Map(x => x.GetHostString())));
+                log.Debug("New Redis Replicas: " + string.Join(", ", replicas.Map(x => x.GetHostString())));
         }
 
         public RedisClient CreateRedisClient(RedisEndpoint config, bool master)
@@ -78,7 +71,7 @@ public RedisEndpoint GetReadWriteHost(int desiredIndex)
         public RedisEndpoint GetReadOnlyHost(int desiredIndex)
         {
             return ReadOnlyHostsCount > 0
-                ? slaves[desiredIndex % slaves.Length]
+                ? replicas[desiredIndex % replicas.Length]
                 : GetReadWriteHost(desiredIndex);
         }