Use more inclusive language (#109)

Author: fabianfett

Sources/Valkey/Cluster/HashSlotShardMap.swift

@@ -12,27 +12,27 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Represents the mapping of nodes in a Valkey shard, consisting of a master node and optional replicas.
+/// Represents the mapping of nodes in a Valkey shard, consisting of a primary node and optional replicas.
 ///
-/// In a Valkey cluster, each shard consists of one master node and zero or more replica nodes.
+/// In a Valkey cluster, each shard consists of one primary node and zero or more replica nodes.
 @usableFromInline
 package struct ValkeyShardNodeIDs: Hashable, Sendable {
-    /// The master node responsible for handling write operations for this shard.
+    /// The primary node responsible for handling write operations for this shard.
     @usableFromInline
-    package var master: ValkeyNodeID
+    package var primary: ValkeyNodeID
 
-    /// The replica nodes that maintain copies of the master's data.
+    /// The replica nodes that maintain copies of the primary's data.
     /// Replicas can handle read operations but not writes.
     @usableFromInline
     package var replicas: [ValkeyNodeID]
 
-    /// Creates a new shard node mapping with the specified master and optional replicas.
+    /// Creates a new shard node mapping with the specified primary and optional replicas.
     ///
     /// - Parameters:
-    ///   - master: The master node ID for this shard
+    ///   - primary: The primary node ID for this shard
     ///   - replicas: An array of replica node IDs, defaults to empty
-    package init(master: ValkeyNodeID, replicas: [ValkeyNodeID] = []) {
-        self.master = master
+    package init(primary: ValkeyNodeID, replicas: [ValkeyNodeID] = []) {
+        self.primary = primary
         self.replicas = replicas
     }
 }
@@ -43,8 +43,8 @@ extension ValkeyShardNodeIDs: ExpressibleByArrayLiteral {
 
     @usableFromInline
     package init(arrayLiteral elements: ValkeyNodeID...) {
-        precondition(!elements.isEmpty, "ValkeyShardNodeIDs requires at least one node ID for the master")
-        self.master = elements.first!
+        precondition(!elements.isEmpty, "ValkeyShardNodeIDs requires at least one node ID for the primary")
+        self.primary = elements.first!
         self.replicas = Array(elements.dropFirst())
     }
 }
@@ -121,8 +121,8 @@ package struct HashSlotShardMap: Sendable {
     /// It performs the following operations:
     /// 1. Resets the slot-to-shard mapping (all slots become unassigned)
     /// 2. Clears the current shard collection
-    /// 3. For each valid shard (that has a master node):
-    ///    - Creates a `ValkeyShardNodeIDs` object with the master and its replicas
+    /// 3. For each valid shard (that has a primary node):
+    ///    - Creates a `ValkeyShardNodeIDs` object with the primary and its replicas
     ///    - Assigns all slots belonging to this shard in the mapping
     ///
     /// - Parameter shards: A collection of shard descriptions containing slot assignments and node information
@@ -133,26 +133,26 @@ package struct HashSlotShardMap: Sendable {
 
         var shardID = 0
         for shard in shards {
-            var master: ValkeyNodeID?
+            var primary: ValkeyNodeID?
             var replicas = [ValkeyNodeID]()
             replicas.reserveCapacity(shard.nodes.count - 1)
 
             for node in shard.nodes {
                 switch node.role.base {
-                case .master:
-                    master = node.nodeID
+                case .primary:
+                    primary = node.nodeID
 
                 case .replica:
                     replicas.append(node.nodeID)
                 }
             }
 
-            guard let master else {
+            guard let primary else {
                 continue
             }
 
             let nodeIDs = ValkeyShardNodeIDs(
-                master: master,
+                primary: primary,
                 replicas: replicas
             )
 
@@ -194,22 +194,22 @@ package struct HashSlotShardMap: Sendable {
             var shard = self.shardIDToShard[shardIndex]
 
             // 1. No change
-            if shard.master == movedError.nodeID {
+            if shard.primary == movedError.nodeID {
                 return .updatedSlotToExistingNode
             }
 
             // 2. Failover
             if shard.replicas.contains(movedError.nodeID) {
                 // lets promote the replica to be the primary and remove the old primary for now
-                shard.master = movedError.nodeID
+                shard.primary = movedError.nodeID
                 shard.replicas.removeAll { $0 == movedError.nodeID }
                 self.shardIDToShard[shardIndex] = shard
                 return .updatedSlotToExistingNode
             }
         }
 
         // 3. Slot migration to an existing primary
-        if let newShardIndex = self.shardIDToShard.firstIndex(where: { $0.master == movedError.nodeID }) {
+        if let newShardIndex = self.shardIDToShard.firstIndex(where: { $0.primary == movedError.nodeID }) {
             self.slotToShardID[Int(movedError.slot.rawValue)] = .init(newShardIndex)
             return .updatedSlotToExistingNode
         }
@@ -220,14 +220,14 @@ package struct HashSlotShardMap: Sendable {
             self.shardIDToShard[ogShardIndexOfNewPrimary].replicas.removeAll(where: { $0 == movedError.nodeID })
             // create a new shard with the replica
             let newShardIndex = self.shardIDToShard.endIndex
-            self.shardIDToShard.append(.init(master: movedError.nodeID))
+            self.shardIDToShard.append(.init(primary: movedError.nodeID))
             self.slotToShardID[Int(movedError.slot.rawValue)] = .init(newShardIndex)
             return .updatedSlotToExistingNode
         }
 
         // 5. totally new node
         let newShardIndex = self.shardIDToShard.endIndex
-        self.shardIDToShard.append(.init(master: movedError.nodeID))
+        self.shardIDToShard.append(.init(primary: movedError.nodeID))
         self.slotToShardID[Int(movedError.slot.rawValue)] = .init(newShardIndex)
         return .updatedSlotToUnknownNode
     }

Sources/Valkey/Cluster/ValkeyClusterClientStateMachine.swift

@@ -537,7 +537,7 @@ package struct ValkeyClusterClientStateMachine<
 
         case .degraded(let context):
             let shardID = try context.hashSlotShardMap.nodeID(for: slots)
-            if let pool = self.runningClients[shardID.master]?.pool {
+            if let pool = self.runningClients[shardID.primary]?.pool {
                 return pool
             }
             // If we don't have a node for a shard, that means that this shard got created from
@@ -547,7 +547,7 @@ package struct ValkeyClusterClientStateMachine<
 
         case .healthy(let context):
             let shardID = try context.hashSlotShardMap.nodeID(for: slots)
-            if let pool = self.runningClients[shardID.master]?.pool {
+            if let pool = self.runningClients[shardID.primary]?.pool {
                 return pool
             }
             // If we don't have a node for a shard, that means that this shard got created from

Sources/Valkey/Cluster/ValkeyClusterError.swift

@@ -16,8 +16,8 @@
 package enum ValkeyClusterError: Error {
     case clusterIsMissingSlotAssignment
     case clusterIsMissingMovedErrorNode
-    case shardIsMissingMasterNode
-    case shardHasMultipleMasterNodes
+    case shardIsMissingPrimaryNode
+    case shardHasMultiplePrimaryNodes
     case noNodeToTalkTo
     case serverDiscoveryFailedNoKnownNode
     case keysInCommandRequireMultipleNodes

Sources/Valkey/Cluster/ValkeyTopologyCandidate.swift

@@ -21,19 +21,19 @@
 package struct ValkeyTopologyCandidate: Hashable {
     /// Represents a shard (hash slot range) within a Valkey cluster topology.
     ///
-    /// A shard consists of a set of hash slots assigned to a master node and optional replica nodes.
+    /// A shard consists of a set of hash slots assigned to a primary node and optional replica nodes.
     package struct Shard: Hashable {
         /// The hash slots assigned to this shard.
         package var slots: HashSlots
 
-        /// The master node responsible for this shard.
-        package var master: Node
+        /// The primary node responsible for this shard.
+        package var primary: Node
 
         /// The replica nodes for this shard, sorted by endpoint, port, and TLS status for consistent equality checking.
         package var replicas: [Node]
     }
 
-    /// Represents a node (either master or replica) in the Valkey cluster topology.
+    /// Represents a node (either primary or replica) in the Valkey cluster topology.
     ///
     /// Contains only the essential connection properties needed to identify and connect to a node.
     package struct Node: Hashable {
@@ -70,17 +70,17 @@ package struct ValkeyTopologyCandidate: Hashable {
     package init(_ description: ValkeyClusterDescription) throws(ValkeyClusterError) {
 
         self.shards = try description.shards.map({ shard throws(ValkeyClusterError) in
-            var master: Node?
+            var primary: Node?
             var replicas = [Node]()
             replicas.reserveCapacity(shard.nodes.count)
 
             for node in shard.nodes {
                 switch node.role.base {
-                case .master:
-                    if master != nil {
-                        throw ValkeyClusterError.shardHasMultipleMasterNodes
+                case .primary:
+                    if primary != nil {
+                        throw ValkeyClusterError.shardHasMultiplePrimaryNodes
                     }
-                    master = Node(node)
+                    primary = Node(node)
                 case .replica:
                     replicas.append(Node(node))
                 }
@@ -99,13 +99,13 @@ package struct ValkeyTopologyCandidate: Hashable {
                 return true
             })
 
-            guard let master else {
-                throw ValkeyClusterError.shardIsMissingMasterNode
+            guard let primary else {
+                throw ValkeyClusterError.shardIsMissingPrimaryNode
             }
 
             return Shard(
                 slots: shard.slots.sorted(by: { $0.startIndex < $1.startIndex }),
-                master: master,
+                primary: primary,
                 replicas: sorted
             )
         })

Sources/Valkey/Commands/Custom/ClusterCustomCommands.swift

@@ -44,9 +44,9 @@ package struct ValkeyClusterParseError: Error, Equatable {
 public struct ValkeyClusterDescription: Hashable, Sendable, RESPTokenDecodable {
     /// Details for a node within a cluster shard
     public struct Node: Hashable, Sendable {
-        /// Replication role of a given shard (master or replica)
+        /// Replication role of a given node within a shard (primary or replica)
         public struct Role: Sendable, Hashable, RawRepresentable {
-            public static let master = Role(base: .master)
+            public static let primary = Role(base: .primary)
             public static let replica = Role(base: .replica)
 
             public init?(rawValue: String) {
@@ -61,7 +61,7 @@ public struct ValkeyClusterDescription: Hashable, Sendable, RESPTokenDecodable {
             }
 
             enum Base: String {
-                case master
+                case primary = "master"
                 case replica
             }
 
@@ -140,14 +140,6 @@ public struct ValkeyClusterDescription: Hashable, Sendable, RESPTokenDecodable {
         public var slots: HashSlots
         public var nodes: [Node]
 
-        public var master: Node? {
-            self.nodes.first
-        }
-
-        public var replicas: ArraySlice<Node> {
-            self.nodes.dropFirst(1)
-        }
-
         public init(slots: HashSlots, nodes: [Node]) {
             self.slots = slots
             self.nodes = nodes