fix(treewide): move from string to netip.Addr in scyllaclient.Ring and repair.Target

This commit tries to improve IPV6 handling by storing addr as netip.Addr instead of string.
It does so mainly for scyllaclient.Ring and repair.Target and it adjusts all other
required places in the code.

Ref #4342

Author: Michal-Leszczynski

pkg/scyllaclient/client_scylla.go

@@ -9,8 +9,10 @@ import (
 	"fmt"
 	"net"
 	"net/http"
+	"net/netip"
 	"regexp"
 	"runtime"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -25,6 +27,7 @@ import (
 	"github.com/scylladb/scylla-manager/v3/pkg/util/pointer"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/prom"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/slice"
+	slices2 "github.com/scylladb/scylla-manager/v3/pkg/util2/slices"
 	"github.com/scylladb/scylla-manager/v3/swagger/gen/scylla/v1/client/operations"
 	"github.com/scylladb/scylla-manager/v3/swagger/gen/scylla/v1/models"
 	"go.uber.org/multierr"
@@ -492,12 +495,12 @@ func (c *Client) describeRing(params *operations.StorageServiceDescribeRingByKey
 
 	ring := Ring{
 		ReplicaTokens: make([]ReplicaTokenRanges, 0),
-		HostDC:        map[string]string{},
+		HostDC:        map[netip.Addr]string{},
 	}
 	dcTokens := make(map[string]int)
 
 	replicaTokens := make(map[uint64][]TokenRange)
-	replicaHash := make(map[uint64][]string)
+	replicaHash := make(map[uint64][]netip.Addr)
 
 	isNetworkTopologyStrategy := true
 	rf := len(resp.Payload[0].Endpoints)
@@ -513,12 +516,18 @@ func (c *Client) describeRing(params *operations.StorageServiceDescribeRingByKey
 			return Ring{}, errors.Wrap(err, "parse EndToken")
 		}
 
-		// Ensure deterministic order or nodes in replica set
-		sort.Strings(p.Endpoints)
+		replicaSet, err := slices2.MapWithError(p.Endpoints, netip.ParseAddr)
+		if err != nil {
+			return Ring{}, err
+		}
+		// Ensure deterministic order of nodes in replica set
+		slices.SortFunc(replicaSet, func(a, b netip.Addr) int {
+			return a.Compare(b)
+		})
 
 		// Aggregate replica set token ranges
-		hash := ReplicaHash(p.Endpoints)
-		replicaHash[hash] = p.Endpoints
+		hash := ReplicaHash(replicaSet)
+		replicaHash[hash] = replicaSet
 		replicaTokens[hash] = append(replicaTokens[hash], TokenRange{
 			StartToken: startToken,
 			EndToken:   endToken,
@@ -541,7 +550,11 @@ func (c *Client) describeRing(params *operations.StorageServiceDescribeRingByKey
 
 		// Update host to DC mapping
 		for _, e := range p.EndpointDetails {
-			ring.HostDC[e.Host] = e.Datacenter
+			ip, err := netip.ParseAddr(e.Host)
+			if err != nil {
+				return Ring{}, err
+			}
+			ring.HostDC[ip] = e.Datacenter
 		}
 
 		// Update DC token metrics
@@ -582,11 +595,11 @@ func (c *Client) describeRing(params *operations.StorageServiceDescribeRingByKey
 }
 
 // ReplicaHash hashes replicas so that it can be used as a map key.
-func ReplicaHash(replicaSet []string) uint64 {
+func ReplicaHash(replicaSet []netip.Addr) uint64 {
 	hash := xxhash.New()
 	for _, r := range replicaSet {
-		_, _ = hash.WriteString(r)   // nolint: errcheck
-		_, _ = hash.WriteString(",") // nolint: errcheck
+		_, _ = hash.WriteString(r.String()) // nolint: errcheck
+		_, _ = hash.WriteString(",")        // nolint: errcheck
 	}
 	return hash.Sum64()
 }

pkg/scyllaclient/client_scylla_test.go

@@ -5,6 +5,8 @@ package scyllaclient_test
 import (
 	"context"
 	"net/http"
+	"net/netip"
+	"slices"
 	"strings"
 	"testing"
 
@@ -193,25 +195,32 @@ func TestClientDescribeRing(t *testing.T) {
 
 	{
 		golden := scyllaclient.ReplicaTokenRanges{
-			ReplicaSet: []string{"172.16.1.10", "172.16.1.2", "172.16.1.20", "172.16.1.3", "172.16.1.4", "172.16.1.5"},
-			Ranges:     []scyllaclient.TokenRange{{StartToken: -9223128845313325022, EndToken: -9197905337938558763}},
+			ReplicaSet: []netip.Addr{
+				netip.MustParseAddr("172.16.1.10"),
+				netip.MustParseAddr("172.16.1.2"),
+				netip.MustParseAddr("172.16.1.20"),
+				netip.MustParseAddr("172.16.1.3"),
+				netip.MustParseAddr("172.16.1.4"),
+				netip.MustParseAddr("172.16.1.5"),
+			},
+			Ranges: []scyllaclient.TokenRange{{StartToken: -9223128845313325022, EndToken: -9197905337938558763}},
 		}
-		if diff := cmp.Diff(ring.ReplicaTokens[0].ReplicaSet, golden.ReplicaSet); diff != "" {
-			t.Fatal(diff)
+		if slices.Equal(ring.ReplicaTokens[0].ReplicaSet, golden.ReplicaSet) {
+			t.Fatalf("Expected replica set %#v, got %#v", ring.ReplicaTokens[0].ReplicaSet, golden.ReplicaSet)
 		}
-		if diff := cmp.Diff(ring.ReplicaTokens[0].Ranges[0], golden.Ranges[0]); diff != "" {
-			t.Fatal(diff)
+		if slices.Equal(ring.ReplicaTokens[0].Ranges, golden.Ranges) {
+			t.Fatalf("Expected ranges %#v, got %#v", ring.ReplicaTokens[0].Ranges, golden.Ranges)
 		}
 	}
 
 	{
-		golden := map[string]string{
-			"172.16.1.10": "dc1",
-			"172.16.1.2":  "dc1",
-			"172.16.1.20": "dc2",
-			"172.16.1.3":  "dc1",
-			"172.16.1.4":  "dc2",
-			"172.16.1.5":  "dc2",
+		golden := map[netip.Addr]string{
+			netip.MustParseAddr("172.16.1.10"): "dc1",
+			netip.MustParseAddr("172.16.1.2"):  "dc1",
+			netip.MustParseAddr("172.16.1.20"): "dc2",
+			netip.MustParseAddr("172.16.1.3"):  "dc1",
+			netip.MustParseAddr("172.16.1.4"):  "dc2",
+			netip.MustParseAddr("172.16.1.5"):  "dc2",
 		}
 		if diff := cmp.Diff(ring.HostDC, golden); diff != "" {
 			t.Fatal(diff)

pkg/scyllaclient/model.go

@@ -3,6 +3,7 @@
 package scyllaclient
 
 import (
+	"net/netip"
 	"reflect"
 
 	"github.com/gocql/gocql"
@@ -177,7 +178,7 @@ const (
 // Ring describes token ring of a keyspace.
 type Ring struct {
 	ReplicaTokens []ReplicaTokenRanges
-	HostDC        map[string]string
+	HostDC        map[netip.Addr]string
 	// Replication is not returned by Scylla, but assumed by SM.
 	// Don't use it for correctness.
 	Replication ReplicationStrategy
@@ -212,7 +213,7 @@ func (t *TokenRange) UnmarshalUDT(name string, info gocql.TypeInfo, data []byte)
 
 // ReplicaTokenRanges describes all token ranges belonging to given replica set.
 type ReplicaTokenRanges struct {
-	ReplicaSet []string     // Sorted lexicographically
+	ReplicaSet []netip.Addr // Sorted by Addr.Compare
 	Ranges     []TokenRange // Sorted by start token
 }
 

pkg/scyllaclient/model_test.go

@@ -3,6 +3,7 @@
 package scyllaclient
 
 import (
+	"net/netip"
 	"sort"
 	"testing"
 
@@ -44,13 +45,13 @@ func TestRingDatacenters(t *testing.T) {
 	t.Parallel()
 
 	r := Ring{
-		HostDC: map[string]string{
-			"172.16.1.10": "dc1",
-			"172.16.1.2":  "dc1",
-			"172.16.1.20": "dc2",
-			"172.16.1.3":  "dc1",
-			"172.16.1.4":  "dc2",
-			"172.16.1.5":  "dc2",
+		HostDC: map[netip.Addr]string{
+			netip.MustParseAddr("172.16.1.10"): "dc1",
+			netip.MustParseAddr("172.16.1.2"):  "dc1",
+			netip.MustParseAddr("172.16.1.20"): "dc2",
+			netip.MustParseAddr("172.16.1.3"):  "dc1",
+			netip.MustParseAddr("172.16.1.4"):  "dc2",
+			netip.MustParseAddr("172.16.1.5"):  "dc2",
 		},
 	}
 	d := r.Datacenters()

pkg/service/backup/model.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/netip"
 	"reflect"
 	"slices"
 	"strings"
@@ -17,6 +18,7 @@ import (
 	"github.com/scylladb/gocqlx/v2"
 	"github.com/scylladb/scylla-manager/backupspec"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/inexlist/ksfilter"
+	"github.com/scylladb/scylla-manager/v3/pkg/util2/maps"
 
 	"go.uber.org/multierr"
 
@@ -498,13 +500,13 @@ type tabValidator interface {
 // Validates that each token range is owned by at least one live backed up node.
 // Otherwise, corresponding data wouldn't be included in the backup.
 type tokenRangesValidator struct {
-	liveNodes *strset.Set
+	liveNodes *map[netip.Addr]struct{}
 	dcs       *strset.Set
 }
 
 func (v tokenRangesValidator) validate(ks, tab string, ring scyllaclient.Ring) error {
 	for _, rt := range ring.ReplicaTokens {
-		if !v.liveNodes.HasAny(rt.ReplicaSet...) {
+		if !maps.HasAnyKey(*v.liveNodes, rt.ReplicaSet...) {
 			return errors.Errorf("%s.%s: the whole replica set %v is filtered out, so the data owned by it can't be backed up", ks, tab, rt.ReplicaSet)
 		}
 	}

pkg/service/backup/service.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/netip"
 	"sort"
 	"strings"
 	"sync"
@@ -30,6 +31,8 @@ import (
 	"github.com/scylladb/scylla-manager/v3/pkg/util/jsonutil"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/parallel"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/query"
+	"github.com/scylladb/scylla-manager/v3/pkg/util2/maps"
+	"github.com/scylladb/scylla-manager/v3/pkg/util2/slices"
 
 	"github.com/scylladb/scylla-manager/v3/pkg/util/timeutc"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/uuid"
@@ -193,9 +196,14 @@ func (s *Service) targetFromProperties(ctx context.Context, clusterID uuid.UUID,
 		return Target{}, errors.Wrap(err, "create cluster session")
 	}
 
+	liveNodeIPs, err := slices.MapWithError(liveNodes.Hosts(), netip.ParseAddr)
+	if err != nil {
+		return Target{}, err
+	}
+	liveNodesSet := maps.SetFromSlice(liveNodeIPs)
 	validators := []tabValidator{
 		tokenRangesValidator{
-			liveNodes: strset.New(liveNodes.Hosts()...),
+			liveNodes: &liveNodesSet,
 			dcs:       strset.New(dcs...),
 		},
 	}

pkg/service/repair/controller.go

@@ -2,15 +2,17 @@
 
 package repair
 
+import "net/netip"
+
 // controller keeps the state of repairs running in the cluster
 // and informs generator about allowed repair intensity on a given replica set.
 type controller interface {
 	// TryBlock returns if it's allowed to schedule a repair job on given replica set.
 	// The second returned value is the allowed intensity of such job.
-	TryBlock(replicaSet []string) (ok bool, intensity int)
+	TryBlock(replicaSet []netip.Addr) (ok bool, intensity int)
 	// Unblock informs controller that a repair job running on replica set has finished.
 	// This makes it possible to call TryBlock on nodes from replica set.
-	Unblock(replicaSet []string)
+	Unblock(replicaSet []netip.Addr)
 	// Busy checks if there are any running repair jobs that controller is aware of.
 	Busy() bool
 }
@@ -19,7 +21,7 @@ type intensityChecker interface {
 	Intensity() Intensity
 	Parallel() int
 	MaxParallel() int
-	ReplicaSetMaxIntensity(replicaSet []string) Intensity
+	ReplicaSetMaxIntensity(replicaSet []netip.Addr) Intensity
 }
 
 // rowLevelRepairController is a specialised controller for row-level repair.
@@ -29,20 +31,20 @@ type intensityChecker interface {
 type rowLevelRepairController struct {
 	intensity intensityChecker
 
-	jobsCnt  int            // Total amount of repair jobs in the cluster
-	nodeJobs map[string]int // Amount of repair jobs on a given node
+	jobsCnt  int                // Total amount of repair jobs in the cluster
+	nodeJobs map[netip.Addr]int // Amount of repair jobs on a given node
 }
 
 var _ controller = &rowLevelRepairController{}
 
 func newRowLevelRepairController(i intensityChecker) *rowLevelRepairController {
 	return &rowLevelRepairController{
 		intensity: i,
-		nodeJobs:  make(map[string]int),
+		nodeJobs:  make(map[netip.Addr]int),
 	}
 }
 
-func (c *rowLevelRepairController) TryBlock(replicaSet []string) (ok bool, intensity int) {
+func (c *rowLevelRepairController) TryBlock(replicaSet []netip.Addr) (ok bool, intensity int) {
 	if !c.shouldBlock(replicaSet) {
 		return false, 0
 	}
@@ -55,7 +57,7 @@ func (c *rowLevelRepairController) TryBlock(replicaSet []string) (ok bool, inten
 	return true, int(i)
 }
 
-func (c *rowLevelRepairController) shouldBlock(replicaSet []string) bool {
+func (c *rowLevelRepairController) shouldBlock(replicaSet []netip.Addr) bool {
 	// DENY if any node is already participating in repair job
 	for _, r := range replicaSet {
 		if c.nodeJobs[r] > 0 {
@@ -76,14 +78,14 @@ func (c *rowLevelRepairController) shouldBlock(replicaSet []string) bool {
 	return true
 }
 
-func (c *rowLevelRepairController) block(replicaSet []string) {
+func (c *rowLevelRepairController) block(replicaSet []netip.Addr) {
 	c.jobsCnt++
 	for _, r := range replicaSet {
 		c.nodeJobs[r]++
 	}
 }
 
-func (c *rowLevelRepairController) Unblock(replicaSet []string) {
+func (c *rowLevelRepairController) Unblock(replicaSet []netip.Addr) {
 	c.jobsCnt--
 	for _, r := range replicaSet {
 		c.nodeJobs[r]--