lruttl

README

lru-ttl

LRU cache with ttl. It's useful for short ttl cache. L2Cache use lru cache for the first cache, and slow cache for the second cache. Lru cache should be set max entries for less memory usage but faster, slow cache is slower but more space.

LRU TTL

cache := lruttl.New(1000, 60 * time.Second)
cache.Add("tree.xie", "my data")
data, ok := cache.Get("tree.xie")
cache.Remove("tree.xie")
cache.Add("tree.xie", "my data", time.Second)

L2Cache

// redisCache
l2 := lruttl.NewL2Cache(redisCache, 200, 10 * time.Minute)
ctx := context.Background()
err := l2.Set(ctx, "key", &map[string]string{
    "name": "test",
})
fmt.Println(err)
m := make(map[string]string)
err = l2.Get(ctx, "key", &m)
fmt.Println(err)
fmt.Println(m)

Ring

ringCache := lruttl.NewRing(lruttl.RingCacheParams{
    Size:       10,
    MaxEntries: 1000,
    DefaultTTL: time.Minute,
})
lruCache := ringCache("key")

Documentation

Index

• Variables
• func BufferMarshal(result interface{}) ([]byte, error)
• func BufferUnmarshal(data []byte, result interface{}) error
• func CPUTicks() int64
• func FastRand() uint32
• func MemHash(data []byte) uint64
• func MemHashString(str string) uint64
• func Memclr(b []byte)
• func NanoTime() int64
• func NewRing(params RingCacheParams, opts ...CacheOption) *ringCache
• type Cache
  • func New(maxEntries int, defaultTTL time.Duration, opts ...CacheOption) *Cache
  • func (c *Cache) Add(key Key, value interface{}, ttl ...time.Duration)
  • func (c *Cache) Get(key Key) (value interface{}, ok bool)
  • func (c *Cache) Keys() []Key
  • func (c *Cache) Len() int
  • func (c *Cache) Peek(key Key) (interface{}, bool)
  • func (c *Cache) Remove(key Key)
  • func (c *Cache) TTL(key Key) time.Duration
• type CacheOption
  • func CacheEvictedOption(fn func(key Key, value interface{})) CacheOption
• type Key
• type L2Cache
  • func NewL2Cache(slowCache SlowCache, maxEntries int, defaultTTL time.Duration, ...) *L2Cache
  • func (l2 *L2Cache) Get(ctx context.Context, key string, result interface{}) error
  • func (l2 *L2Cache) Set(ctx context.Context, key string, value interface{}, ttl ...time.Duration) error
  • func (l2 *L2Cache) TTL(ctx context.Context, key string) (time.Duration, error)
• type L2CacheOption
  • func L2CacheMarshalOption(fn func(v interface{}) ([]byte, error)) L2CacheOption
  • func L2CachePrefixOption(prefix string) L2CacheOption
  • func L2CacheUnmarshalOption(fn func(data []byte, v interface{}) error) L2CacheOption
• type RingCacheParams
• type SlowCache

Variables

var ErrInvalidType = errors.New("invalid type")

ErrInvalidType is the error of invalid type

var ErrIsNil = errors.New("cache is nil")

ErrIsNil is the error of nil cache

Functions

func BufferMarshal

func BufferMarshal(result interface{}) ([]byte, error)

BufferMarshal converts *bytes.Buffer to bytes, it returns a ErrInvalidType if restult is not *bytes.Buffer

func BufferUnmarshal

func BufferUnmarshal(data []byte, result interface{}) error

BufferUnmarshal writes the data to buffer, it returns a ErrInvalidType if restult is not *bytes.Buffer

func CPUTicks

func CPUTicks() int64

CPUTicks is a faster alternative to NanoTime to measure time duration.

func FastRand

func FastRand() uint32

FastRand is a fast thread local random function.

func MemHash

func MemHash(data []byte) uint64

MemHash is the hash function used by go map, it utilizes available hardware instructions(behaves as aeshash if aes instruction is available). NOTE: The hash seed changes for every process. So, this cannot be used as a persistent hash.

func MemHashString

func MemHashString(str string) uint64

MemHashString is the hash function used by go map, it utilizes available hardware instructions (behaves as aeshash if aes instruction is available). NOTE: The hash seed changes for every process. So, this cannot be used as a persistent hash.

func Memclr

func Memclr(b []byte)

func NanoTime

func NanoTime() int64

NanoTime returns the current time in nanoseconds from a monotonic clock.

func NewRing

func NewRing(params RingCacheParams, opts ...CacheOption) *ringCache

NewRing returns a new ring cache

Types

type Cache

type Cache struct {
	// contains filtered or unexported fields
}

func New

func New(maxEntries int, defaultTTL time.Duration, opts ...CacheOption) *Cache

New returns a new lru cache with ttl

func (*Cache) Add

func (c *Cache) Add(key Key, value interface{}, ttl ...time.Duration)

Add adds a value to the cache, it will use default ttl if the ttl is nil.

func (*Cache) Get

func (c *Cache) Get(key Key) (value interface{}, ok bool)

Get returns value and exists from the cache by key, if value is expired then remove it. If the value is expired, value is not nil but exists is false.

func (*Cache) Keys

func (c *Cache) Keys() []Key

Keys gets all keys of cache

func (*Cache) Len

func (c *Cache) Len() int

Len returns the number of items in the cache.

func (*Cache) Peek

func (c *Cache) Peek(key Key) (interface{}, bool)

Peek get a key's value from the cache, but not move to front. The performance is better than get. It will not remove it if the cache is expired.

func (*Cache) Remove

func (c *Cache) Remove(key Key)

Remove removes the key's value from the cache.

func (*Cache) TTL

func (c *Cache) TTL(key Key) time.Duration

TTL returns the ttl of key

type CacheOption

type CacheOption func(c *Cache)

CacheOption cache option

func CacheEvictedOption

func CacheEvictedOption(fn func(key Key, value interface{})) CacheOption

CacheEvictedOption sets evicted function to cache

type Key

type Key interface{}

type L2Cache

type L2Cache struct {
	// contains filtered or unexported fields
}

func NewL2Cache

func NewL2Cache(slowCache SlowCache, maxEntries int, defaultTTL time.Duration, opts ...L2CacheOption) *L2Cache

NewL2Cache return a new L2Cache, it returns panic if maxEntries or defaultTTL is nil

func (*L2Cache) Get

func (l2 *L2Cache) Get(ctx context.Context, key string, result interface{}) error

Get first get cache from lru, if not exists, then get the data from slow cache. Use unmarshal function covert the data to result

func (*L2Cache) Set

func (l2 *L2Cache) Set(ctx context.Context, key string, value interface{}, ttl ...time.Duration) error

Set converts the value to bytes, then set it to lru cache and slow cache

func (*L2Cache) TTL

func (l2 *L2Cache) TTL(ctx context.Context, key string) (time.Duration, error)

TTL returns the ttl for key

type L2CacheOption

type L2CacheOption func(c *L2Cache)

L2CacheOption l2cache option

func L2CacheMarshalOption

func L2CacheMarshalOption(fn func(v interface{}) ([]byte, error)) L2CacheOption

L2CacheMarshalOption set custom marshal function for l2cache

func L2CachePrefixOption

func L2CachePrefixOption(prefix string) L2CacheOption

L2CachePrefixOption set prefix for l2cache

func L2CacheUnmarshalOption

func L2CacheUnmarshalOption(fn func(data []byte, v interface{}) error) L2CacheOption

L2CacheUnmarshalOption set custom unmarshal function for l2cache

type RingCacheParams

type RingCacheParams struct {
	// ring size
	Size int
	// max entries
	MaxEntries int
	// default ttl
	DefaultTTL time.Duration
}

type SlowCache

type SlowCache interface {
	Get(ctx context.Context, key string) ([]byte, error)
	Set(ctx context.Context, key string, value []byte, ttl time.Duration) error
	TTL(ctx context.Context, key string) (time.Duration, error)
}