+
+
package cache
+
+import (
+ "context"
+ "sync"
+ "time"
+)
+
+// MemoryCache implements CacheEngine using in-memory storage
+type MemoryCache struct {
+ config *CacheConfig
+ items map[string]cacheItem
+ mutex sync.RWMutex
+ cleanupCtx context.Context
+ cancelFunc context.CancelFunc
+}
+
+type cacheItem struct {
+ value interface{}
+ expiration time.Time
+}
+
+// NewMemoryCache creates a new memory cache engine
+func NewMemoryCache(config *CacheConfig) *MemoryCache {
+ return &MemoryCache{
+ config: config,
+ items: make(map[string]cacheItem),
+ }
+}
+
+// Connect initializes the memory cache
+func (c *MemoryCache) Connect(ctx context.Context) error {
+ // Start cleanup goroutine
+ c.cleanupCtx, c.cancelFunc = context.WithCancel(ctx)
+ go c.startCleanupTimer(c.cleanupCtx)
+ return nil
+}
+
+// Close stops the memory cache cleanup routine
+func (c *MemoryCache) Close(_ context.Context) error {
+ if c.cancelFunc != nil {
+ c.cancelFunc()
+ }
+ return nil
+}
+
+// Get retrieves an item from the cache
+func (c *MemoryCache) Get(_ context.Context, key string) (interface{}, bool) {
+ c.mutex.RLock()
+ item, found := c.items[key]
+ c.mutex.RUnlock()
+
+ if !found {
+ return nil, false
+ }
+
+ // Check if the item has expired
+ if !item.expiration.IsZero() && time.Now().After(item.expiration) {
+ c.mutex.Lock()
+ delete(c.items, key)
+ c.mutex.Unlock()
+ return nil, false
+ }
+
+ return item.value, true
+}
+
+// Set stores an item in the cache
+func (c *MemoryCache) Set(_ context.Context, key string, value interface{}, ttl time.Duration) error {
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ // If cache is full, reject new items
+ if c.config.MaxItems > 0 && len(c.items) >= c.config.MaxItems {
+ _, exists := c.items[key]
+ if !exists {
+ return ErrCacheFull
+ }
+ }
+
+ var exp time.Time
+ if ttl > 0 {
+ exp = time.Now().Add(ttl)
+ }
+
+ c.items[key] = cacheItem{
+ value: value,
+ expiration: exp,
+ }
+
+ return nil
+}
+
+// Delete removes an item from the cache
+func (c *MemoryCache) Delete(_ context.Context, key string) error {
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ delete(c.items, key)
+ return nil
+}
+
+// Flush removes all items from the cache
+func (c *MemoryCache) Flush(_ context.Context) error {
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ c.items = make(map[string]cacheItem)
+ return nil
+}
+
+// GetMulti retrieves multiple items from the cache
+func (c *MemoryCache) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error) {
+ result := make(map[string]interface{}, len(keys))
+ for _, key := range keys {
+ if value, found := c.Get(ctx, key); found {
+ result[key] = value
+ }
+ }
+ return result, nil
+}
+
+// SetMulti stores multiple items in the cache
+func (c *MemoryCache) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error {
+ for key, value := range items {
+ if err := c.Set(ctx, key, value, ttl); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// DeleteMulti removes multiple items from the cache
+func (c *MemoryCache) DeleteMulti(ctx context.Context, keys []string) error {
+ for _, key := range keys {
+ if err := c.Delete(ctx, key); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// startCleanupTimer starts the cleanup timer for expired items
+func (c *MemoryCache) startCleanupTimer(ctx context.Context) {
+ ticker := time.NewTicker(time.Duration(c.config.CleanupInterval) * time.Second)
+ defer ticker.Stop()
+
+ for {
+ select {
+ case <-ticker.C:
+ c.cleanupExpiredItems()
+ case <-ctx.Done():
+ return
+ }
+ }
+}
+
+// cleanupExpiredItems removes expired items from the cache
+func (c *MemoryCache) cleanupExpiredItems() {
+ now := time.Now()
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ for key, item := range c.items {
+ if !item.expiration.IsZero() && now.After(item.expiration) {
+ delete(c.items, key)
+ }
+ }
+}
+
+
+
package cache
+
+import (
+ "context"
+ "time"
+
+ "github.com/GoCodeAlone/modular"
+)
+
+// ModuleName is the name of this module
+const ModuleName = "cache"
+
+// ServiceName is the name of the service provided by this module
+const ServiceName = "cache.provider"
+
+// CacheModule represents the cache module
+type CacheModule struct {
+ name string
+ config *CacheConfig
+ logger modular.Logger
+ cacheEngine CacheEngine
+}
+
+// NewModule creates a new instance of the cache module
+func NewModule() modular.Module {
+ return &CacheModule{
+ name: ModuleName,
+ }
+}
+
+// Name returns the name of the module
+func (m *CacheModule) Name() string {
+ return m.name
+}
+
+// RegisterConfig registers the module's configuration structure
+func (m *CacheModule) RegisterConfig(app modular.Application) error {
+ // Register the configuration with default values
+ defaultConfig := &CacheConfig{
+ Engine: "memory",
+ DefaultTTL: 300,
+ CleanupInterval: 60,
+ MaxItems: 10000,
+ RedisURL: "",
+ RedisPassword: "",
+ RedisDB: 0,
+ ConnectionMaxAge: 60,
+ }
+
+ app.RegisterConfigSection(m.Name(), modular.NewStdConfigProvider(defaultConfig))
+ return nil
+}
+
+// Init initializes the module
+func (m *CacheModule) Init(app modular.Application) error {
+ // Retrieve the registered config section for access
+ cfg, err := app.GetConfigSection(m.name)
+ if err != nil {
+ return err
+ }
+
+ m.config = cfg.GetConfig().(*CacheConfig)
+ m.logger = app.Logger()
+
+ // Initialize the appropriate cache engine based on configuration
+ switch m.config.Engine {
+ case "memory":
+ m.cacheEngine = NewMemoryCache(m.config)
+ m.logger.Info("Initialized memory cache engine", "maxItems", m.config.MaxItems)
+ case "redis":
+ m.cacheEngine = NewRedisCache(m.config)
+ m.logger.Info("Initialized Redis cache engine", "url", m.config.RedisURL)
+ default:
+ m.cacheEngine = NewMemoryCache(m.config)
+ m.logger.Warn("Unknown cache engine specified, using memory cache", "specified", m.config.Engine)
+ }
+
+ m.logger.Info("Cache module initialized")
+ return nil
+}
+
+// Start performs startup logic for the module
+func (m *CacheModule) Start(ctx context.Context) error {
+ m.logger.Info("Starting cache module")
+ err := m.cacheEngine.Connect(ctx)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Stop performs shutdown logic for the module
+func (m *CacheModule) Stop(ctx context.Context) error {
+ m.logger.Info("Stopping cache module")
+ return m.cacheEngine.Close(ctx)
+}
+
+// Dependencies returns the names of modules this module depends on
+func (m *CacheModule) Dependencies() []string {
+ return nil
+}
+
+// ProvidesServices declares services provided by this module
+func (m *CacheModule) ProvidesServices() []modular.ServiceProvider {
+ return []modular.ServiceProvider{
+ {
+ Name: ServiceName,
+ Description: "Cache service for storing and retrieving data",
+ Instance: m,
+ },
+ }
+}
+
+// RequiresServices declares services required by this module
+func (m *CacheModule) RequiresServices() []modular.ServiceDependency {
+ return nil
+}
+
+// Constructor provides a dependency injection constructor for the module
+func (m *CacheModule) Constructor() modular.ModuleConstructor {
+ return func(app modular.Application, services map[string]any) (modular.Module, error) {
+ return m, nil
+ }
+}
+
+// Get retrieves a cached item by key
+func (m *CacheModule) Get(ctx context.Context, key string) (interface{}, bool) {
+ return m.cacheEngine.Get(ctx, key)
+}
+
+// Set stores an item in the cache with an optional TTL
+func (m *CacheModule) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error {
+ if ttl == 0 {
+ ttl = time.Duration(m.config.DefaultTTL) * time.Second
+ }
+ return m.cacheEngine.Set(ctx, key, value, ttl)
+}
+
+// Delete removes an item from the cache
+func (m *CacheModule) Delete(ctx context.Context, key string) error {
+ return m.cacheEngine.Delete(ctx, key)
+}
+
+// Flush removes all items from the cache
+func (m *CacheModule) Flush(ctx context.Context) error {
+ return m.cacheEngine.Flush(ctx)
+}
+
+// GetMulti retrieves multiple items from the cache
+func (m *CacheModule) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error) {
+ return m.cacheEngine.GetMulti(ctx, keys)
+}
+
+// SetMulti stores multiple items in the cache
+func (m *CacheModule) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error {
+ if ttl == 0 {
+ ttl = time.Duration(m.config.DefaultTTL) * time.Second
+ }
+ return m.cacheEngine.SetMulti(ctx, items, ttl)
+}
+
+// DeleteMulti removes multiple items from the cache
+func (m *CacheModule) DeleteMulti(ctx context.Context, keys []string) error {
+ return m.cacheEngine.DeleteMulti(ctx, keys)
+}
+
+
+
package cache
+
+import (
+ "context"
+ "encoding/json"
+ "time"
+
+ "github.com/redis/go-redis/v9"
+)
+
+// RedisCache implements CacheEngine using Redis
+type RedisCache struct {
+ config *CacheConfig
+ client *redis.Client
+}
+
+// NewRedisCache creates a new Redis cache engine
+func NewRedisCache(config *CacheConfig) *RedisCache {
+ return &RedisCache{
+ config: config,
+ }
+}
+
+// Connect establishes connection to Redis
+func (c *RedisCache) Connect(ctx context.Context) error {
+ opts, err := redis.ParseURL(c.config.RedisURL)
+ if err != nil {
+ return err
+ }
+
+ if c.config.RedisPassword != "" {
+ opts.Password = c.config.RedisPassword
+ }
+
+ opts.DB = c.config.RedisDB
+ opts.ConnMaxLifetime = time.Duration(c.config.ConnectionMaxAge) * time.Second
+
+ c.client = redis.NewClient(opts)
+
+ // Test the connection
+ return c.client.Ping(ctx).Err()
+}
+
+// Close closes the connection to Redis
+func (c *RedisCache) Close(ctx context.Context) error {
+ if c.client != nil {
+ return c.client.Close()
+ }
+ return nil
+}
+
+// Get retrieves an item from the Redis cache
+func (c *RedisCache) Get(ctx context.Context, key string) (interface{}, bool) {
+ if c.client == nil {
+ return nil, false
+ }
+
+ val, err := c.client.Get(ctx, key).Result()
+ if err != nil {
+ if err == redis.Nil {
+ return nil, false
+ }
+ return nil, false
+ }
+
+ var result interface{}
+ if err := json.Unmarshal([]byte(val), &result); err != nil {
+ return nil, false
+ }
+
+ return result, true
+}
+
+// Set stores an item in the Redis cache with a TTL
+func (c *RedisCache) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error {
+ if c.client == nil {
+ return ErrNotConnected
+ }
+
+ data, err := json.Marshal(value)
+ if err != nil {
+ return ErrInvalidValue
+ }
+
+ return c.client.Set(ctx, key, data, ttl).Err()
+}
+
+// Delete removes an item from the Redis cache
+func (c *RedisCache) Delete(ctx context.Context, key string) error {
+ if c.client == nil {
+ return ErrNotConnected
+ }
+
+ return c.client.Del(ctx, key).Err()
+}
+
+// Flush removes all items from the Redis cache
+func (c *RedisCache) Flush(ctx context.Context) error {
+ if c.client == nil {
+ return ErrNotConnected
+ }
+
+ return c.client.FlushDB(ctx).Err()
+}
+
+// GetMulti retrieves multiple items from the Redis cache
+func (c *RedisCache) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error) {
+ if len(keys) == 0 {
+ return make(map[string]interface{}), nil
+ }
+
+ if c.client == nil {
+ return nil, ErrNotConnected
+ }
+
+ vals, err := c.client.MGet(ctx, keys...).Result()
+ if err != nil {
+ return nil, err
+ }
+
+ result := make(map[string]interface{}, len(keys))
+ for i, val := range vals {
+ if val != nil {
+ var value interface{}
+ if str, ok := val.(string); ok {
+ if err := json.Unmarshal([]byte(str), &value); err == nil {
+ result[keys[i]] = value
+ }
+ }
+ }
+ }
+
+ return result, nil
+}
+
+// SetMulti stores multiple items in the Redis cache with a TTL
+func (c *RedisCache) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error {
+ if len(items) == 0 {
+ return nil
+ }
+
+ if c.client == nil {
+ return ErrNotConnected
+ }
+
+ pipe := c.client.Pipeline()
+ for key, value := range items {
+ data, err := json.Marshal(value)
+ if err != nil {
+ return ErrInvalidValue
+ }
+ pipe.Set(ctx, key, data, ttl)
+ }
+
+ _, err := pipe.Exec(ctx)
+ return err
+}
+
+// DeleteMulti removes multiple items from the Redis cache
+func (c *RedisCache) DeleteMulti(ctx context.Context, keys []string) error {
+ if len(keys) == 0 {
+ return nil
+ }
+
+ if c.client == nil {
+ return ErrNotConnected
+ }
+
+ return c.client.Del(ctx, keys...).Err()
+}
+
+
+
-
-
package cache
-
-import (
- "context"
- "sync"
- "time"
-)
-
-// MemoryCache implements CacheEngine using in-memory storage
-type MemoryCache struct {
- config *CacheConfig
- items map[string]cacheItem
- mutex sync.RWMutex
- cleanupCtx context.Context
- cancelFunc context.CancelFunc
-}
-
-type cacheItem struct {
- value interface{}
- expiration time.Time
-}
-
-// NewMemoryCache creates a new memory cache engine
-func NewMemoryCache(config *CacheConfig) *MemoryCache {
- return &MemoryCache{
- config: config,
- items: make(map[string]cacheItem),
- }
-}
-
-// Connect initializes the memory cache
-func (c *MemoryCache) Connect(ctx context.Context) error {
- // Start cleanup goroutine
- c.cleanupCtx, c.cancelFunc = context.WithCancel(ctx)
- go c.startCleanupTimer(c.cleanupCtx)
- return nil
-}
-
-// Close stops the memory cache cleanup routine
-func (c *MemoryCache) Close(_ context.Context) error {
- if c.cancelFunc != nil {
- c.cancelFunc()
- }
- return nil
-}
-
-// Get retrieves an item from the cache
-func (c *MemoryCache) Get(_ context.Context, key string) (interface{}, bool) {
- c.mutex.RLock()
- item, found := c.items[key]
- c.mutex.RUnlock()
-
- if !found {
- return nil, false
- }
-
- // Check if the item has expired
- if !item.expiration.IsZero() && time.Now().After(item.expiration) {
- c.mutex.Lock()
- delete(c.items, key)
- c.mutex.Unlock()
- return nil, false
- }
-
- return item.value, true
-}
-
-// Set stores an item in the cache
-func (c *MemoryCache) Set(_ context.Context, key string, value interface{}, ttl time.Duration) error {
- c.mutex.Lock()
- defer c.mutex.Unlock()
-
- // If cache is full, reject new items
- if c.config.MaxItems > 0 && len(c.items) >= c.config.MaxItems {
- _, exists := c.items[key]
- if !exists {
- return ErrCacheFull
- }
- }
-
- var exp time.Time
- if ttl > 0 {
- exp = time.Now().Add(ttl)
- }
-
- c.items[key] = cacheItem{
- value: value,
- expiration: exp,
- }
-
- return nil
-}
-
-// Delete removes an item from the cache
-func (c *MemoryCache) Delete(_ context.Context, key string) error {
- c.mutex.Lock()
- defer c.mutex.Unlock()
-
- delete(c.items, key)
- return nil
-}
-
-// Flush removes all items from the cache
-func (c *MemoryCache) Flush(_ context.Context) error {
- c.mutex.Lock()
- defer c.mutex.Unlock()
-
- c.items = make(map[string]cacheItem)
- return nil
-}
-
-// GetMulti retrieves multiple items from the cache
-func (c *MemoryCache) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error) {
- result := make(map[string]interface{}, len(keys))
- for _, key := range keys {
- if value, found := c.Get(ctx, key); found {
- result[key] = value
- }
- }
- return result, nil
-}
-
-// SetMulti stores multiple items in the cache
-func (c *MemoryCache) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error {
- for key, value := range items {
- if err := c.Set(ctx, key, value, ttl); err != nil {
- return err
- }
- }
- return nil
-}
-
-// DeleteMulti removes multiple items from the cache
-func (c *MemoryCache) DeleteMulti(ctx context.Context, keys []string) error {
- for _, key := range keys {
- if err := c.Delete(ctx, key); err != nil {
- return err
- }
- }
- return nil
-}
-
-// startCleanupTimer starts the cleanup timer for expired items
-func (c *MemoryCache) startCleanupTimer(ctx context.Context) {
- ticker := time.NewTicker(time.Duration(c.config.CleanupInterval) * time.Second)
- defer ticker.Stop()
-
- for {
- select {
- case <-ticker.C:
- c.cleanupExpiredItems()
- case <-ctx.Done():
- return
- }
- }
-}
-
-// cleanupExpiredItems removes expired items from the cache
-func (c *MemoryCache) cleanupExpiredItems() {
- now := time.Now()
- c.mutex.Lock()
- defer c.mutex.Unlock()
-
- for key, item := range c.items {
- if !item.expiration.IsZero() && now.After(item.expiration) {
- delete(c.items, key)
- }
- }
-}
-
-
-
package cache
-
-import (
- "context"
- "time"
-
- "github.com/GoCodeAlone/modular"
-)
-
-// ModuleName is the name of this module
-const ModuleName = "cache"
-
-// ServiceName is the name of the service provided by this module
-const ServiceName = "cache.provider"
-
-// CacheModule represents the cache module
-type CacheModule struct {
- name string
- config *CacheConfig
- logger modular.Logger
- cacheEngine CacheEngine
-}
-
-// NewModule creates a new instance of the cache module
-func NewModule() modular.Module {
- return &CacheModule{
- name: ModuleName,
- }
-}
-
-// Name returns the name of the module
-func (m *CacheModule) Name() string {
- return m.name
-}
-
-// RegisterConfig registers the module's configuration structure
-func (m *CacheModule) RegisterConfig(app modular.Application) error {
- // Register the configuration with default values
- defaultConfig := &CacheConfig{
- Engine: "memory",
- DefaultTTL: 300,
- CleanupInterval: 60,
- MaxItems: 10000,
- RedisURL: "",
- RedisPassword: "",
- RedisDB: 0,
- ConnectionMaxAge: 60,
- }
-
- app.RegisterConfigSection(m.Name(), modular.NewStdConfigProvider(defaultConfig))
- return nil
-}
-
-// Init initializes the module
-func (m *CacheModule) Init(app modular.Application) error {
- // Retrieve the registered config section for access
- cfg, err := app.GetConfigSection(m.name)
- if err != nil {
- return err
- }
-
- m.config = cfg.GetConfig().(*CacheConfig)
- m.logger = app.Logger()
-
- // Initialize the appropriate cache engine based on configuration
- switch m.config.Engine {
- case "memory":
- m.cacheEngine = NewMemoryCache(m.config)
- m.logger.Info("Initialized memory cache engine", "maxItems", m.config.MaxItems)
- case "redis":
- m.cacheEngine = NewRedisCache(m.config)
- m.logger.Info("Initialized Redis cache engine", "url", m.config.RedisURL)
- default:
- m.cacheEngine = NewMemoryCache(m.config)
- m.logger.Warn("Unknown cache engine specified, using memory cache", "specified", m.config.Engine)
- }
-
- m.logger.Info("Cache module initialized")
- return nil
-}
-
-// Start performs startup logic for the module
-func (m *CacheModule) Start(ctx context.Context) error {
- m.logger.Info("Starting cache module")
- err := m.cacheEngine.Connect(ctx)
- if err != nil {
- return err
- }
- return nil
-}
-
-// Stop performs shutdown logic for the module
-func (m *CacheModule) Stop(ctx context.Context) error {
- m.logger.Info("Stopping cache module")
- return m.cacheEngine.Close(ctx)
-}
-
-// Dependencies returns the names of modules this module depends on
-func (m *CacheModule) Dependencies() []string {
- return nil
-}
-
-// ProvidesServices declares services provided by this module
-func (m *CacheModule) ProvidesServices() []modular.ServiceProvider {
- return []modular.ServiceProvider{
- {
- Name: ServiceName,
- Description: "Cache service for storing and retrieving data",
- Instance: m,
- },
- }
-}
-
-// RequiresServices declares services required by this module
-func (m *CacheModule) RequiresServices() []modular.ServiceDependency {
- return nil
-}
-
-// Constructor provides a dependency injection constructor for the module
-func (m *CacheModule) Constructor() modular.ModuleConstructor {
- return func(app modular.Application, services map[string]any) (modular.Module, error) {
- return m, nil
- }
-}
-
-// Get retrieves a cached item by key
-func (m *CacheModule) Get(ctx context.Context, key string) (interface{}, bool) {
- return m.cacheEngine.Get(ctx, key)
-}
-
-// Set stores an item in the cache with an optional TTL
-func (m *CacheModule) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error {
- if ttl == 0 {
- ttl = time.Duration(m.config.DefaultTTL) * time.Second
- }
- return m.cacheEngine.Set(ctx, key, value, ttl)
-}
-
-// Delete removes an item from the cache
-func (m *CacheModule) Delete(ctx context.Context, key string) error {
- return m.cacheEngine.Delete(ctx, key)
-}
-
-// Flush removes all items from the cache
-func (m *CacheModule) Flush(ctx context.Context) error {
- return m.cacheEngine.Flush(ctx)
-}
-
-// GetMulti retrieves multiple items from the cache
-func (m *CacheModule) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error) {
- return m.cacheEngine.GetMulti(ctx, keys)
-}
-
-// SetMulti stores multiple items in the cache
-func (m *CacheModule) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error {
- if ttl == 0 {
- ttl = time.Duration(m.config.DefaultTTL) * time.Second
- }
- return m.cacheEngine.SetMulti(ctx, items, ttl)
-}
-
-// DeleteMulti removes multiple items from the cache
-func (m *CacheModule) DeleteMulti(ctx context.Context, keys []string) error {
- return m.cacheEngine.DeleteMulti(ctx, keys)
-}
-
-
-
package cache
-
-import (
- "context"
- "encoding/json"
- "time"
-
- "github.com/redis/go-redis/v9"
-)
-
-// RedisCache implements CacheEngine using Redis
-type RedisCache struct {
- config *CacheConfig
- client *redis.Client
-}
-
-// NewRedisCache creates a new Redis cache engine
-func NewRedisCache(config *CacheConfig) *RedisCache {
- return &RedisCache{
- config: config,
- }
-}
-
-// Connect establishes connection to Redis
-func (c *RedisCache) Connect(ctx context.Context) error {
- opts, err := redis.ParseURL(c.config.RedisURL)
- if err != nil {
- return err
- }
-
- if c.config.RedisPassword != "" {
- opts.Password = c.config.RedisPassword
- }
-
- opts.DB = c.config.RedisDB
- opts.ConnMaxLifetime = time.Duration(c.config.ConnectionMaxAge) * time.Second
-
- c.client = redis.NewClient(opts)
-
- // Test the connection
- return c.client.Ping(ctx).Err()
-}
-
-// Close closes the connection to Redis
-func (c *RedisCache) Close(ctx context.Context) error {
- if c.client != nil {
- return c.client.Close()
- }
- return nil
-}
-
-// Get retrieves an item from the Redis cache
-func (c *RedisCache) Get(ctx context.Context, key string) (interface{}, bool) {
- if c.client == nil {
- return nil, false
- }
-
- val, err := c.client.Get(ctx, key).Result()
- if err != nil {
- if err == redis.Nil {
- return nil, false
- }
- return nil, false
- }
-
- var result interface{}
- if err := json.Unmarshal([]byte(val), &result); err != nil {
- return nil, false
- }
-
- return result, true
-}
-
-// Set stores an item in the Redis cache with a TTL
-func (c *RedisCache) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error {
- if c.client == nil {
- return ErrNotConnected
- }
-
- data, err := json.Marshal(value)
- if err != nil {
- return ErrInvalidValue
- }
-
- return c.client.Set(ctx, key, data, ttl).Err()
-}
-
-// Delete removes an item from the Redis cache
-func (c *RedisCache) Delete(ctx context.Context, key string) error {
- if c.client == nil {
- return ErrNotConnected
- }
-
- return c.client.Del(ctx, key).Err()
-}
-
-// Flush removes all items from the Redis cache
-func (c *RedisCache) Flush(ctx context.Context) error {
- if c.client == nil {
- return ErrNotConnected
- }
-
- return c.client.FlushDB(ctx).Err()
-}
-
-// GetMulti retrieves multiple items from the Redis cache
-func (c *RedisCache) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error) {
- if len(keys) == 0 {
- return make(map[string]interface{}), nil
- }
-
- if c.client == nil {
- return nil, ErrNotConnected
- }
-
- vals, err := c.client.MGet(ctx, keys...).Result()
- if err != nil {
- return nil, err
- }
-
- result := make(map[string]interface{}, len(keys))
- for i, val := range vals {
- if val != nil {
- var value interface{}
- if str, ok := val.(string); ok {
- if err := json.Unmarshal([]byte(str), &value); err == nil {
- result[keys[i]] = value
- }
- }
- }
- }
-
- return result, nil
-}
-
-// SetMulti stores multiple items in the Redis cache with a TTL
-func (c *RedisCache) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error {
- if len(items) == 0 {
- return nil
- }
-
- if c.client == nil {
- return ErrNotConnected
- }
-
- pipe := c.client.Pipeline()
- for key, value := range items {
- data, err := json.Marshal(value)
- if err != nil {
- return ErrInvalidValue
- }
- pipe.Set(ctx, key, data, ttl)
- }
-
- _, err := pipe.Exec(ctx)
- return err
-}
-
-// DeleteMulti removes multiple items from the Redis cache
-func (c *RedisCache) DeleteMulti(ctx context.Context, keys []string) error {
- if len(keys) == 0 {
- return nil
- }
-
- if c.client == nil {
- return ErrNotConnected
- }
-
- return c.client.Del(ctx, keys...).Err()
-}
-
-
-