Remove external library dependency, use homebrewed cache instead.

cache/cache.go

@@ -0,0 +1,87 @@
+package libpack_cache
+
+import (
+	"sync"
+	"time"
+)
+
+type CacheEntry struct {
+	Value     []byte
+	ExpiresAt time.Time
+}
+
+type Cache struct {
+	sync.Mutex
+	entries   map[string]CacheEntry
+	globalTTL time.Duration
+	ticker    *time.Ticker
+}
+
+func New(globalTTL time.Duration) *Cache {
+	cache := &Cache{
+		entries:   make(map[string]CacheEntry),
+		globalTTL: globalTTL,
+		ticker:    time.NewTicker(globalTTL / 2),
+	}
+
+	// Start the cache.
+	cache.Start()
+	return cache
+}
+
+func (c *Cache) Start() {
+	go func() {
+		for {
+			<-c.ticker.C
+			c.CleanExpiredEntries()
+		}
+	}()
+}
+
+func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
+	c.Lock()
+	defer c.Unlock()
+
+	now := time.Now()
+	expiresAt := now.Add(ttl)
+	if expiresAt.After(now.Add(c.globalTTL)) {
+		expiresAt = now.Add(c.globalTTL)
+	}
+
+	c.entries[key] = CacheEntry{
+		Value:     value,
+		ExpiresAt: expiresAt,
+	}
+}
+
+func (c *Cache) Get(key string) ([]byte, bool) {
+	c.Lock()
+	defer c.Unlock()
+
+	entry, ok := c.entries[key]
+	if !ok || entry.ExpiresAt.Before(time.Now()) {
+		return nil, false
+	}
+
+	return entry.Value, true
+}
+
+func (c *Cache) Delete(key string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.entries, key)
+}
+
+func (c *Cache) CleanExpiredEntries() {
+	now := time.Now()
+
+	c.Lock()
+	defer c.Unlock()
+
+	for key, entry := range c.entries {
+		if entry.ExpiresAt.Before(now) {
+			delete(c.entries, key)
+		}
+	}
+}