update

Author: hhftechnology

go.mod

@@ -2,4 +2,3 @@ module github.com/hhftechnology/traefik-queue-manager
 
 go 1.19
 
-require github.com/patrickmn/go-cache v2.1.0+incompatible

go.sum

@@ -0,0 +1,145 @@
+// internal_cache.go
+package queuemanager
+
+import (
+	"sync"
+	"time"
+)
+
+// Item represents a cached item with expiration
+type CacheItem struct {
+	Object     interface{}
+	Expiration int64 // Unix nano time when this item expires
+}
+
+// SimpleCache provides a thread-safe in-memory key/value store with expiration
+type SimpleCache struct {
+	items             map[string]CacheItem
+	mu                sync.RWMutex
+	defaultExpiration time.Duration
+	cleanupInterval   time.Duration
+	stopCleanup       chan bool
+}
+
+// Constants for expiration
+const (
+	NoExpiration      time.Duration = -1
+	DefaultExpiration time.Duration = 0
+)
+
+// NewSimpleCache creates a new cache with the provided default expiration duration
+// and cleanup interval. If the cleanup interval is <= 0, expired items are not
+// automatically deleted from the cache.
+func NewSimpleCache(defaultExpiration, cleanupInterval time.Duration) *SimpleCache {
+	cache := &SimpleCache{
+		items:             make(map[string]CacheItem),
+		defaultExpiration: defaultExpiration,
+		cleanupInterval:   cleanupInterval,
+	}
+
+	// Start the cleanup goroutine if a cleanup interval is specified
+	if cleanupInterval > 0 {
+		cache.stopCleanup = make(chan bool)
+		go cache.startCleanupTimer()
+	}
+
+	return cache
+}
+
+// startCleanupTimer starts a timer that periodically cleans up expired items
+func (c *SimpleCache) startCleanupTimer() {
+	ticker := time.NewTicker(c.cleanupInterval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			c.DeleteExpired()
+		case <-c.stopCleanup:
+			return
+		}
+	}
+}
+
+// Set adds an item to the cache, replacing any existing item with the same key
+func (c *SimpleCache) Set(k string, x interface{}, d time.Duration) {
+	var exp int64
+
+	if d == DefaultExpiration {
+		d = c.defaultExpiration
+	}
+
+	if d > 0 {
+		exp = time.Now().Add(d).UnixNano()
+	}
+
+	c.mu.Lock()
+	c.items[k] = CacheItem{
+		Object:     x,
+		Expiration: exp,
+	}
+	c.mu.Unlock()
+}
+
+// Get retrieves an item from the cache and returns (item, found)
+func (c *SimpleCache) Get(k string) (interface{}, bool) {
+	c.mu.RLock()
+	item, found := c.items[k]
+	if !found {
+		c.mu.RUnlock()
+		return nil, false
+	}
+
+	// Check if the item has expired
+	if item.Expiration > 0 {
+		if time.Now().UnixNano() > item.Expiration {
+			c.mu.RUnlock()
+			return nil, false
+		}
+	}
+
+	c.mu.RUnlock()
+	return item.Object, true
+}
+
+// Delete removes an item from the cache
+func (c *SimpleCache) Delete(k string) {
+	c.mu.Lock()
+	delete(c.items, k)
+	c.mu.Unlock()
+}
+
+// DeleteExpired deletes all expired items from the cache
+func (c *SimpleCache) DeleteExpired() {
+	now := time.Now().UnixNano()
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	for k, v := range c.items {
+		// Delete if the item has expired
+		if v.Expiration > 0 && now > v.Expiration {
+			delete(c.items, k)
+		}
+	}
+}
+
+// Stop ends the cleanup timer if it's running
+func (c *SimpleCache) Stop() {
+	if c.cleanupInterval > 0 {
+		c.stopCleanup <- true
+	}
+}
+
+// ItemCount returns the number of items in the cache (including expired items)
+func (c *SimpleCache) ItemCount() int {
+	c.mu.RLock()
+	n := len(c.items)
+	c.mu.RUnlock()
+	return n
+}
+
+// Flush deletes all items from the cache
+func (c *SimpleCache) Flush() {
+	c.mu.Lock()
+	c.items = make(map[string]CacheItem)
+	c.mu.Unlock()
+}

internal_cache.go

@@ -18,8 +18,6 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/patrickmn/go-cache"
 )
 
 // Config holds the plugin configuration.
@@ -81,7 +79,7 @@ type QueueManager struct {
 	next             http.Handler
 	name             string
 	config           *Config
-	cache            *cache.Cache
+	cache            *SimpleCache
 	template         *template.Template
 	queue            []Session
 	activeSessionIDs map[string]bool
@@ -114,7 +112,7 @@ func New(ctx context.Context, next http.Handler, config *Config, name string) (h
 		next:             next,
 		name:             name,
 		config:           config,
-		cache:            cache.New(config.SessionTime, config.PurgeTime),
+		cache:            NewSimpleCache(config.SessionTime, config.PurgeTime),
 		template:         tmpl,
 		queue:            make([]Session, 0),
 		activeSessionIDs: make(map[string]bool),
@@ -169,7 +167,7 @@ func (qm *QueueManager) canClientProceed(clientID string) bool {
 		}
 
 		qm.activeSessionIDs[clientID] = true
-		qm.cache.Set(clientID, session, cache.DefaultExpiration)
+		qm.cache.Set(clientID, session, DefaultExpiration)
 		return true
 	}
 
@@ -179,8 +177,8 @@ func (qm *QueueManager) canClientProceed(clientID string) bool {
 
 // updateClientTimestamp updates the last seen timestamp for a client.
 func (qm *QueueManager) updateClientTimestamp(clientID string) {
-	if session, found := qm.cache.Get(clientID); found {
-		sessionData, ok := session.(Session)
+	if sessionObj, found := qm.cache.Get(clientID); found {
+		sessionData, ok := sessionObj.(Session)
 		if !ok {
 			if qm.config.Debug {
 				log.Printf("[Queue Manager] Error: Failed to convert session to Session type")
@@ -189,7 +187,7 @@ func (qm *QueueManager) updateClientTimestamp(clientID string) {
 		}
 
 		sessionData.LastSeen = time.Now()
-		qm.cache.Set(clientID, sessionData, cache.DefaultExpiration)
+		qm.cache.Set(clientID, sessionData, DefaultExpiration)
 	}
 }
 
@@ -213,7 +211,7 @@ func (qm *QueueManager) placeClientInQueue(clientID string) int {
 			Position:  len(qm.queue),
 		}
 		qm.queue = append(qm.queue, session)
-		qm.cache.Set(clientID, session, cache.DefaultExpiration)
+		qm.cache.Set(clientID, session, DefaultExpiration)
 		position = len(qm.queue) - 1
 	}
 
@@ -483,11 +481,11 @@ func (qm *QueueManager) CleanupExpiredSessions() {
 
 	// Update positions in queue
 	for i := range qm.queue {
-		if session, found := qm.cache.Get(qm.queue[i].ID); found {
-			sessionData, ok := session.(Session)
+		if sessionObj, found := qm.cache.Get(qm.queue[i].ID); found {
+			sessionData, ok := sessionObj.(Session)
 			if ok {
 				sessionData.Position = i
-				qm.cache.Set(qm.queue[i].ID, sessionData, cache.DefaultExpiration)
+				qm.cache.Set(qm.queue[i].ID, sessionData, DefaultExpiration)
 			}
 		}
 	}

queue-manager.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"os"
 	"testing"
+	"time"
 )
 
 func TestGenerateUniqueID(t *testing.T) {
@@ -155,4 +156,49 @@ func TestFileExists(t *testing.T) {
 	if fileExists("nonexistent_file.txt") {
 		t.Errorf("fileExists should return false for a non-existent file")
 	}
+}
+
+// Add tests for the SimpleCache
+func TestSimpleCache(t *testing.T) {
+	// Create a new cache with default expiration of 1 second
+	cache := NewSimpleCache(time.Second, time.Second*2)
+	
+	// Test Set and Get
+	cache.Set("key1", "value1", DefaultExpiration)
+	val, found := cache.Get("key1")
+	if !found {
+		t.Errorf("Expected to find key1 in cache")
+	}
+	if val != "value1" {
+		t.Errorf("Expected value1, got %v", val)
+	}
+	
+	// Test with non-existant key
+	_, found = cache.Get("nonexistent")
+	if found {
+		t.Errorf("Should not find nonexistent key")
+	}
+	
+	// Test expiration
+	cache.Set("key2", "value2", 500*time.Millisecond)
+	time.Sleep(800 * time.Millisecond)
+	_, found = cache.Get("key2")
+	if found {
+		t.Errorf("key2 should have expired")
+	}
+	
+	// Test Delete
+	cache.Set("key3", "value3", NoExpiration)
+	cache.Delete("key3")
+	_, found = cache.Get("key3")
+	if found {
+		t.Errorf("key3 should have been deleted")
+	}
+	
+	// Test Flush
+	cache.Set("key4", "value4", NoExpiration)
+	cache.Flush()
+	if cache.ItemCount() != 0 {
+		t.Errorf("Cache should be empty after Flush")
+	}
 }