Go Fork Redis Client Library

package main

import (
    "context"
    "log"
    "time"
    
    "go.fork.vn/config"
    "go.fork.vn/di"
    "go.fork.vn/redis"
)

func main() {
    // 1. Setup DI Container
    app := di.New()
    
    // 2. Register Providers
    app.Register("config", config.NewProvider())
    app.Register("redis", redis.NewServiceProvider())
    
    // 3. Boot Application
    ctx := context.Background()
    if err := app.Boot(ctx); err != nil {
        log.Fatal("Boot failed:", err)
    }
    
    // 4. Get Redis Manager
    var manager redis.Manager
    if err := app.Resolve("redis.manager", &manager); err != nil {
        log.Fatal("Resolve failed:", err)
    }
    defer manager.Close()
    
    // 5. Use Redis
    // Set value
    if err := manager.Set(ctx, "user:123", "John Doe", time.Hour); err != nil {
        log.Fatal("Set failed:", err)
    }
    
    // Get value
    value, err := manager.Get(ctx, "user:123")
    if err != nil {
        log.Fatal("Get failed:", err)
    }
    
    log.Printf("User: %s", value) // Output: User: John Doe
    
    // Hash operations
    if err := manager.HSet(ctx, "user:123:profile",
        "name", "John Doe",
        "email", "john@example.com",
        "age", "30"); err != nil {
        log.Fatal("HSet failed:", err)
    }
    
    profile, err := manager.HGetAll(ctx, "user:123:profile")
    if err != nil {
        log.Fatal("HGetAll failed:", err)
    }
    
    log.Printf("Profile: %+v", profile)
}

// Simple caching service
type CacheService struct {
    redis redis.Manager
}

func (s *CacheService) GetUser(ctx context.Context, userID string) (*User, error) {
    key := fmt.Sprintf("user:%s", userID)
    
    // Try cache first
    data, err := s.redis.Get(ctx, key)
    if err != nil && err != redis.ErrKeyNotFound {
        return nil, err
    }
    
    if data != "" {
        var user User
        json.Unmarshal([]byte(data), &user)
        return &user, nil
    }
    
    // Cache miss - get from database
    user, err := s.getUserFromDB(ctx, userID)
    if err != nil {
        return nil, err
    }
    
    // Cache for 1 hour
    userData, _ := json.Marshal(user)
    s.redis.Set(ctx, key, userData, time.Hour)
    
    return user, nil
}

// Distributed session manager
type SessionManager struct {
    redis redis.Manager
}

func (s *SessionManager) CreateSession(ctx context.Context, userID string) (*Session, error) {
    sessionID := uuid.New().String()
    session := &Session{
        ID:        sessionID,
        UserID:    userID,
        CreatedAt: time.Now(),
        ExpiresAt: time.Now().Add(24 * time.Hour),
    }
    
    // Use pipeline for atomic operations
    pipe := s.redis.Pipeline()
    
    sessionKey := fmt.Sprintf("session:%s", sessionID)
    pipe.HSet(ctx, sessionKey, map[string]interface{}{
        "user_id":    session.UserID,
        "created_at": session.CreatedAt.Unix(),
        "expires_at": session.ExpiresAt.Unix(),
    })
    pipe.Expire(ctx, sessionKey, 24*time.Hour)
    
    // Track user's active sessions
    userSessionsKey := fmt.Sprintf("user:%s:sessions", userID)
    pipe.SAdd(ctx, userSessionsKey, sessionID)
    pipe.Expire(ctx, userSessionsKey, 25*time.Hour)
    
    _, err := pipe.Exec(ctx)
    return session, err
}

// Pub/Sub notification service with Sentinel
type NotificationService struct {
    redis redis.Manager
}

func (s *NotificationService) PublishNotification(ctx context.Context, userID string, notification *Notification) error {
    channel := fmt.Sprintf("notifications:%s", userID)
    
    data, err := json.Marshal(notification)
    if err != nil {
        return err
    }
    
    // Universal client handles master/slave routing automatically
    if _, err := s.redis.Publish(ctx, channel, data); err != nil {
        return err
    }
    
    // Store in persistent queue (writes to master)
    queueKey := fmt.Sprintf("user:%s:notifications", userID)
    return s.redis.LPush(ctx, queueKey, data)
}

func (s *NotificationService) GetUnreadCount(ctx context.Context, userID string) (int64, error) {
    queueKey := fmt.Sprintf("user:%s:notifications", userID)
    // This read can be routed to slave automatically
    return s.redis.LLen(ctx, queueKey)
}

// Built-in health checks
type HealthChecker struct {
    redis redis.Manager
}

func (h *HealthChecker) CheckRedisHealth(ctx context.Context) error {
    // Test connectivity
    if err := h.redis.Ping(ctx); err != nil {
        return fmt.Errorf("redis ping failed: %w", err)
    }
    
    // Test operations
    testKey := "health:check:" + time.Now().Format("20060102150405")
    if err := h.redis.Set(ctx, testKey, "ok", time.Minute); err != nil {
        return fmt.Errorf("redis set failed: %w", err)
    }
    
    value, err := h.redis.Get(ctx, testKey)
    if err != nil {
        return fmt.Errorf("redis get failed: %w", err)
    }
    
    if value != "ok" {
        return fmt.Errorf("health check failed")
    }
    
    h.redis.Del(ctx, testKey)
    return nil
}

// Enable debug logging
import "log"

config := &redis.Config{
    Universal: &redis.UniversalConfig{
        // ... other config
    },
}

// Add debug wrapper
manager := redis.NewManager(config)
manager = redis.WithDebugLogging(manager, log.Default())