Update from PR comments

- Moved nodeSelection setting into it own function getNodeSelection
- Added `cycleAllNode`
- Renamed `ReadOnlyReplicaSelection` to `ReadOnlyCommandNodeSelection`

Signed-off-by: Adam Fowler <[email protected]>

Author: adam-fowler

Sources/Valkey/Cluster/ValkeyClusterClient.swift

@@ -146,12 +146,7 @@ public final class ValkeyClusterClient: Sendable {
     @inlinable
     public func execute<Command: ValkeyCommand>(_ command: Command) async throws -> Command.Response {
         let hashSlot = try self.hashSlot(for: command.keysAffected)
-        let nodeSelection =
-            if command.isReadOnly {
-                self.clientConfiguration.readOnlyReplicaSelection.clusterNodeSelection
-            } else {
-                ValkeyClusterNodeSelection.primary
-            }
+        let nodeSelection = getNodeSelection(readOnly: command.isReadOnly)
         var clientSelector: () async throws -> ValkeyNodeClient = {
             try await self.nodeClient(for: hashSlot.map { [$0] } ?? [], nodeSelection: nodeSelection)
         }
@@ -259,12 +254,7 @@ public final class ValkeyClusterClient: Sendable {
     ) async -> [Result<RESPToken, any Error>] {
         guard commands.count > 0 else { return [] }
         let readOnlyCommand = commands.reduce(true) { $0 && $1.isReadOnly }
-        let nodeSelection =
-            if readOnlyCommand {
-                self.clientConfiguration.readOnlyReplicaSelection.clusterNodeSelection
-            } else {
-                ValkeyClusterNodeSelection.primary
-            }
+        let nodeSelection = getNodeSelection(readOnly: readOnlyCommand)
         // get a list of nodes and the commands that should be run on them
         do {
             let nodes = try await self.splitCommandsAcrossNodes(commands: commands, nodeSelection: nodeSelection)
@@ -354,12 +344,7 @@ public final class ValkeyClusterClient: Sendable {
     ) async throws -> [Result<RESPToken, Error>] where Commands.Element == any ValkeyCommand {
         let hashSlot = try self.hashSlot(for: commands.flatMap { $0.keysAffected })
         let readOnlyCommand = commands.reduce(true) { $0 && $1.isReadOnly }
-        let nodeSelection =
-            if readOnlyCommand {
-                self.clientConfiguration.readOnlyReplicaSelection.clusterNodeSelection
-            } else {
-                ValkeyClusterNodeSelection.primary
-            }
+        let nodeSelection = getNodeSelection(readOnly: readOnlyCommand)
         var clientSelector: () async throws -> ValkeyNodeClient = {
             try await self.nodeClient(for: hashSlot.map { [$0] } ?? [], nodeSelection: nodeSelection)
         }
@@ -489,16 +474,20 @@ public final class ValkeyClusterClient: Sendable {
         operation: (ValkeyConnection) async throws -> sending Value
     ) async throws -> Value {
         let hashSlots = keys.compactMap { HashSlot(key: $0) }
-        let nodeSelection =
-            if readOnly {
-                self.clientConfiguration.readOnlyReplicaSelection.clusterNodeSelection
-            } else {
-                ValkeyClusterNodeSelection.primary
-            }
+        let nodeSelection = getNodeSelection(readOnly: readOnly)
         let node = try await self.nodeClient(for: hashSlots, nodeSelection: nodeSelection)
         return try await node.withConnection(isolation: isolation, operation: operation)
     }
 
+    @inlinable
+    /* private */ func getNodeSelection(readOnly: Bool) -> ValkeyClusterNodeSelection {
+        if readOnly {
+            self.clientConfiguration.readOnlyCommandNodeSelection.clusterNodeSelection
+        } else {
+            .primary
+        }
+    }
+
     /// Starts running the cluster client.
     ///
     /// This method initiates:

Sources/Valkey/Cluster/ValkeyClusterNodeSelection.swift

@@ -10,6 +10,7 @@
 package enum ValkeyClusterNodeSelection: Sendable {
     case primary
     case cycleReplicas(Int)
+    case cycleAllNodes(Int)
 
     /// Select node from node ids
     /// - Parameter nodeIDs: Primary and replica nodes
@@ -22,20 +23,29 @@ package enum ValkeyClusterNodeSelection: Sendable {
         case .cycleReplicas(let index):
             guard nodeIDs.replicas.count > 0 else { return nodeIDs.primary }
             return nodeIDs.replicas[index % nodeIDs.replicas.count]
+        case .cycleAllNodes(let index):
+            let index = index % (nodeIDs.replicas.count + 1)
+            if index == 0 {
+                return nodeIDs.primary
+            } else {
+                return nodeIDs.replicas[index - 1]
+            }
         }
     }
 }
 
 @available(valkeySwift 1.0, *)
-extension ValkeyClientConfiguration.ReadOnlyReplicaSelection {
-    /// Convert from read only replica selection to node selection
+extension ValkeyClientConfiguration.ReadOnlyCommandNodeSelection {
+    /// Convert from ``ValkeyClientConfiguration/ReadOnlyCommandNodeSelection`` to node selection
     @usableFromInline
     var clusterNodeSelection: ValkeyClusterNodeSelection {
         switch self.value {
-        case .none:
+        case .primary:
             .primary
-        case .cycle:
+        case .cycleReplicas:
             .cycleReplicas(Self.idGenerator.next())
+        case .cycleAllNodes:
+            .cycleAllNodes(Self.idGenerator.next())
         }
     }
 

Sources/Valkey/ValkeyClientConfiguration.swift

@@ -153,19 +153,22 @@ public struct ValkeyClientConfiguration: Sendable {
         }
     }
 
-    /// Determine how replicas are chosen for readonly commands
-    public struct ReadOnlyReplicaSelection: Sendable {
+    /// Determine how nodes are chosen for readonly commands
+    public struct ReadOnlyCommandNodeSelection: Sendable {
         enum _Internal {
-            case none
-            case cycle
+            case primary
+            case cycleReplicas
+            case cycleAllNodes
         }
 
         let value: _Internal
 
-        /// Do not use readonly replicas
-        public static var none: Self { .init(value: .none) }
+        /// Always use the primary node
+        public static var primary: Self { .init(value: .primary) }
         /// Cycle through replicas
-        public static var cycle: Self { .init(value: .cycle) }
+        public static var cycleReplicas: Self { .init(value: .cycleReplicas) }
+        /// Cycle through primary and replicas
+        public static var cycleAllNodes: Self { .init(value: .cycleAllNodes) }
     }
 
     /// The authentication credentials for the connection.
@@ -186,15 +189,13 @@ public struct ValkeyClientConfiguration: Sendable {
     /// The TLS to use for the Valkey connection.
     public var tls: TLS
 
-    /// Determine how we chose replicas for readonly commands
-    ///
-    /// A nil value indicates we do not want to use readonly replicas
+    /// Determine how we chose nodes for readonly commands
     ///
     /// Cluster by default will redirect commands from replica nodes to the primary node.
-    /// Setting this value will allow replicas to run readonly commands. This will reduce
-    /// load on your primary nodes but there is a chance you will receive stale data as
-    /// the replica is not up to date.
-    public var readOnlyReplicaSelection: ReadOnlyReplicaSelection
+    /// Setting this value to something other than ``ReadOnlyCommandNodeSelection/primary``
+    /// will allow replicas to run readonly commands. This will reduce load on your primary
+    /// nodes but there is a chance you will receive stale data as the replica is not up to date.
+    public var readOnlyCommandNodeSelection: ReadOnlyCommandNodeSelection
 
     #if DistributedTracingSupport
     /// The distributed tracing configuration to use for the Valkey connection.
@@ -221,7 +222,7 @@ public struct ValkeyClientConfiguration: Sendable {
         commandTimeout: Duration = .seconds(30),
         blockingCommandTimeout: Duration = .seconds(120),
         tls: TLS = .disable,
-        readOnlyReplicaSelection: ReadOnlyReplicaSelection = .none
+        readOnlyCommandNodeSelection: ReadOnlyCommandNodeSelection = .primary
     ) {
         self.authentication = authentication
         self.connectionPool = connectionPool
@@ -230,6 +231,6 @@ public struct ValkeyClientConfiguration: Sendable {
         self.commandTimeout = commandTimeout
         self.blockingCommandTimeout = blockingCommandTimeout
         self.tls = tls
-        self.readOnlyReplicaSelection = readOnlyReplicaSelection
+        self.readOnlyCommandNodeSelection = readOnlyCommandNodeSelection
     }
 }