cache

Documentation

Index

• func HashKey(key string) string
• type BackgroundConfig
  • func (cfg *BackgroundConfig) RegisterFlagsWithPrefix(prefix string, description string, f *flag.FlagSet)
• type Cache
  • func Instrument(name string, cache Cache) Cache
  • func New(cfg Config) (Cache, error)
  • func NewBackground(name string, cfg BackgroundConfig, cache Cache) Cache
  • func NewMockCache() Cache
  • func NewSnappy(next Cache) Cache
  • func NewTiered(caches []Cache) Cache
  • func StopOnce(cache Cache) Cache
• type Config
  • func (cfg *Config) RegisterFlagsWithPrefix(prefix string, description string, f *flag.FlagSet)
• type FifoCache
  • func NewFifoCache(name string, cfg FifoCacheConfig) *FifoCache
  • func (c *FifoCache) Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string)
  • func (c *FifoCache) Get(ctx context.Context, key string) (interface{}, bool)
  • func (c *FifoCache) Put(ctx context.Context, keys []string, values []interface{})
  • func (c *FifoCache) Stop() error
  • func (c *FifoCache) Store(ctx context.Context, keys []string, bufs [][]byte)
• type FifoCacheConfig
  • func (cfg *FifoCacheConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)
• type Memcached
  • func NewMemcached(cfg MemcachedConfig, client MemcachedClient, name string) *Memcached
  • func (c *Memcached) Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missed []string)
  • func (c *Memcached) Stop() error
  • func (c *Memcached) Store(ctx context.Context, keys []string, bufs [][]byte)
• type MemcachedClient
  • func NewMemcachedClient(cfg MemcachedClientConfig) MemcachedClient
• type MemcachedClientConfig
  • func (cfg *MemcachedClientConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)
• type MemcachedConfig
  • func (cfg *MemcachedConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)
• type MemcachedJumpHashSelector
  • func (s *MemcachedJumpHashSelector) Each(f func(net.Addr) error) error
  • func (s *MemcachedJumpHashSelector) PickServer(key string) (net.Addr, error)
  • func (s *MemcachedJumpHashSelector) SetServers(servers ...string) error

Functions

func HashKey

func HashKey(key string) string

HashKey hashes key into something you can store in memcached.

Types

type BackgroundConfig

type BackgroundConfig struct {
	WriteBackGoroutines int `yaml:"writeback_goroutines,omitempty"`
	WriteBackBuffer     int `yaml:"writeback_buffer,omitempty"`
}

BackgroundConfig is config for a Background Cache.

func (*BackgroundConfig) RegisterFlagsWithPrefix

func (cfg *BackgroundConfig) RegisterFlagsWithPrefix(prefix string, description string, f *flag.FlagSet)

RegisterFlagsWithPrefix adds the flags required to config this to the given FlagSet

type Cache

type Cache interface {
	Store(ctx context.Context, key []string, buf [][]byte)
	Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string)
	Stop() error
}

Cache byte arrays by key.

NB we intentionally do not return errors in this interface - caching is best effort by definition. We found that when these methods did return errors, the caller would just log them - so its easier for implementation to do that. Whatsmore, we found partially successful Fetchs were often treated as failed when they returned an error.

func Instrument

func Instrument(name string, cache Cache) Cache

Instrument returns an instrumented cache.

func New

func New(cfg Config) (Cache, error)

New creates a new Cache using Config.

func NewBackground

func NewBackground(name string, cfg BackgroundConfig, cache Cache) Cache

NewBackground returns a new Cache that does stores on background goroutines.

func NewMockCache

func NewMockCache() Cache

NewMockCache makes a new MockCache

func NewSnappy

func NewSnappy(next Cache) Cache

NewSnappy makes a new snappy encoding cache wrapper.

func NewTiered

func NewTiered(caches []Cache) Cache

NewTiered makes a new tiered cache.

func StopOnce

func StopOnce(cache Cache) Cache

StopOnce wraps a Cache and ensures its only stopped once.

type Config

type Config struct {
	EnableFifoCache bool `yaml:"enable_fifocache,omitempty"`

	DefaultValidity time.Duration `yaml:"defaul_validity,omitempty"`

	Background     BackgroundConfig      `yaml:"background,omitempty"`
	Memcache       MemcachedConfig       `yaml:"memcached,omitempty"`
	MemcacheClient MemcachedClientConfig `yaml:"memcached_client,omitempty"`
	Fifocache      FifoCacheConfig       `yaml:"fifocache,omitempty"`

	// This is to name the cache metrics properly.
	Prefix string `yaml:"prefix,omitempty"`

	// For tests to inject specific implementations.
	Cache Cache
}

Config for building Caches.

func (*Config) RegisterFlagsWithPrefix

func (cfg *Config) RegisterFlagsWithPrefix(prefix string, description string, f *flag.FlagSet)

RegisterFlagsWithPrefix adds the flags required to config this to the given FlagSet

type FifoCache

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

FifoCache is a simple string -> interface{} cache which uses a fifo slide to manage evictions. O(1) inserts and updates, O(1) gets.

func NewFifoCache

func NewFifoCache(name string, cfg FifoCacheConfig) *FifoCache

NewFifoCache returns a new initialised FifoCache of size. TODO(bwplotka): Fix metrics, get them out of globals, separate or allow prefixing.

func (*FifoCache) Fetch

func (c *FifoCache) Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string)

Fetch implements Cache.

func (*FifoCache) Get

func (c *FifoCache) Get(ctx context.Context, key string) (interface{}, bool)

Get returns the stored value against the key and when the key was last updated.

func (*FifoCache) Put

func (c *FifoCache) Put(ctx context.Context, keys []string, values []interface{})

Put stores the value against the key.

func (*FifoCache) Stop

func (c *FifoCache) Stop() error

Stop implements Cache.

func (*FifoCache) Store

func (c *FifoCache) Store(ctx context.Context, keys []string, bufs [][]byte)

Store implements Cache.

type FifoCacheConfig

type FifoCacheConfig struct {
	Size     int           `yaml:"size,omitempty"`
	Validity time.Duration `yaml:"validity,omitempty"`
}

FifoCacheConfig holds config for the FifoCache.

func (*FifoCacheConfig) RegisterFlagsWithPrefix

func (cfg *FifoCacheConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)

RegisterFlagsWithPrefix adds the flags required to config this to the given FlagSet

type Memcached

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

Memcached type caches chunks in memcached

func NewMemcached

func NewMemcached(cfg MemcachedConfig, client MemcachedClient, name string) *Memcached

NewMemcached makes a new Memcache. TODO(bwplotka): Fix metrics, get them out of globals, separate or allow prefixing. TODO(bwplotka): Remove globals & util packages from cache package entirely (e.g util.Logger).

func (*Memcached) Fetch

func (c *Memcached) Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missed []string)

Fetch gets keys from the cache. The keys that are found must be in the order of the keys requested.

func (*Memcached) Stop

func (c *Memcached) Stop() error

Stop does nothing.

func (*Memcached) Store

func (c *Memcached) Store(ctx context.Context, keys []string, bufs [][]byte)

Store stores the key in the cache.

type MemcachedClient

type MemcachedClient interface {
	GetMulti(keys []string) (map[string]*memcache.Item, error)
	Set(item *memcache.Item) error
}

MemcachedClient interface exists for mocking memcacheClient.

func NewMemcachedClient

func NewMemcachedClient(cfg MemcachedClientConfig) MemcachedClient

NewMemcachedClient creates a new MemcacheClient that gets its server list from SRV and updates the server list on a regular basis.

type MemcachedClientConfig

type MemcachedClientConfig struct {
	Host           string        `yaml:"host,omitempty"`
	Service        string        `yaml:"service,omitempty"`
	Timeout        time.Duration `yaml:"timeout,omitempty"`
	MaxIdleConns   int           `yaml:"max_idle_conns,omitempty"`
	UpdateInterval time.Duration `yaml:"update_interval,omitempty"`
	ConsistentHash bool          `yaml:"consistent_hash,omitempty"`
}

MemcachedClientConfig defines how a MemcachedClient should be constructed.

func (*MemcachedClientConfig) RegisterFlagsWithPrefix

func (cfg *MemcachedClientConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)

RegisterFlagsWithPrefix adds the flags required to config this to the given FlagSet

type MemcachedConfig

type MemcachedConfig struct {
	Expiration time.Duration `yaml:"expiration,omitempty"`

	BatchSize   int `yaml:"batch_size,omitempty"`
	Parallelism int `yaml:"parallelism,omitempty"`
}

MemcachedConfig is config to make a Memcached

func (*MemcachedConfig) RegisterFlagsWithPrefix

func (cfg *MemcachedConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)

RegisterFlagsWithPrefix adds the flags required to config this to the given FlagSet

type MemcachedJumpHashSelector

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

MemcachedJumpHashSelector implements the memcache.ServerSelector interface. MemcachedJumpHashSelector utilizes a jump hash to distribute keys to servers.

While adding or removing servers only requires 1/N keys to move, servers are treated as a stack and can only be pushed/popped. Therefore, MemcachedJumpHashSelector works best for servers with consistent DNS names where the naturally sorted order is predictable.

func (*MemcachedJumpHashSelector) Each

func (s *MemcachedJumpHashSelector) Each(f func(net.Addr) error) error

Each iterates over each server and calls the given function. If f returns a non-nil error, iteration will stop and that error will be returned.

func (*MemcachedJumpHashSelector) PickServer

func (s *MemcachedJumpHashSelector) PickServer(key string) (net.Addr, error)

PickServer returns the server address that a given item should be shared onto.

func (*MemcachedJumpHashSelector) SetServers

func (s *MemcachedJumpHashSelector) SetServers(servers ...string) error

SetServers changes a MemcachedJumpHashSelector's set of servers at runtime and is safe for concurrent use by multiple goroutines.

Each server is given equal weight. A server is given more weight if it's listed multiple times.

SetServers returns an error if any of the server names fail to resolve. No attempt is made to connect to the server. If any error occurs, no changes are made to the internal server list.

To minimize the number of rehashes for keys when scaling the number of servers in subsequent calls to SetServers, servers are stored in natural sort order.