The expirable-cache from go-pkgz

expirable-cache's People

Contributors

Stargazers

Watchers

expirable-cache's Issues

Add to README distinctions between this library and hashicorp/golang-lru

This cache is heavily inspired by hashicorp/golang-lru simplelru implementation.

How does it differ?

Feature request: Add option to get expiry time

I'd like to store the cache on disk when I close my application, but I need a way to get the expiry time for each item so I can store it.
I'd also need to set it back later, so having the option to set the ttl with time.Time would also be handy, but not as important since I can just subtract the current time.

Basic get does not work

The following code returns nil regardless of what key is passed in. The keys are obviously there and returned by the .Keys() function

Why can I not access the actual cache values?

package cache

import (
	"errors"
	"fmt"
	"log"
	"time"

	common "github.com/awilson9/redis_proxy/go/pkg/common"
	config "github.com/awilson9/redis_proxy/go/pkg/config"
	cache "github.com/go-pkgz/expirable-cache"
	lru "github.com/go-pkgz/expirable-cache"
)

type LRUCache struct {
	Cache  lru.Cache
	Expiry int
}

func (lruCache *LRUCache) InitCache() {
	cfg, err := config.NewConfig(common.ConfigPath)
	if err != nil {
		log.Fatal(err)
	}
	var capacity = cfg.App.Cache.Capacity
	var ttl = cfg.App.Cache.Expiry
	log.Printf("Initializing LRU cache with capacity %v expiration %v", capacity, ttl)
	cache, err := lru.NewCache(cache.MaxKeys(capacity), cache.TTL(time.Duration(ttl)*time.Millisecond))
	if err != nil {
		log.Fatal(err)
	}
	lruCache.Expiry = ttl
	lruCache.Cache = cache
}

func (lruCache *LRUCache) GetFromCache(lruCacheKey string) (value string, ok bool) {
	interfaceValue, ok := lruCache.Cache.Get(lruCacheKey)
	var valueStr string = ""
	if interfaceValue != nil {
		valueStr = interfaceValue.(string)
	}

	return valueStr, ok
}

func (lruCache *LRUCache) AddToCache(lruCacheKey string, lruCacheValue string) {
	lruCache.Cache.Set(lruCacheKey, lruCacheValue, 0)
}

func (lruCache *LRUCache) DumpCache() ([]common.CacheEntry, error) {
	keys := lruCache.Cache.Keys()
	cacheValues := make([]common.CacheEntry, len(keys))
	log.Printf("%v", keys)
	for _, key := range keys {
		log.Printf("key: %s", key)
		value, ok := lruCache.GetFromCache(key)
		log.Printf("value: %v", value)
		if ok {
			cacheValues = append(cacheValues, common.CacheEntry{Key: key, Value: fmt.Sprintf("%v", value)})
		} else {
			return nil, errors.New("Unable to dump cache")
		}

	}
	return cacheValues, nil
}

Recommend Projects