161 lines
3.4 KiB
Go
161 lines
3.4 KiB
Go
package backend
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"image"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type CacheItem struct {
|
|
val image.Image
|
|
ttl time.Duration
|
|
|
|
// unix time
|
|
expiresAt int64
|
|
lastAccessed int64
|
|
}
|
|
|
|
// A custom cache for images with the following eviction strategy:
|
|
// 1. If there are fewer than MinSize items in the cache, none will be evicted
|
|
// 2. If a new addition would make the cache exceed MaxSize, an item will be immediately evicted
|
|
// 2a. in this case, evict the LRU expired item or if none expired, the LRU item
|
|
// 3. If the size of the cache is between MaxSize and MinSize, expired items will be periodically evicted
|
|
// 3a. in this case, again the least recently used expired items will be evicted first
|
|
type ImageCache struct {
|
|
MinSize int
|
|
MaxSize int
|
|
DefaultTTL time.Duration
|
|
|
|
mu sync.RWMutex
|
|
cache map[string]CacheItem
|
|
}
|
|
|
|
var (
|
|
ErrNotFound = errors.New("item not found")
|
|
)
|
|
|
|
func (i *ImageCache) Init(ctx context.Context) {
|
|
i.cache = make(map[string]CacheItem)
|
|
}
|
|
|
|
// holds writer lock for O(i.MaxSize) worst case
|
|
func (i *ImageCache) AddWithTTL(key string, val image.Image, ttl time.Duration) {
|
|
i.mu.Lock()
|
|
defer i.mu.Unlock()
|
|
|
|
if v, ok := i.cache[key]; ok {
|
|
v.val = val
|
|
v.ttl = ttl
|
|
v.expiresAt = time.Now().Add(v.ttl).Unix()
|
|
v.lastAccessed = time.Now().Unix()
|
|
return
|
|
}
|
|
if len(i.cache) == i.MaxSize {
|
|
i.evictOne()
|
|
i.cache[key] = CacheItem{
|
|
val: val,
|
|
ttl: ttl,
|
|
expiresAt: time.Now().Add(ttl).Unix(),
|
|
lastAccessed: time.Now().Unix(),
|
|
}
|
|
}
|
|
}
|
|
|
|
func (i *ImageCache) Add(key string, val image.Image) {
|
|
i.AddWithTTL(key, val, i.DefaultTTL)
|
|
}
|
|
|
|
func (i *ImageCache) Has(key string) bool {
|
|
i.mu.RLock()
|
|
defer i.mu.RUnlock()
|
|
|
|
_, ok := i.cache[key]
|
|
return ok
|
|
}
|
|
|
|
func (i *ImageCache) Get(key string, resetTTL bool) (image.Image, error) {
|
|
i.mu.RLock()
|
|
defer i.mu.RUnlock()
|
|
|
|
if v, ok := i.cache[key]; ok {
|
|
v.lastAccessed = time.Now().Unix()
|
|
if resetTTL {
|
|
v.expiresAt = time.Now().Add(v.ttl).Unix()
|
|
}
|
|
return v.val, nil
|
|
}
|
|
return nil, ErrNotFound
|
|
}
|
|
|
|
func (i *ImageCache) GetWithNewTTL(key string, newTtl time.Duration) (image.Image, error) {
|
|
i.mu.RLock()
|
|
defer i.mu.RUnlock()
|
|
|
|
if v, ok := i.cache[key]; ok {
|
|
v.lastAccessed = time.Now().Unix()
|
|
v.expiresAt = time.Now().Add(newTtl).Unix()
|
|
v.ttl = newTtl
|
|
return v.val, nil
|
|
}
|
|
return nil, ErrNotFound
|
|
}
|
|
|
|
// must be called when rwmutex is already acquired for writing
|
|
func (i *ImageCache) evictOne() {
|
|
now := time.Now().Unix()
|
|
var lruKey string
|
|
lruTime := now
|
|
var lruExpiredKey string
|
|
lruExpiredTime := now
|
|
for k, v := range i.cache {
|
|
if v.expiresAt < now && v.lastAccessed < lruExpiredTime {
|
|
lruExpiredTime = v.lastAccessed
|
|
lruExpiredKey = k
|
|
}
|
|
if v.lastAccessed < lruTime {
|
|
lruTime = v.lastAccessed
|
|
lruKey = k
|
|
}
|
|
}
|
|
if lruExpiredTime < now {
|
|
// deleting LRU expired item
|
|
delete(i.cache, lruExpiredKey)
|
|
} else {
|
|
// no expired items, delete LRU non-expired item
|
|
delete(i.cache, lruKey)
|
|
}
|
|
}
|
|
|
|
type expiredItem struct {
|
|
key string
|
|
lastAccessed int64
|
|
}
|
|
|
|
// TODO
|
|
func (i *ImageCache) EvictExpired() {
|
|
i.mu.RLock()
|
|
expired := make([]expiredItem, 0, len(i.cache)-i.MinSize)
|
|
now := time.Now().Unix()
|
|
for k, v := range i.cache {
|
|
if v.expiresAt < now {
|
|
expired = append(expired, expiredItem{key: k, lastAccessed: v.lastAccessed})
|
|
}
|
|
}
|
|
i.mu.RUnlock()
|
|
|
|
count := len(i.cache)
|
|
for count > i.MinSize {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func heapify(arr *[]expiredItem, i int) {
|
|
//smallest := i
|
|
//lChild := 2*i + 1
|
|
//rChild := 2*i + 2
|
|
|
|
}
|