fix(config-cache): use netip.Addr to unify the IPv6 (#4269)

Author: karol-kokoszka

Diff for: pkg/service/configcache/service.go

@@ -4,6 +4,7 @@ package configcache
 
 import (
 	"context"
+	"net/netip"
 	"sync"
 	"time"
 
@@ -80,7 +81,18 @@ func (svc *Service) Read(clusterID uuid.UUID, host string) (NodeConfig, error) {
 		return emptyConfig, err
 	}
 
-	rawHostConfig, ok := clusterConfig.Load(host)
+	hostKey := host
+	// Remove leading '[' and trailing ']' if present.
+	// netip.ParseAddr(bracketedIP) leaves brackets.
+	// Need to remove it.
+	if host != "" && host[0] == '[' && host[len(host)-1] == ']' {
+		host = host[1 : len(host)-1]
+	}
+	if addr, err := netip.ParseAddr(host); err == nil {
+		hostKey = addr.String()
+	}
+
+	rawHostConfig, ok := clusterConfig.Load(hostKey)
 	if !ok {
 		return emptyConfig, ErrNoHostConfig
 	}
@@ -192,17 +204,23 @@ func (svc *Service) updateSingle(ctx context.Context, c *cluster.Cluster) bool {
 
 	for _, host := range client.Config().Hosts {
 		hostsWg.Add(1)
+		hostKey := host
+
+		parsedIP, err := netip.ParseAddr(host)
+		if err == nil {
+			hostKey = parsedIP.String()
+		}
 
-		perHostLogger := logger.Named("Cluster host config update").With("host", host)
+		perHostLogger := logger.Named("Cluster host config update").With("host", host, "hostKey", hostKey)
 		go func() {
 			defer hostsWg.Done()
 
-			config, err := svc.retrieveNodeConfig(ctx, host, client, c)
+			config, err := svc.retrieveNodeConfig(ctx, hostKey, client, c)
 			if err != nil {
 				perHostLogger.Error(ctx, "Couldn't read cluster host config", "error", err)
 				return
 			}
-			clusterConfig.Store(host, config)
+			clusterConfig.Store(hostKey, config)
 		}()
 	}
 	hostsWg.Wait()

Diff for: pkg/service/configcache/service_test.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/json"
+	"net/netip"
 	"sync"
 	"testing"
 	"time"
@@ -222,6 +223,73 @@ func TestServiceForceUpdateCluster(t *testing.T) {
 	})
 }
 
+func TestService_Read_IPv6Normalization(t *testing.T) {
+	// Define a canonical IPv6 representation
+	key := "2001:0db8:0000:0000:0000:0000:0000:0001"
+	parsedKey, err := netip.ParseAddr(key)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Assume that our system normalizes IPv6 addresses to the canonical form.
+	// Create the configuration for the canonical IPv6 address.
+	nodeConfig := NodeConfig{
+		NodeInfo: &scyllaclient.NodeInfo{
+			AgentVersion: "expectedVersion",
+		},
+	}
+	configHash, err := nodeConfig.sha256hash()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	clusterID := uuid.MustRandom()
+	// Prepopulate the service config with the canonical representation as the key.
+	initialState := convertMapToSyncMap(map[any]any{
+		clusterID.String(): convertMapToSyncMap(map[any]any{
+			parsedKey.String(): nodeConfig,
+		}),
+	})
+
+	// Define several valid IPv6 representations for the same host.
+	testCases := []struct {
+		name    string
+		hostKey string
+	}{
+		{"Fully Expanded", "2001:0db8:0000:0000:0000:0000:0000:0001"},
+		{"Uncompressed", "2001:db8:0:0:0:0:0:1"},
+		{"Compressed", "2001:db8::1"},
+		{"Uppercase Variant", "2001:DB8::1"},
+		{"Bracketed", "[2001:db8::1]"},
+	}
+
+	svc := Service{
+		svcConfig:    DefaultConfig(),
+		clusterSvc:   &mockClusterServicer{},
+		scyllaClient: mockProviderFunc,
+		secretsStore: &mockStore{},
+		configs:      initialState,
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// When
+			conf, err := svc.Read(clusterID, tc.hostKey)
+			// Then
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			h, err := conf.sha256hash()
+			if err != nil {
+				t.Fatalf("error creating hash: %v", err)
+			}
+			if h != configHash {
+				t.Fatalf("expected hash %v, got %v", configHash, h)
+			}
+		})
+	}
+}
+
 func (nc NodeConfig) sha256hash() (hash [32]byte, err error) {
 	data, err := json.Marshal(nc)
 	if err != nil {