Merge pull request #1 from WarpWing/patch-1

feat(dev): added conn pool with sync.RWMutex

Author: DuckySoLucky

src/db/redis.go

@@ -3,6 +3,8 @@ package redis
 import (
 	"context"
 	"fmt"
+	"os"
+	"sync"
 	"time"
 
 	"github.com/go-redis/redis/v8"
@@ -13,29 +15,50 @@ var redisClient *redis.Client
 var redisAddr string
 var redisPassword string
 var redisDB int
+var clientMutex sync.RWMutex
 
 type RedisClient struct {
 	client *redis.Client
 }
 
 func InitRedis(addr string, password string, db int) error {
+	clientMutex.Lock()
+	defer clientMutex.Unlock()
+
 	redisAddr = addr
 	redisPassword = password
 	redisDB = db
 
 	// Don't use sync.Once with prefork mode - each process needs its own connection
 	redisClient = redis.NewClient(&redis.Options{
-		Addr:     addr,
-		Password: password,
-		DB:       db,
+		Addr:         addr,
+		Password:     password,
+		DB:           db,
+		PoolSize:     10,
+		MinIdleConns: 5,
+		MaxRetries:   3,
+		PoolTimeout:  time.Second * 4,
+		IdleTimeout:  time.Minute * 5,
+		DialTimeout:  time.Second * 5,
+		ReadTimeout:  time.Second * 3,
+		WriteTimeout: time.Second * 3,
+		PoolFIFO:     false,
 	})
 
-	_, err := redisClient.Ping(ctx).Result()
+	ctxTimeout, cancel := context.WithTimeout(ctx, time.Second*5)
+	defer cancel()
+
+	_, err := redisClient.Ping(ctxTimeout).Result()
 	if err != nil {
+		redisClient.Close()
+		redisClient = nil
 		return fmt.Errorf("could not connect to Redis: %v", err)
 	}
 
-	// fmt.Print("Redis connected successfully\n")
+	if os.Getenv("FIBER_PREFORK_CHILD") == "" {
+		fmt.Print("Redis connected successfully\n")
+	}
+	
 	return nil
 }
 
@@ -49,18 +72,29 @@ func (r *RedisClient) Set(key string, value interface{}, expirationSeconds int)
 }
 
 func Get(key string) (string, error) {
-	if redisClient == nil {
-		if redisAddr != "" {
-			err := InitRedis(redisAddr, redisPassword, redisDB)
-			if err != nil {
-				return "", fmt.Errorf("redis client not initialized and re-initialization failed: %v", err)
+	clientMutex.RLock()
+	client := redisClient
+	clientMutex.RUnlock()
+
+	if client == nil {
+		clientMutex.Lock()
+		if redisClient == nil {
+			if redisAddr != "" {
+				err := InitRedis(redisAddr, redisPassword, redisDB)
+				if err != nil {
+					clientMutex.Unlock()
+					return "", fmt.Errorf("redis client not initialized and re-initialization failed: %v", err)
+				}
+			} else {
+				clientMutex.Unlock()
+				return "", fmt.Errorf("redis client not initialized. Call InitRedis() first")
 			}
-		} else {
-			return "", fmt.Errorf("redis client not initialized. Call InitRedis() first")
 		}
+		client = redisClient
+		clientMutex.Unlock()
 	}
 
-	val, err := redisClient.Get(ctx, key).Result()
+	val, err := client.Get(ctx, key).Result()
 	if err != nil {
 		if err == redis.Nil {
 			return "", nil
@@ -72,12 +106,24 @@ func Get(key string) (string, error) {
 
 func NewRedisClient(addr string, password string, db int) *RedisClient {
 	rdb := redis.NewClient(&redis.Options{
-		Addr:     addr,
-		Password: password,
-		DB:       db,
+		Addr:         addr,
+		Password:     password,
+		DB:           db,
+		PoolSize:     10,
+		MinIdleConns: 5,
+		MaxRetries:   3,
+		PoolTimeout:  time.Second * 4,
+		IdleTimeout:  time.Minute * 5,
+		DialTimeout:  time.Second * 5,
+		ReadTimeout:  time.Second * 3,
+		WriteTimeout: time.Second * 3,
+		PoolFIFO:     false,
 	})
 
-	_, err := rdb.Ping(ctx).Result()
+	ctxTimeout, cancel := context.WithTimeout(ctx, time.Second*5)
+	defer cancel()
+
+	_, err := rdb.Ping(ctxTimeout).Result()
 	if err != nil {
 		panic(fmt.Errorf("could not connect to Redis: %v", err))
 	}
@@ -86,19 +132,30 @@ func NewRedisClient(addr string, password string, db int) *RedisClient {
 }
 
 func Set(key string, value interface{}, expirationSeconds int) error {
-	if redisClient == nil {
-		if redisAddr != "" {
-			err := InitRedis(redisAddr, redisPassword, redisDB)
-			if err != nil {
-				return fmt.Errorf("redis client not initialized and re-initialization failed: %v", err)
+	clientMutex.RLock()
+	client := redisClient
+	clientMutex.RUnlock()
+
+	if client == nil {
+		clientMutex.Lock()
+		if redisClient == nil {
+			if redisAddr != "" {
+				err := InitRedis(redisAddr, redisPassword, redisDB)
+				if err != nil {
+					clientMutex.Unlock()
+					return fmt.Errorf("redis client not initialized and re-initialization failed: %v", err)
+				}
+			} else {
+				clientMutex.Unlock()
+				return fmt.Errorf("redis client not initialized. Call InitRedis() first")
 			}
-		} else {
-			return fmt.Errorf("redis client not initialized. Call InitRedis() first")
 		}
+		client = redisClient
+		clientMutex.Unlock()
 	}
 
 	expiration := time.Duration(expirationSeconds) * time.Second
-	err := redisClient.Set(ctx, key, value, expiration).Err()
+	err := client.Set(ctx, key, value, expiration).Err()
 	if err != nil {
 		return fmt.Errorf("could not set value in Redis: %v", err)
 	}