loader

README

cache-loader

Golang Cache Loader

Feature

• Thread safe
• Fetch once even when concurrent process request same key.
• stale-while-revalidate when item is expired

Example

func main() {
  itemLoader := loader.NewLRU(fetchItem, 5 * time.Minute, 1000)
  item, err := loader.Get("key")
  // use item
}

func fetchItem(key interface{}) (interface{}, error) {
  res, err := http.Get("https://example.com/item/" + key)
  if err != nil {
    return nil, err
  }
  return processResponse(res)
}

Documentation

Index

• type CacheDriver
  • func InMemoryCache() CacheDriver
• type ContextFactory
• type Fetcher
• type InMemoryKeyLocker
  • func (l *InMemoryKeyLocker[Key]) Lock(key Key) func()
• type KeyLocker
• type Loader
  • func New[Key comparable, Value any](fn Fetcher[Key, Value], ttl time.Duration, options ...Option) *Loader[Key, Value]
  • func NewLRU[Key comparable, Value any](fn Fetcher[Key, Value], ttl time.Duration, size int, options ...Option) *Loader[Key, Value]
  • func (l *Loader[Key, Value]) Load(key Key) (Value, error)
• type Option
  • func WithContextFactory(cf ContextFactory) Option
  • func WithDriver(driver CacheDriver) Option
  • func WithErrorTTL(ttl time.Duration) Option

Types

type CacheDriver

type CacheDriver interface {
	Add(key interface{}, value interface{})
	Get(key interface{}) (interface{}, bool)
}

CacheDriver stores the items you can use ARCCache or TwoQueueCache from github.com/hashicorp/golang-lru

func InMemoryCache

func InMemoryCache() CacheDriver

type ContextFactory

type ContextFactory func() context.Context

ContextFactory creates context to be used by LoadFunc

type Fetcher

type Fetcher[Key comparable, Value any] func(ctx context.Context, key Key) (Value, error)

Fetcher loads the value based on key

type InMemoryKeyLocker

type InMemoryKeyLocker[Key comparable] struct {
	// contains filtered or unexported fields
}

func (*InMemoryKeyLocker[Key]) Lock

func (l *InMemoryKeyLocker[Key]) Lock(key Key) func()

Lock implements KeyLocker

type KeyLocker

type KeyLocker[Key comparable] interface {
	Lock(key Key) (unlock func())
}

type Loader

type Loader[Key comparable, Value any] struct {
	// contains filtered or unexported fields
}

Loader manage items in cache and fetch them if not exist

func New

func New[Key comparable, Value any](fn Fetcher[Key, Value], ttl time.Duration, options ...Option) *Loader[Key, Value]

New creates new Loader

func NewLRU

func NewLRU[Key comparable, Value any](fn Fetcher[Key, Value], ttl time.Duration, size int, options ...Option) *Loader[Key, Value]

NewLRU creates Loader with lru based cache

func (*Loader[Key, Value]) Load

func (l *Loader[Key, Value]) Load(key Key) (Value, error)

Load the item. If it doesn't exist on cache, Loader will call LoadFunc once even when other go routine access the same key. If the item is expired, it will return old value while loading new one.

type Option

type Option func(cfg *config)

func WithContextFactory

func WithContextFactory(cf ContextFactory) Option

func WithDriver

func WithDriver(driver CacheDriver) Option

func WithErrorTTL

func WithErrorTTL(ttl time.Duration) Option