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)
+			}
+		}
+	}
+}