Merge branch 'master' of https://github.com/redis/go-redis into xinfo-groups-nil-lag-support

Author: ofekshenawa

.github/actions/run-tests/action.yml

@@ -25,7 +25,7 @@ runs:
         
         # Mapping of redis version to redis testing containers
         declare -A redis_version_mapping=(
-          ["8.0-RC2"]="8.0-RC2-pre"
+          ["8.0.1"]="8.0.1-pre"
           ["7.4.2"]="rs-7.4.0-v2"
           ["7.2.7"]="rs-7.2.0-v14"
         )

.github/workflows/build.yml

@@ -18,7 +18,7 @@ jobs:
       fail-fast: false
       matrix:
         redis-version:
-          - "8.0-RC2" # 8.0 RC2
+          - "8.0.1" # 8.0.1
           - "7.4.2" # should use redis stack 7.4
         go-version:
           - "1.23.x"
@@ -43,7 +43,7 @@ jobs:
           
           # Mapping of redis version to redis testing containers
           declare -A redis_version_mapping=(
-            ["8.0-RC2"]="8.0-RC2-pre"
+            ["8.0.1"]="8.0.1-pre"
             ["7.4.2"]="rs-7.4.0-v2"
           )
           if [[ -v redis_version_mapping[$REDIS_VERSION] ]]; then
@@ -72,7 +72,7 @@ jobs:
         fail-fast: false
         matrix:
           redis-version:
-            - "8.0-RC2" # 8.0 RC2
+            - "8.0.1" # 8.0.1
             - "7.4.2" # should use redis stack 7.4
             - "7.2.7" # should redis stack 7.2
           go-version:

error.go

@@ -15,6 +15,13 @@ import (
 // ErrClosed performs any operation on the closed client will return this error.
 var ErrClosed = pool.ErrClosed
 
+// ErrPoolExhausted is returned from a pool connection method
+// when the maximum number of database connections in the pool has been reached.
+var ErrPoolExhausted = pool.ErrPoolExhausted
+
+// ErrPoolTimeout timed out waiting to get a connection from the connection pool.
+var ErrPoolTimeout = pool.ErrPoolTimeout
+
 // HasErrorPrefix checks if the err is a Redis error and the message contains a prefix.
 func HasErrorPrefix(err error, prefix string) bool {
 	var rErr Error

example_test.go

@@ -359,7 +359,7 @@ func ExampleMapStringStringCmd_Scan() {
 	// Get the map. The same approach works for HmGet().
 	res := rdb.HGetAll(ctx, "map")
 	if res.Err() != nil {
-		panic(err)
+		panic(res.Err())
 	}
 
 	type data struct {
@@ -392,7 +392,7 @@ func ExampleSliceCmd_Scan() {
 
 	res := rdb.MGet(ctx, "name", "count", "empty", "correct")
 	if res.Err() != nil {
-		panic(err)
+		panic(res.Err())
 	}
 
 	type data struct {

export_test.go

@@ -11,8 +11,6 @@ import (
 	"github.com/redis/go-redis/v9/internal/pool"
 )
 
-var ErrPoolTimeout = pool.ErrPoolTimeout
-
 func (c *baseClient) Pool() pool.Pooler {
 	return c.connPool
 }

helper/helper.go

@@ -0,0 +1,11 @@
+package helper
+
+import "github.com/redis/go-redis/v9/internal/util"
+
+func ParseFloat(s string) (float64, error) {
+	return util.ParseStringToFloat(s)
+}
+
+func MustParseFloat(s string) float64 {
+	return util.MustParseFloat(s)
+}

internal/pool/pool_test.go

@@ -387,4 +387,33 @@ var _ = Describe("race", func() {
 		Expect(stats.WaitCount).To(Equal(uint32(1)))
 		Expect(stats.WaitDurationNs).To(BeNumerically("~", time.Second.Nanoseconds(), 100*time.Millisecond.Nanoseconds()))
 	})
+
+	It("timeout", func() {
+		testPoolTimeout := 1 * time.Second
+		opt := &pool.Options{
+			Dialer: func(ctx context.Context) (net.Conn, error) {
+				// Artificial delay to force pool timeout
+				time.Sleep(3 * testPoolTimeout)
+
+				return &net.TCPConn{}, nil
+			},
+			PoolSize:    1,
+			PoolTimeout: testPoolTimeout,
+		}
+		p := pool.NewConnPool(opt)
+
+		stats := p.Stats()
+		Expect(stats.Timeouts).To(Equal(uint32(0)))
+
+		conn, err := p.Get(ctx)
+		Expect(err).NotTo(HaveOccurred())
+		_, err = p.Get(ctx)
+		Expect(err).To(MatchError(pool.ErrPoolTimeout))
+		p.Put(ctx, conn)
+		conn, err = p.Get(ctx)
+		Expect(err).NotTo(HaveOccurred())
+
+		stats = p.Stats()
+		Expect(stats.Timeouts).To(Equal(uint32(1)))
+	})
 })

internal/util.go

@@ -49,22 +49,7 @@ func isLower(s string) bool {
 }
 
 func ReplaceSpaces(s string) string {
-	// Pre-allocate a builder with the same length as s to minimize allocations.
-	// This is a basic optimization; adjust the initial size based on your use case.
-	var builder strings.Builder
-	builder.Grow(len(s))
-
-	for _, char := range s {
-		if char == ' ' {
-			// Replace space with a hyphen.
-			builder.WriteRune('-')
-		} else {
-			// Copy the character as-is.
-			builder.WriteRune(char)
-		}
-	}
-
-	return builder.String()
+	return strings.ReplaceAll(s, " ", "-")
 }
 
 func GetAddr(addr string) string {

internal/util/convert.go

@@ -0,0 +1,30 @@
+package util
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+)
+
+// ParseFloat parses a Redis RESP3 float reply into a Go float64,
+// handling "inf", "-inf", "nan" per Redis conventions.
+func ParseStringToFloat(s string) (float64, error) {
+	switch s {
+	case "inf":
+		return math.Inf(1), nil
+	case "-inf":
+		return math.Inf(-1), nil
+	case "nan", "-nan":
+		return math.NaN(), nil
+	}
+	return strconv.ParseFloat(s, 64)
+}
+
+// MustParseFloat is like ParseFloat but panics on parse errors.
+func MustParseFloat(s string) float64 {
+	f, err := ParseStringToFloat(s)
+	if err != nil {
+		panic(fmt.Sprintf("redis: failed to parse float %q: %v", s, err))
+	}
+	return f
+}

internal/util/convert_test.go

@@ -0,0 +1,40 @@
+package util
+
+import (
+	"math"
+	"testing"
+)
+
+func TestParseStringToFloat(t *testing.T) {
+	tests := []struct {
+		in   string
+		want float64
+		ok   bool
+	}{
+		{"1.23", 1.23, true},
+		{"inf", math.Inf(1), true},
+		{"-inf", math.Inf(-1), true},
+		{"nan", math.NaN(), true},
+		{"oops", 0, false},
+	}
+
+	for _, tc := range tests {
+		got, err := ParseStringToFloat(tc.in)
+		if tc.ok {
+			if err != nil {
+				t.Fatalf("ParseFloat(%q) error: %v", tc.in, err)
+			}
+			if math.IsNaN(tc.want) {
+				if !math.IsNaN(got) {
+					t.Errorf("ParseFloat(%q) = %v; want NaN", tc.in, got)
+				}
+			} else if got != tc.want {
+				t.Errorf("ParseFloat(%q) = %v; want %v", tc.in, got, tc.want)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("ParseFloat(%q) expected error, got nil", tc.in)
+			}
+		}
+	}
+}

internal/util/strconv_test.go

@@ -0,0 +1,101 @@
+package util
+
+import (
+	"math"
+	"testing"
+)
+
+func TestAtoi(t *testing.T) {
+	tests := []struct {
+		input    []byte
+		expected int
+		wantErr  bool
+	}{
+		{[]byte("123"), 123, false},
+		{[]byte("-456"), -456, false},
+		{[]byte("abc"), 0, true},
+	}
+
+	for _, tt := range tests {
+		result, err := Atoi(tt.input)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("Atoi(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
+		}
+		if result != tt.expected && !tt.wantErr {
+			t.Errorf("Atoi(%q) = %d, want %d", tt.input, result, tt.expected)
+		}
+	}
+}
+
+func TestParseInt(t *testing.T) {
+	tests := []struct {
+		input    []byte
+		base     int
+		bitSize  int
+		expected int64
+		wantErr  bool
+	}{
+		{[]byte("123"), 10, 64, 123, false},
+		{[]byte("-7F"), 16, 64, -127, false},
+		{[]byte("zzz"), 36, 64, 46655, false},
+		{[]byte("invalid"), 10, 64, 0, true},
+	}
+
+	for _, tt := range tests {
+		result, err := ParseInt(tt.input, tt.base, tt.bitSize)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("ParseInt(%q, base=%d) error = %v, wantErr %v", tt.input, tt.base, err, tt.wantErr)
+		}
+		if result != tt.expected && !tt.wantErr {
+			t.Errorf("ParseInt(%q, base=%d) = %d, want %d", tt.input, tt.base, result, tt.expected)
+		}
+	}
+}
+
+func TestParseUint(t *testing.T) {
+	tests := []struct {
+		input    []byte
+		base     int
+		bitSize  int
+		expected uint64
+		wantErr  bool
+	}{
+		{[]byte("255"), 10, 8, 255, false},
+		{[]byte("FF"), 16, 16, 255, false},
+		{[]byte("-1"), 10, 8, 0, true}, // negative should error for unsigned
+	}
+
+	for _, tt := range tests {
+		result, err := ParseUint(tt.input, tt.base, tt.bitSize)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("ParseUint(%q, base=%d) error = %v, wantErr %v", tt.input, tt.base, err, tt.wantErr)
+		}
+		if result != tt.expected && !tt.wantErr {
+			t.Errorf("ParseUint(%q, base=%d) = %d, want %d", tt.input, tt.base, result, tt.expected)
+		}
+	}
+}
+
+func TestParseFloat(t *testing.T) {
+	tests := []struct {
+		input    []byte
+		bitSize  int
+		expected float64
+		wantErr  bool
+	}{
+		{[]byte("3.14"), 64, 3.14, false},
+		{[]byte("-2.71"), 64, -2.71, false},
+		{[]byte("NaN"), 64, math.NaN(), false},
+		{[]byte("invalid"), 64, 0, true},
+	}
+
+	for _, tt := range tests {
+		result, err := ParseFloat(tt.input, tt.bitSize)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("ParseFloat(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
+		}
+		if !tt.wantErr && !(math.IsNaN(tt.expected) && math.IsNaN(result)) && result != tt.expected {
+			t.Errorf("ParseFloat(%q) = %v, want %v", tt.input, result, tt.expected)
+		}
+	}
+}

internal/util_test.go

@@ -1,6 +1,7 @@
 package internal
 
 import (
+	"runtime"
 	"strings"
 	"testing"
 
@@ -72,3 +73,36 @@ func TestGetAddr(t *testing.T) {
 		Expect(GetAddr("127")).To(Equal(""))
 	})
 }
+
+func BenchmarkReplaceSpaces(b *testing.B) {
+	version := runtime.Version()
+	for i := 0; i < b.N; i++ {
+		_ = ReplaceSpaces(version)
+	}
+}
+
+func ReplaceSpacesUseBuilder(s string) string {
+	// Pre-allocate a builder with the same length as s to minimize allocations.
+	// This is a basic optimization; adjust the initial size based on your use case.
+	var builder strings.Builder
+	builder.Grow(len(s))
+
+	for _, char := range s {
+		if char == ' ' {
+			// Replace space with a hyphen.
+			builder.WriteRune('-')
+		} else {
+			// Copy the character as-is.
+			builder.WriteRune(char)
+		}
+	}
+
+	return builder.String()
+}
+
+func BenchmarkReplaceSpacesUseBuilder(b *testing.B) {
+	version := runtime.Version()
+	for i := 0; i < b.N; i++ {
+		_ = ReplaceSpacesUseBuilder(version)
+	}
+}

internal_test.go

@@ -364,14 +364,14 @@ var _ = Describe("ClusterClient", func() {
 		It("select slot from args for GETKEYSINSLOT command", func() {
 			cmd := NewStringSliceCmd(ctx, "cluster", "getkeysinslot", 100, 200)
 
-			slot := client.cmdSlot(context.Background(), cmd)
+			slot := client.cmdSlot(cmd)
 			Expect(slot).To(Equal(100))
 		})
 
 		It("select slot from args for COUNTKEYSINSLOT command", func() {
 			cmd := NewStringSliceCmd(ctx, "cluster", "countkeysinslot", 100)
 
-			slot := client.cmdSlot(context.Background(), cmd)
+			slot := client.cmdSlot(cmd)
 			Expect(slot).To(Equal(100))
 		})
 	})

main_test.go

@@ -100,7 +100,8 @@ var _ = BeforeSuite(func() {
 
 	fmt.Printf("RECluster: %v\n", RECluster)
 	fmt.Printf("RCEDocker: %v\n", RCEDocker)
-	fmt.Printf("REDIS_VERSION: %v\n", RedisVersion)
+	fmt.Printf("REDIS_VERSION: %.1f\n", RedisVersion)
+	fmt.Printf("CLIENT_LIBS_TEST_IMAGE: %v\n", os.Getenv("CLIENT_LIBS_TEST_IMAGE"))
 
 	if RedisVersion < 7.0 || RedisVersion > 9 {
 		panic("incorrect or not supported redis version")