cache

package
v1.13.0-rc.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 6, 2022 License: Apache-2.0 Imports: 34 Imported by: 11

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ExtractCacheGenNumber added in v1.1.0 

func ExtractCacheGenNumber(ctx context.Context) string

ExtractCacheGenNumbersFromHeaders gets the cache gen from the context.

func HashKey 

func HashKey(key string) string

HashKey hashes key into something you can store in memcached.

func InjectCacheGenNumber added in v1.1.0 

func InjectCacheGenNumber(ctx context.Context, cacheGen string) context.Context

InjectCacheGenNumber returns a derived context containing the cache gen.

func IsEmptyTieredCache added in v1.2.0 

func IsEmptyTieredCache(cache Cache) bool

IsEmptyTieredCache is used to determine whether the current Cache is implemented by an empty tiered.

func StringToBytes added in v1.4.0 

func StringToBytes(s string) []byte

StringToBytes converts string to byte slice. (copied from vendor/github.com/go-redis/redis/v8/internal/util/unsafe.go)

Types

type BackgroundConfig 

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

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()
}

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, reg prometheus.Registerer) Cache

Instrument returns an instrumented cache.

func New 

func New(cfg Config, reg prometheus.Registerer, logger log.Logger) (Cache, error)

New creates a new Cache using Config.

func NewBackground 

func NewBackground(name string, cfg BackgroundConfig, cache Cache, reg prometheus.Registerer) Cache

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

func NewCacheGenNumMiddleware added in v1.1.0 

func NewCacheGenNumMiddleware(downstreamCache Cache) Cache

NewCacheGenNumMiddleware creates a new GenNumMiddleware.

func NewMockCache 

func NewMockCache() Cache

NewMockCache makes a new MockCache.

func NewNoopCache added in v1.0.0 

func NewNoopCache() Cache

NewNoopCache returns a no-op cache.

func NewSnappy 

func NewSnappy(next Cache, logger log.Logger) 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"`

	DefaultValidity time.Duration `yaml:"default_validity"`

	Background     BackgroundConfig      `yaml:"background"`
	Memcache       MemcachedConfig       `yaml:"memcached"`
	MemcacheClient MemcachedClientConfig `yaml:"memcached_client"`
	Redis          RedisConfig           `yaml:"redis"`
	Fifocache      FifoCacheConfig       `yaml:"fifocache"`

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

	// For tests to inject specific implementations.
	Cache Cache `yaml:"-"`
}

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

func (*Config) Validate added in v1.1.0 

func (cfg *Config) Validate() error

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, reg prometheus.Registerer, logger log.Logger) *FifoCache

NewFifoCache returns a new initialised FifoCache of size.

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) ([]byte, bool)

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

func (*FifoCache) Stop 

func (c *FifoCache) Stop()

Stop implements Cache.

func (*FifoCache) Store 

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

Store implements Cache.

type FifoCacheConfig 

type FifoCacheConfig struct {
	MaxSizeBytes string        `yaml:"max_size_bytes"`
	MaxSizeItems int           `yaml:"max_size_items"`
	Validity     time.Duration `yaml:"validity"`

	DeprecatedSize int `yaml:"size"`
}

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

func (*FifoCacheConfig) Validate added in v1.1.0 

func (cfg *FifoCacheConfig) Validate() error

type GenNumMiddleware added in v1.1.0 

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

GenNumMiddleware adds gen number to keys from context. Expected size of gen numbers is upto 2 digits. If we start seeing problems with keys exceeding length limit, we need to look into resetting gen numbers.

func (GenNumMiddleware) Fetch added in v1.1.0 

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

Fetch adds cache gen number to keys before calling Fetch method of downstream cache. It also removes gen number before responding back with found and missing keys to make sure consumer of response gets to see same keys.

func (GenNumMiddleware) Stop added in v1.1.0 

func (c GenNumMiddleware) Stop()

Stop calls Stop method of downstream cache.

func (GenNumMiddleware) Store added in v1.1.0 

func (c GenNumMiddleware) Store(ctx context.Context, keys []string, buf [][]byte)

Store adds cache gen number to keys before calling Store method of downstream cache.

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, reg prometheus.Registerer, logger log.Logger) *Memcached

NewMemcached makes a new Memcached.

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()

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, name string, r prometheus.Registerer, logger log.Logger) 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"`
	Service        string        `yaml:"service"`
	Addresses      string        `yaml:"addresses"` // EXPERIMENTAL.
	Timeout        time.Duration `yaml:"timeout"`
	MaxIdleConns   int           `yaml:"max_idle_conns"`
	MaxItemSize    int           `yaml:"max_item_size"`
	UpdateInterval time.Duration `yaml:"update_interval"`
	ConsistentHash bool          `yaml:"consistent_hash"`
	CBFailures     uint          `yaml:"circuit_breaker_consecutive_failures"`
	CBTimeout      time.Duration `yaml:"circuit_breaker_timeout"`  // reset error count after this long
	CBInterval     time.Duration `yaml:"circuit_breaker_interval"` // remain closed for this long after CBFailures errors
}

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"`

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

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 added in v0.2.0 

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 added in v0.2.0 

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 added in v0.2.0 

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 added in v0.2.0 

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.

type RedisCache added in v0.3.0 

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

RedisCache type caches chunks in redis

func NewRedisCache added in v0.3.0 

func NewRedisCache(name string, redisClient *RedisClient, reg prometheus.Registerer, logger log.Logger) *RedisCache

NewRedisCache creates a new RedisCache

func (*RedisCache) Fetch added in v0.3.0 

func (c *RedisCache) 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 (*RedisCache) Stop added in v0.3.0 

func (c *RedisCache) Stop()

Stop stops the redis client.

func (*RedisCache) Store added in v0.3.0 

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

Store stores the key in the cache.

type RedisClient added in v1.4.0 

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

func NewRedisClient added in v1.4.0 

func NewRedisClient(cfg *RedisConfig) *RedisClient

NewRedisClient creates Redis client

func (*RedisClient) Close added in v1.4.0 

func (c *RedisClient) Close() error

func (*RedisClient) MGet added in v1.4.0 

func (c *RedisClient) MGet(ctx context.Context, keys []string) ([][]byte, error)

func (*RedisClient) MSet added in v1.4.0 

func (c *RedisClient) MSet(ctx context.Context, keys []string, values [][]byte) error

func (*RedisClient) Ping added in v1.4.0 

func (c *RedisClient) Ping(ctx context.Context) error

type RedisConfig added in v0.3.0 

type RedisConfig struct {
	Endpoint           string         `yaml:"endpoint"`
	MasterName         string         `yaml:"master_name"`
	Timeout            time.Duration  `yaml:"timeout"`
	Expiration         time.Duration  `yaml:"expiration"`
	DB                 int            `yaml:"db"`
	PoolSize           int            `yaml:"pool_size"`
	Password           flagext.Secret `yaml:"password"`
	EnableTLS          bool           `yaml:"tls_enabled"`
	InsecureSkipVerify bool           `yaml:"tls_insecure_skip_verify"`
	IdleTimeout        time.Duration  `yaml:"idle_timeout"`
	MaxConnAge         time.Duration  `yaml:"max_connection_age"`
}

RedisConfig defines how a RedisCache should be constructed.

func (*RedisConfig) RegisterFlagsWithPrefix added in v0.3.0 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.