cache

package
v3.1.0 Latest Latest
Warning

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

 Go to latest Published: Jul 2, 2024 License: AGPL-3.0 Imports: 37 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ExtractCacheGenNumber 

func ExtractCacheGenNumber(ctx context.Context) string

ExtractCacheGenNumber 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 

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

InjectCacheGenNumber returns a derived context containing the cache gen.

func IsCacheConfigured 

func IsCacheConfigured(cfg Config) bool

IsCacheConfigured determines if either of the following caches is configured: - memcached - redis - embedded-cache - specific cache implementation

func IsEmbeddedCacheSet 

func IsEmbeddedCacheSet(cfg Config) bool

func IsEmptyTieredCache 

func IsEmptyTieredCache(cache Cache) bool

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

func IsMemcacheSet 

func IsMemcacheSet(cfg Config) bool

IsMemcacheSet returns whether a non empty Memcache config is set or not, based on the configured host or addresses.

Internally, this function is used to set Memcache as the cache storage to be used.

func IsRedisSet 

func IsRedisSet(cfg Config) bool

IsRedisSet returns whether a non empty Redis config is set or not, based on the configured endpoint.

Internally, this function is used to set Redis as the cache storage to be used.

func IsSpecificImplementationSet 

func IsSpecificImplementationSet(cfg Config) bool

func StringToBytes 

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"`
	WriteBackSizeLimit  flagext.ByteSize `yaml:"writeback_size_limit"`
}

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) error
	Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string, err error)
	Stop()
	// GetCacheType returns a string indicating the cache "type" for the purpose of grouping cache usage statistics
	GetCacheType() stats.CacheType
}

Cache byte arrays by key.

func CollectStats 

func CollectStats(cache Cache) Cache

CollectStats returns a new Cache that keeps various statistics on cache usage.

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, cacheType stats.CacheType, metricsNamespace string) (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 

func NewCacheGenNumMiddleware(downstreamCache Cache) Cache

NewCacheGenNumMiddleware creates a new GenNumMiddleware.

func NewNoopCache 

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 {
	DefaultValidity time.Duration `yaml:"default_validity"`

	Background     BackgroundConfig      `yaml:"background"`
	Memcache       MemcachedConfig       `yaml:"memcached"`
	MemcacheClient MemcachedClientConfig `yaml:"memcached_client"`
	Redis          RedisConfig           `yaml:"redis"`
	EmbeddedCache  EmbeddedCacheConfig   `yaml:"embedded_cache"`

	// 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

type EmbeddedCache 

type EmbeddedCache[K comparable, V any] struct {
	// contains filtered or unexported fields
}

EmbeddedCache is a simple (comparable -> any) cache which uses a fifo slide to manage evictions. O(1) inserts and updates, O(1) gets.

This embedded cache implementation supports two eviction methods - based on number of items in the cache, and based on memory usage. For the memory-based eviction, set EmbeddedCacheConfig.MaxSizeMB to a positive integer, indicating upper limit of memory allocated by items in the cache. Alternatively, set EmbeddedCacheConfig.MaxSizeItems to a positive integer, indicating maximum number of items in the cache. If both parameters are set, both methods are enforced, whichever hits first.

func NewEmbeddedCache 

func NewEmbeddedCache(name string, cfg EmbeddedCacheConfig, reg prometheus.Registerer, logger log.Logger, cacheType stats.CacheType) *EmbeddedCache[string, []byte]

NewEmbeddedCache returns a new initialised EmbeddedCache where the key is a string and the value is a slice of bytes.

func NewTypedEmbeddedCache 

func NewTypedEmbeddedCache[K comparable, V any](
	name string,
	cfg EmbeddedCacheConfig,
	reg prometheus.Registerer,
	logger log.Logger,
	cacheType stats.CacheType,
	entrySizeCalculator cacheEntrySizeCalculator[K, V],
	onEntryRemoved func(key K, value V),
) *EmbeddedCache[K, V]

NewTypedEmbeddedCache returns a new initialised EmbeddedCache with the key and value of requested types. To limit the memory allocated by items in the cache, it's necessary to pass cacheEntrySizeCalculator that calculates the size of an entry in bytes. Also, this constructor allows passing the callback that will be called for the entry whenever it is removed from the cache.

func (*EmbeddedCache[K, V]) Fetch 

func (c *EmbeddedCache[K, V]) Fetch(ctx context.Context, keys []K) (foundKeys []K, foundValues []V, missingKeys []K, err error)

Fetch implements Cache.

func (*EmbeddedCache[K, V]) Get 

func (c *EmbeddedCache[K, V]) Get(_ context.Context, key K) (V, bool)

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

func (*EmbeddedCache[K, V]) GetCacheType 

func (c *EmbeddedCache[K, V]) GetCacheType() stats.CacheType

func (*EmbeddedCache[K, V]) Stop 

func (c *EmbeddedCache[K, V]) Stop()

Stop implements Cache.

func (*EmbeddedCache[K, V]) Store 

func (c *EmbeddedCache[K, V]) Store(_ context.Context, keys []K, values []V) error

Store implements Cache.

type EmbeddedCacheConfig 

type EmbeddedCacheConfig struct {
	Enabled      bool          `yaml:"enabled,omitempty"`
	MaxSizeMB    int64         `yaml:"max_size_mb"`
	MaxSizeItems int           `yaml:"max_size_items"`
	TTL          time.Duration `yaml:"ttl"`

	// PurgeInterval tell how often should we remove keys that are expired.
	// by default it takes `defaultPurgeInterval`
	PurgeInterval time.Duration `yaml:"-"`
}

EmbeddedCacheConfig represents in-process embedded cache config.

func (*EmbeddedCacheConfig) IsEnabled 

func (cfg *EmbeddedCacheConfig) IsEnabled() bool

func (*EmbeddedCacheConfig) RegisterFlagsWithPrefix 

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

func (*EmbeddedCacheConfig) RegisterFlagsWithPrefixAndDefaults 

func (cfg *EmbeddedCacheConfig) RegisterFlagsWithPrefixAndDefaults(prefix, description string, f *flag.FlagSet, defaultTTL time.Duration)

type Entry 

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

type GenNumMiddleware 

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 

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

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

func (c GenNumMiddleware) GetCacheType() stats.CacheType

func (GenNumMiddleware) Stop 

func (c GenNumMiddleware) Stop()

Stop calls Stop method of downstream cache.

func (GenNumMiddleware) Store 

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

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, cacheType stats.CacheType) *Memcached

NewMemcached makes a new Memcached.

func (*Memcached) Fetch 

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

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

func (*Memcached) GetCacheType 

func (c *Memcached) GetCacheType() stats.CacheType

func (*Memcached) Stop 

func (c *Memcached) Stop()

func (*Memcached) Store 

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

Store stores the key in the cache.

type MemcachedClient 

type MemcachedClient interface {
	GetMulti(keys []string, opts ...memcache.Option) (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, metricsNamespace string) 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"`
	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

	// TLSEnabled enables connecting to Memcached with TLS.
	TLSEnabled bool `yaml:"tls_enabled"`

	// TLS to use to connect to the Memcached server.
	TLS dstls.ClientConfig `yaml:",inline"`
}

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 MockCache 

type MockCache interface {
	Cache
	NumKeyUpdates() int
	GetInternal() map[string][]byte
	KeysRequested() int
	GetKeys() []string
	SetErr(error, error)
}

func NewMockCache 

func NewMockCache() MockCache

NewMockCache makes a new MockCache.

type RedisCache 

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

RedisCache type caches chunks in redis

func NewRedisCache 

func NewRedisCache(name string, redisClient *RedisClient, logger log.Logger, cacheType stats.CacheType) *RedisCache

NewRedisCache creates a new RedisCache

func (*RedisCache) Fetch 

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

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

func (*RedisCache) GetCacheType 

func (c *RedisCache) GetCacheType() stats.CacheType

func (*RedisCache) Stop 

func (c *RedisCache) Stop()

Stop stops the redis client.

func (*RedisCache) Store 

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

Store stores the key in the cache.

type RedisClient 

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

func NewRedisClient 

func NewRedisClient(cfg *RedisConfig) (*RedisClient, error)

NewRedisClient creates Redis client

func (*RedisClient) Close 

func (c *RedisClient) Close() error

func (*RedisClient) MGet 

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

func (*RedisClient) MSet 

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

func (*RedisClient) Ping 

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

type RedisConfig 

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"`
	Username           string         `yaml:"username"`
	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"`
	RouteRandomly      bool           `yaml:"route_randomly"`
}

RedisConfig defines how a RedisCache should be constructed.

func (*RedisConfig) RegisterFlagsWithPrefix 

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

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

type TypedCache 

type TypedCache[K comparable, V any] interface {
	Store(ctx context.Context, keys []K, values []V) error
	Fetch(ctx context.Context, keys []K) (found []K, values []V, missing []K, err error)
	Stop()
	// GetCacheType returns a string indicating the cache "type" for the purpose of grouping cache usage statistics
	GetCacheType() stats.CacheType
}

Interface for EmbeddedCache Matches the interface from cache.Cache but has generics

func NewNoopTypedCache 

func NewNoopTypedCache[K comparable, V any]() TypedCache[K, V]

Source Files

View all Source files

Directories

Path Synopsis

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.