feat(storage): implement Redis distributed lock and cache invalidation broadcasting

- Add Redis distributed lock in Execute of MigrationHandler to prevent concurrent storage migrations.
- Define storage:config_invalidation Redis pub/sub channel to broadcast cache invalidation events.
- Implement background pub/sub listener on all nodes to evict config memory cache concurrently.
- Add integration tests for distributed locking and invalidation propagation using miniredis.

internal/storage/config.go

@@ -88,6 +88,8 @@ func DefaultConfig() Config {
 
 // LoadConfig loads the active storage configuration.
 func LoadConfig(ctx context.Context) (Config, error) {
+	pubSubOnce.Do(startPubSubListener)
+
 	cacheMutex.RLock()
 	isCacheValid := time.Since(lastChecked) < 5*time.Second && activeConfigJSON != ""
 	configJSON := activeConfigJSON
@@ -184,6 +186,7 @@ func saveSystemConfig(ctx context.Context, key string, value any, description st
 	})
 	if err == nil && key == model.ConfigKeyStorageConfig {
 		ResetCache()
+		PublishCacheInvalidation(ctx)
 	}
 	return err
 }

internal/storage/storage.go

@@ -13,6 +13,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/Rain-kl/Wavelet/internal/db"
 	"github.com/Rain-kl/Wavelet/internal/model"
 	"gorm.io/gorm"
 )
@@ -51,6 +52,10 @@ var (
 	cacheMutex       sync.RWMutex
 )
 
+const configInvalidationChannel = "storage:config_invalidation"
+
+var pubSubOnce sync.Once
+
 // ResetCache clears the local cache for storage configuration and client singletons.
 func ResetCache() {
 	cacheMutex.Lock()
@@ -61,12 +66,39 @@ func ResetCache() {
 	lastChecked = time.Time{}
 }
 
+// PublishCacheInvalidation broadcasts cache eviction to all nodes in the cluster via Redis.
+func PublishCacheInvalidation(ctx context.Context) {
+	if db.Redis != nil {
+		_ = db.Redis.Publish(ctx, configInvalidationChannel, "reset").Err()
+	}
+}
+
+// startPubSubListener starts the background subscriber for cache invalidations.
+func startPubSubListener() {
+	if db.Redis == nil {
+		return
+	}
+	go func() {
+		pubsub := db.Redis.Subscribe(context.Background(), configInvalidationChannel)
+		defer func() {
+			_ = pubsub.Close()
+		}()
+
+		ch := pubsub.Channel()
+		for range ch {
+			ResetCache()
+		}
+	}()
+}
+
 // Active returns the configured active driver and backend, using an in-memory cache with 5s TTL.
 func Active(ctx context.Context) (Driver, Backend, error) {
 	if IsEnabledFunc() && mockBackend != nil {
 		return DriverS3, mockBackend, nil
 	}
 
+	pubSubOnce.Do(startPubSubListener)
+
 	cacheMutex.RLock()
 	isCacheValid := time.Since(lastChecked) < 5*time.Second && activeBackend != nil
 	if isCacheValid {

internal/storage/storage_test.go

@@ -4,11 +4,16 @@
 package storage
 
 import (
-	"context"
-	"encoding/json"
-	"io"
-	"testing"
-	"time"
+    "context"
+    "encoding/json"
+    "io"
+    "sync"
+    "testing"
+    "time"
+
+    "github.com/Rain-kl/Wavelet/internal/db"
+    "github.com/alicebob/miniredis/v2"
+    "github.com/redis/go-redis/v9"
 )
 
 func TestStorageCache(t *testing.T) {
@@ -80,3 +85,68 @@ func TestStorageCache(t *testing.T) {
 		t.Fatal("ResetCache did not clear cache variables after setting them")
 	}
 }
+
+func TestStorageCachePubSub(t *testing.T) {
+	// 1. Start miniredis
+	mr, err := miniredis.Run()
+	if err != nil {
+		t.Fatalf("Failed to run miniredis: %v", err)
+	}
+	defer mr.Close()
+
+	// 2. Initialize Redis client
+	rdb := redis.NewClient(&redis.Options{
+		Addr: mr.Addr(),
+	})
+	defer rdb.Close()
+
+	// 3. Set db.Redis to our client
+	oldRedis := db.Redis
+	db.Redis = rdb
+	defer func() {
+		db.Redis = oldRedis
+	}()
+
+	// Reset cache and set some cached config
+	ResetCache()
+	cacheMutex.Lock()
+	activeConfigJSON = "some_config"
+	lastChecked = time.Now()
+	cacheMutex.Unlock()
+
+	// 4. Force trigger lazy initialization of subscription
+	// Reset the once guard so it runs the listener
+	pubSubOnce = sync.Once{}
+	ctx := context.Background()
+
+	// Create mock backend for Active call
+	mockBnd := &functionBackend{
+		put:    func(context.Context, string, io.Reader, int64, string) error { return nil },
+		get:    func(context.Context, string) (*Object, error) { return nil, nil },
+		delete: func(context.Context, string) error { return nil },
+	}
+	cacheMutex.Lock()
+	activeBackend = mockBnd
+	activeDriver = DriverLocal
+	cacheMutex.Unlock()
+
+	_, _, _ = Active(ctx) // This calls startPubSubListener()
+
+	// Allow some time for subscriber connection
+	time.Sleep(100 * time.Millisecond)
+
+	// 5. Publish cache invalidation
+	PublishCacheInvalidation(ctx)
+
+	// Allow message propagation
+	time.Sleep(100 * time.Millisecond)
+
+	// 6. Verify cache was cleared
+	cacheMutex.RLock()
+	configJSON := activeConfigJSON
+	cacheMutex.RUnlock()
+
+	if configJSON != "" {
+		t.Error("Memory cache was not cleared after Redis Pub/Sub broadcast")
+	}
+}