mirror of https://github.com/usememos/memos
refactor: store cache
Steven
5 months ago
parent
c23aebd648
commit
ad2c5f0d05
@ -0,0 +1,121 @@
|
|||||||
|
package profiler
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
"log/slog"
|
||||||
|
"net/http"
|
||||||
|
"net/http/pprof"
|
||||||
|
"runtime"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/labstack/echo/v4"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Profiler provides HTTP endpoints for memory profiling
|
||||||
|
type Profiler struct {
|
||||||
|
memStatsLogInterval time.Duration
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewProfiler creates a new profiler
|
||||||
|
func NewProfiler() *Profiler {
|
||||||
|
return &Profiler{
|
||||||
|
memStatsLogInterval: 1 * time.Minute,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// RegisterRoutes adds profiling endpoints to the Echo server
|
||||||
|
func (p *Profiler) RegisterRoutes(e *echo.Echo) {
|
||||||
|
// Register pprof handlers
|
||||||
|
g := e.Group("/debug/pprof")
|
||||||
|
g.GET("", echo.WrapHandler(http.HandlerFunc(pprof.Index)))
|
||||||
|
g.GET("/cmdline", echo.WrapHandler(http.HandlerFunc(pprof.Cmdline)))
|
||||||
|
g.GET("/profile", echo.WrapHandler(http.HandlerFunc(pprof.Profile)))
|
||||||
|
g.POST("/symbol", echo.WrapHandler(http.HandlerFunc(pprof.Symbol)))
|
||||||
|
g.GET("/symbol", echo.WrapHandler(http.HandlerFunc(pprof.Symbol)))
|
||||||
|
g.GET("/trace", echo.WrapHandler(http.HandlerFunc(pprof.Trace)))
|
||||||
|
g.GET("/allocs", echo.WrapHandler(http.HandlerFunc(pprof.Handler("allocs").ServeHTTP)))
|
||||||
|
g.GET("/block", echo.WrapHandler(http.HandlerFunc(pprof.Handler("block").ServeHTTP)))
|
||||||
|
g.GET("/goroutine", echo.WrapHandler(http.HandlerFunc(pprof.Handler("goroutine").ServeHTTP)))
|
||||||
|
g.GET("/heap", echo.WrapHandler(http.HandlerFunc(pprof.Handler("heap").ServeHTTP)))
|
||||||
|
g.GET("/mutex", echo.WrapHandler(http.HandlerFunc(pprof.Handler("mutex").ServeHTTP)))
|
||||||
|
g.GET("/threadcreate", echo.WrapHandler(http.HandlerFunc(pprof.Handler("threadcreate").ServeHTTP)))
|
||||||
|
|
||||||
|
// Add a custom memory stats endpoint
|
||||||
|
g.GET("/memstats", func(c echo.Context) error {
|
||||||
|
var m runtime.MemStats
|
||||||
|
runtime.ReadMemStats(&m)
|
||||||
|
return c.JSON(http.StatusOK, map[string]interface{}{
|
||||||
|
"alloc": m.Alloc,
|
||||||
|
"totalAlloc": m.TotalAlloc,
|
||||||
|
"sys": m.Sys,
|
||||||
|
"numGC": m.NumGC,
|
||||||
|
"heapAlloc": m.HeapAlloc,
|
||||||
|
"heapSys": m.HeapSys,
|
||||||
|
"heapInuse": m.HeapInuse,
|
||||||
|
"heapObjects": m.HeapObjects,
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// StartMemoryMonitor starts a goroutine that periodically logs memory stats
|
||||||
|
func (p *Profiler) StartMemoryMonitor(ctx context.Context) {
|
||||||
|
go func() {
|
||||||
|
ticker := time.NewTicker(p.memStatsLogInterval)
|
||||||
|
defer ticker.Stop()
|
||||||
|
|
||||||
|
// Store previous heap allocation to track growth
|
||||||
|
var lastHeapAlloc uint64
|
||||||
|
var lastNumGC uint32
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-ticker.C:
|
||||||
|
var m runtime.MemStats
|
||||||
|
runtime.ReadMemStats(&m)
|
||||||
|
|
||||||
|
// Calculate heap growth since last check
|
||||||
|
heapGrowth := int64(m.HeapAlloc) - int64(lastHeapAlloc)
|
||||||
|
gcCount := m.NumGC - lastNumGC
|
||||||
|
|
||||||
|
slog.Info("memory stats",
|
||||||
|
"heapAlloc", byteCountIEC(m.HeapAlloc),
|
||||||
|
"heapSys", byteCountIEC(m.HeapSys),
|
||||||
|
"heapObjects", m.HeapObjects,
|
||||||
|
"heapGrowth", byteCountIEC(uint64(heapGrowth)),
|
||||||
|
"numGoroutine", runtime.NumGoroutine(),
|
||||||
|
"numGC", m.NumGC,
|
||||||
|
"gcSince", gcCount,
|
||||||
|
"nextGC", byteCountIEC(m.NextGC),
|
||||||
|
"gcPause", time.Duration(m.PauseNs[(m.NumGC+255)%256]).String(),
|
||||||
|
)
|
||||||
|
|
||||||
|
// Track values for next iteration
|
||||||
|
lastHeapAlloc = m.HeapAlloc
|
||||||
|
lastNumGC = m.NumGC
|
||||||
|
|
||||||
|
// Force GC if memory usage is high to see if objects can be reclaimed
|
||||||
|
if m.HeapAlloc > 500*1024*1024 { // 500 MB threshold
|
||||||
|
slog.Info("forcing garbage collection due to high memory usage")
|
||||||
|
runtime.GC()
|
||||||
|
}
|
||||||
|
case <-ctx.Done():
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
}
|
||||||
|
|
||||||
|
// byteCountIEC converts bytes to a human-readable string (MiB, GiB)
|
||||||
|
func byteCountIEC(b uint64) string {
|
||||||
|
const unit = 1024
|
||||||
|
if b < unit {
|
||||||
|
return fmt.Sprintf("%d B", b)
|
||||||
|
}
|
||||||
|
div, exp := uint64(unit), 0
|
||||||
|
for n := b / unit; n >= unit; n /= unit {
|
||||||
|
div *= unit
|
||||||
|
exp++
|
||||||
|
}
|
||||||
|
return fmt.Sprintf("%.1f %ciB", float64(b)/float64(div), "KMGTPE"[exp])
|
||||||
|
}
|
||||||
@ -0,0 +1,311 @@
|
|||||||
|
package cache
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"sync"
|
||||||
|
"sync/atomic"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Interface defines the operations a cache must support
|
||||||
|
type Interface interface {
|
||||||
|
// Set adds a value to the cache with the default TTL
|
||||||
|
Set(ctx context.Context, key string, value interface{})
|
||||||
|
|
||||||
|
// SetWithTTL adds a value to the cache with a custom TTL
|
||||||
|
SetWithTTL(ctx context.Context, key string, value interface{}, ttl time.Duration)
|
||||||
|
|
||||||
|
// Get retrieves a value from the cache
|
||||||
|
Get(ctx context.Context, key string) (interface{}, bool)
|
||||||
|
|
||||||
|
// Delete removes a value from the cache
|
||||||
|
Delete(ctx context.Context, key string)
|
||||||
|
|
||||||
|
// Clear removes all values from the cache
|
||||||
|
Clear(ctx context.Context)
|
||||||
|
|
||||||
|
// Size returns the number of items in the cache
|
||||||
|
Size() int64
|
||||||
|
|
||||||
|
// Close stops all background tasks and releases resources
|
||||||
|
Close() error
|
||||||
|
}
|
||||||
|
|
||||||
|
// item represents a cached value with metadata
|
||||||
|
type item struct {
|
||||||
|
value interface{}
|
||||||
|
expiration time.Time
|
||||||
|
size int // Approximate size in bytes
|
||||||
|
}
|
||||||
|
|
||||||
|
// Config contains options for configuring a cache
|
||||||
|
type Config struct {
|
||||||
|
// DefaultTTL is the default time-to-live for cache entries
|
||||||
|
DefaultTTL time.Duration
|
||||||
|
|
||||||
|
// CleanupInterval is how often the cache runs cleanup
|
||||||
|
CleanupInterval time.Duration
|
||||||
|
|
||||||
|
// MaxItems is the maximum number of items allowed in the cache
|
||||||
|
MaxItems int
|
||||||
|
|
||||||
|
// OnEviction is called when an item is evicted from the cache
|
||||||
|
OnEviction func(key string, value interface{})
|
||||||
|
}
|
||||||
|
|
||||||
|
// DefaultConfig returns a default configuration for the cache
|
||||||
|
func DefaultConfig() Config {
|
||||||
|
return Config{
|
||||||
|
DefaultTTL: 10 * time.Minute,
|
||||||
|
CleanupInterval: 5 * time.Minute,
|
||||||
|
MaxItems: 1000,
|
||||||
|
OnEviction: nil,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Cache is a thread-safe in-memory cache with TTL and memory management
|
||||||
|
type Cache struct {
|
||||||
|
data sync.Map
|
||||||
|
config Config
|
||||||
|
itemCount int64 // Use atomic operations to track item count
|
||||||
|
stopChan chan struct{}
|
||||||
|
closedChan chan struct{}
|
||||||
|
}
|
||||||
|
|
||||||
|
// New creates a new memory cache with the given configuration
|
||||||
|
func New(config Config) *Cache {
|
||||||
|
c := &Cache{
|
||||||
|
config: config,
|
||||||
|
stopChan: make(chan struct{}),
|
||||||
|
closedChan: make(chan struct{}),
|
||||||
|
}
|
||||||
|
|
||||||
|
go c.cleanupLoop()
|
||||||
|
return c
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewDefault creates a new memory cache with default configuration
|
||||||
|
func NewDefault() *Cache {
|
||||||
|
return New(DefaultConfig())
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set adds a value to the cache with the default TTL
|
||||||
|
func (c *Cache) Set(ctx context.Context, key string, value interface{}) {
|
||||||
|
c.SetWithTTL(ctx, key, value, c.config.DefaultTTL)
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetWithTTL adds a value to the cache with a custom TTL
|
||||||
|
func (c *Cache) SetWithTTL(ctx context.Context, key string, value interface{}, ttl time.Duration) {
|
||||||
|
// Estimate size of the item (very rough approximation)
|
||||||
|
size := estimateSize(value)
|
||||||
|
|
||||||
|
// Check if item already exists to avoid double counting
|
||||||
|
if _, exists := c.data.Load(key); exists {
|
||||||
|
c.data.Delete(key)
|
||||||
|
// Don't decrement count - we'll replace it
|
||||||
|
} else {
|
||||||
|
// Only increment if this is a new key
|
||||||
|
atomic.AddInt64(&c.itemCount, 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
c.data.Store(key, item{
|
||||||
|
value: value,
|
||||||
|
expiration: time.Now().Add(ttl),
|
||||||
|
size: size,
|
||||||
|
})
|
||||||
|
|
||||||
|
// If we're over the max items, clean up old items
|
||||||
|
if c.config.MaxItems > 0 && atomic.LoadInt64(&c.itemCount) > int64(c.config.MaxItems) {
|
||||||
|
c.cleanupOldest()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get retrieves a value from the cache
|
||||||
|
func (c *Cache) Get(ctx context.Context, key string) (interface{}, bool) {
|
||||||
|
value, ok := c.data.Load(key)
|
||||||
|
if !ok {
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
|
||||||
|
itm := value.(item)
|
||||||
|
if time.Now().After(itm.expiration) {
|
||||||
|
c.data.Delete(key)
|
||||||
|
atomic.AddInt64(&c.itemCount, -1)
|
||||||
|
|
||||||
|
if c.config.OnEviction != nil {
|
||||||
|
c.config.OnEviction(key, itm.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
|
||||||
|
return itm.value, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// Delete removes a value from the cache
|
||||||
|
func (c *Cache) Delete(ctx context.Context, key string) {
|
||||||
|
if value, loaded := c.data.LoadAndDelete(key); loaded {
|
||||||
|
atomic.AddInt64(&c.itemCount, -1)
|
||||||
|
|
||||||
|
if c.config.OnEviction != nil {
|
||||||
|
itm := value.(item)
|
||||||
|
c.config.OnEviction(key, itm.value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Clear removes all values from the cache
|
||||||
|
func (c *Cache) Clear(ctx context.Context) {
|
||||||
|
if c.config.OnEviction != nil {
|
||||||
|
c.data.Range(func(key, value interface{}) bool {
|
||||||
|
itm := value.(item)
|
||||||
|
c.config.OnEviction(key.(string), itm.value)
|
||||||
|
return true
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
c.data = sync.Map{}
|
||||||
|
atomic.StoreInt64(&c.itemCount, 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Size returns the number of items in the cache
|
||||||
|
func (c *Cache) Size() int64 {
|
||||||
|
return atomic.LoadInt64(&c.itemCount)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close stops the cache cleanup goroutine
|
||||||
|
func (c *Cache) Close() error {
|
||||||
|
select {
|
||||||
|
case <-c.stopChan:
|
||||||
|
// Already closed
|
||||||
|
return nil
|
||||||
|
default:
|
||||||
|
close(c.stopChan)
|
||||||
|
<-c.closedChan // Wait for cleanup goroutine to exit
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// cleanupLoop periodically cleans up expired items
|
||||||
|
func (c *Cache) cleanupLoop() {
|
||||||
|
ticker := time.NewTicker(c.config.CleanupInterval)
|
||||||
|
defer func() {
|
||||||
|
ticker.Stop()
|
||||||
|
close(c.closedChan)
|
||||||
|
}()
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-ticker.C:
|
||||||
|
c.cleanup()
|
||||||
|
case <-c.stopChan:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// cleanup removes expired items
|
||||||
|
func (c *Cache) cleanup() {
|
||||||
|
evicted := make(map[string]interface{})
|
||||||
|
count := 0
|
||||||
|
|
||||||
|
c.data.Range(func(key, value interface{}) bool {
|
||||||
|
itm := value.(item)
|
||||||
|
if time.Now().After(itm.expiration) {
|
||||||
|
c.data.Delete(key)
|
||||||
|
count++
|
||||||
|
|
||||||
|
if c.config.OnEviction != nil {
|
||||||
|
evicted[key.(string)] = itm.value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
})
|
||||||
|
|
||||||
|
if count > 0 {
|
||||||
|
atomic.AddInt64(&c.itemCount, -int64(count))
|
||||||
|
|
||||||
|
// Call eviction callbacks outside the loop to avoid blocking the range
|
||||||
|
if c.config.OnEviction != nil {
|
||||||
|
for k, v := range evicted {
|
||||||
|
c.config.OnEviction(k, v)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// cleanupOldest removes the oldest items if we're over the max items
|
||||||
|
func (c *Cache) cleanupOldest() {
|
||||||
|
threshold := c.config.MaxItems / 5 // Remove 20% of max items at once
|
||||||
|
if threshold < 1 {
|
||||||
|
threshold = 1
|
||||||
|
}
|
||||||
|
|
||||||
|
currentCount := atomic.LoadInt64(&c.itemCount)
|
||||||
|
|
||||||
|
// If we're not over the threshold, don't do anything
|
||||||
|
if currentCount <= int64(c.config.MaxItems) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find the oldest items
|
||||||
|
type keyExpPair struct {
|
||||||
|
key string
|
||||||
|
value interface{}
|
||||||
|
expiration time.Time
|
||||||
|
}
|
||||||
|
candidates := make([]keyExpPair, 0, threshold)
|
||||||
|
|
||||||
|
c.data.Range(func(key, value interface{}) bool {
|
||||||
|
itm := value.(item)
|
||||||
|
if len(candidates) < threshold {
|
||||||
|
candidates = append(candidates, keyExpPair{key.(string), itm.value, itm.expiration})
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find the newest item in candidates
|
||||||
|
newestIdx := 0
|
||||||
|
for i := 1; i < len(candidates); i++ {
|
||||||
|
if candidates[i].expiration.After(candidates[newestIdx].expiration) {
|
||||||
|
newestIdx = i
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Replace it if this item is older
|
||||||
|
if itm.expiration.Before(candidates[newestIdx].expiration) {
|
||||||
|
candidates[newestIdx] = keyExpPair{key.(string), itm.value, itm.expiration}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true
|
||||||
|
})
|
||||||
|
|
||||||
|
// Delete the oldest items
|
||||||
|
deletedCount := 0
|
||||||
|
for _, candidate := range candidates {
|
||||||
|
c.data.Delete(candidate.key)
|
||||||
|
deletedCount++
|
||||||
|
|
||||||
|
if c.config.OnEviction != nil {
|
||||||
|
c.config.OnEviction(candidate.key, candidate.value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update count
|
||||||
|
if deletedCount > 0 {
|
||||||
|
atomic.AddInt64(&c.itemCount, -int64(deletedCount))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// estimateSize attempts to estimate the memory footprint of a value
|
||||||
|
func estimateSize(value interface{}) int {
|
||||||
|
switch v := value.(type) {
|
||||||
|
case string:
|
||||||
|
return len(v) + 24 // base size + string overhead
|
||||||
|
case []byte:
|
||||||
|
return len(v) + 24 // base size + slice overhead
|
||||||
|
case map[string]interface{}:
|
||||||
|
return len(v) * 64 // rough estimate
|
||||||
|
default:
|
||||||
|
return 64 // default conservative estimate
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,209 @@
|
|||||||
|
package cache
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
"sync"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestCacheBasicOperations(t *testing.T) {
|
||||||
|
ctx := context.Background()
|
||||||
|
config := DefaultConfig()
|
||||||
|
config.DefaultTTL = 100 * time.Millisecond
|
||||||
|
config.CleanupInterval = 50 * time.Millisecond
|
||||||
|
cache := New(config)
|
||||||
|
defer cache.Close()
|
||||||
|
|
||||||
|
// Test Set and Get
|
||||||
|
cache.Set(ctx, "key1", "value1")
|
||||||
|
if val, ok := cache.Get(ctx, "key1"); !ok || val != "value1" {
|
||||||
|
t.Errorf("Expected 'value1', got %v, exists: %v", val, ok)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test SetWithTTL
|
||||||
|
cache.SetWithTTL(ctx, "key2", "value2", 200*time.Millisecond)
|
||||||
|
if val, ok := cache.Get(ctx, "key2"); !ok || val != "value2" {
|
||||||
|
t.Errorf("Expected 'value2', got %v, exists: %v", val, ok)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test Delete
|
||||||
|
cache.Delete(ctx, "key1")
|
||||||
|
if _, ok := cache.Get(ctx, "key1"); ok {
|
||||||
|
t.Errorf("Key 'key1' should have been deleted")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test automatic expiration
|
||||||
|
time.Sleep(150 * time.Millisecond)
|
||||||
|
if _, ok := cache.Get(ctx, "key1"); ok {
|
||||||
|
t.Errorf("Key 'key1' should have expired")
|
||||||
|
}
|
||||||
|
// key2 should still be valid (200ms TTL)
|
||||||
|
if _, ok := cache.Get(ctx, "key2"); !ok {
|
||||||
|
t.Errorf("Key 'key2' should still be valid")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Wait for key2 to expire
|
||||||
|
time.Sleep(100 * time.Millisecond)
|
||||||
|
if _, ok := cache.Get(ctx, "key2"); ok {
|
||||||
|
t.Errorf("Key 'key2' should have expired")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test Clear
|
||||||
|
cache.Set(ctx, "key3", "value3")
|
||||||
|
cache.Clear(ctx)
|
||||||
|
if _, ok := cache.Get(ctx, "key3"); ok {
|
||||||
|
t.Errorf("Cache should be empty after Clear()")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestCacheEviction(t *testing.T) {
|
||||||
|
ctx := context.Background()
|
||||||
|
config := DefaultConfig()
|
||||||
|
config.MaxItems = 5
|
||||||
|
cache := New(config)
|
||||||
|
defer cache.Close()
|
||||||
|
|
||||||
|
// Add 5 items (max capacity)
|
||||||
|
for i := 0; i < 5; i++ {
|
||||||
|
key := fmt.Sprintf("key%d", i)
|
||||||
|
cache.Set(ctx, key, i)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verify all 5 items are in the cache
|
||||||
|
for i := 0; i < 5; i++ {
|
||||||
|
key := fmt.Sprintf("key%d", i)
|
||||||
|
if _, ok := cache.Get(ctx, key); !ok {
|
||||||
|
t.Errorf("Key '%s' should be in the cache", key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add 2 more items to trigger eviction
|
||||||
|
cache.Set(ctx, "keyA", "valueA")
|
||||||
|
cache.Set(ctx, "keyB", "valueB")
|
||||||
|
|
||||||
|
// Verify size is still within limits
|
||||||
|
if cache.Size() > int64(config.MaxItems) {
|
||||||
|
t.Errorf("Cache size %d exceeds limit %d", cache.Size(), config.MaxItems)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Some of the original keys should have been evicted
|
||||||
|
evictedCount := 0
|
||||||
|
for i := 0; i < 5; i++ {
|
||||||
|
key := fmt.Sprintf("key%d", i)
|
||||||
|
if _, ok := cache.Get(ctx, key); !ok {
|
||||||
|
evictedCount++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if evictedCount == 0 {
|
||||||
|
t.Errorf("No keys were evicted despite exceeding max items")
|
||||||
|
}
|
||||||
|
|
||||||
|
// The newer keys should still be present
|
||||||
|
if _, ok := cache.Get(ctx, "keyA"); !ok {
|
||||||
|
t.Errorf("Key 'keyA' should be in the cache")
|
||||||
|
}
|
||||||
|
if _, ok := cache.Get(ctx, "keyB"); !ok {
|
||||||
|
t.Errorf("Key 'keyB' should be in the cache")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestCacheConcurrency(t *testing.T) {
|
||||||
|
ctx := context.Background()
|
||||||
|
cache := NewDefault()
|
||||||
|
defer cache.Close()
|
||||||
|
|
||||||
|
const goroutines = 10
|
||||||
|
const operationsPerGoroutine = 100
|
||||||
|
|
||||||
|
var wg sync.WaitGroup
|
||||||
|
wg.Add(goroutines)
|
||||||
|
|
||||||
|
for i := 0; i < goroutines; i++ {
|
||||||
|
go func(id int) {
|
||||||
|
defer wg.Done()
|
||||||
|
|
||||||
|
baseKey := fmt.Sprintf("worker%d-", id)
|
||||||
|
|
||||||
|
// Set operations
|
||||||
|
for j := 0; j < operationsPerGoroutine; j++ {
|
||||||
|
key := fmt.Sprintf("%skey%d", baseKey, j)
|
||||||
|
value := fmt.Sprintf("value%d-%d", id, j)
|
||||||
|
cache.Set(ctx, key, value)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get operations
|
||||||
|
for j := 0; j < operationsPerGoroutine; j++ {
|
||||||
|
key := fmt.Sprintf("%skey%d", baseKey, j)
|
||||||
|
val, ok := cache.Get(ctx, key)
|
||||||
|
if !ok {
|
||||||
|
t.Errorf("Key '%s' should exist in cache", key)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
expected := fmt.Sprintf("value%d-%d", id, j)
|
||||||
|
if val != expected {
|
||||||
|
t.Errorf("For key '%s', expected '%s', got '%s'", key, expected, val)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Delete half the keys
|
||||||
|
for j := 0; j < operationsPerGoroutine/2; j++ {
|
||||||
|
key := fmt.Sprintf("%skey%d", baseKey, j)
|
||||||
|
cache.Delete(ctx, key)
|
||||||
|
}
|
||||||
|
}(i)
|
||||||
|
}
|
||||||
|
|
||||||
|
wg.Wait()
|
||||||
|
|
||||||
|
// Verify size and deletion
|
||||||
|
var totalKeysExpected int64 = goroutines * operationsPerGoroutine / 2
|
||||||
|
if cache.Size() != totalKeysExpected {
|
||||||
|
t.Errorf("Expected cache size to be %d, got %d", totalKeysExpected, cache.Size())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestEvictionCallback(t *testing.T) {
|
||||||
|
ctx := context.Background()
|
||||||
|
evicted := make(map[string]interface{})
|
||||||
|
evictedMu := sync.Mutex{}
|
||||||
|
|
||||||
|
config := DefaultConfig()
|
||||||
|
config.DefaultTTL = 50 * time.Millisecond
|
||||||
|
config.CleanupInterval = 25 * time.Millisecond
|
||||||
|
config.OnEviction = func(key string, value interface{}) {
|
||||||
|
evictedMu.Lock()
|
||||||
|
evicted[key] = value
|
||||||
|
evictedMu.Unlock()
|
||||||
|
}
|
||||||
|
|
||||||
|
cache := New(config)
|
||||||
|
defer cache.Close()
|
||||||
|
|
||||||
|
// Add items
|
||||||
|
cache.Set(ctx, "key1", "value1")
|
||||||
|
cache.Set(ctx, "key2", "value2")
|
||||||
|
|
||||||
|
// Manually delete
|
||||||
|
cache.Delete(ctx, "key1")
|
||||||
|
|
||||||
|
// Verify manual deletion triggered callback
|
||||||
|
time.Sleep(10 * time.Millisecond) // Small delay to ensure callback processed
|
||||||
|
evictedMu.Lock()
|
||||||
|
if evicted["key1"] != "value1" {
|
||||||
|
t.Errorf("Eviction callback not triggered for manual deletion")
|
||||||
|
}
|
||||||
|
evictedMu.Unlock()
|
||||||
|
|
||||||
|
// Wait for automatic expiration
|
||||||
|
time.Sleep(60 * time.Millisecond)
|
||||||
|
|
||||||
|
// Verify TTL expiration triggered callback
|
||||||
|
evictedMu.Lock()
|
||||||
|
if evicted["key2"] != "value2" {
|
||||||
|
t.Errorf("Eviction callback not triggered for TTL expiration")
|
||||||
|
}
|
||||||
|
evictedMu.Unlock()
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue