Documentation ¶
Index ¶
- func ExtractCacheGenNumber(ctx context.Context) string
- func HashKey(key string) string
- func InjectCacheGenNumber(ctx context.Context, cacheGen string) context.Context
- func IsEmptyTieredCache(cache Cache) bool
- func IsMemcacheSet(cfg Config) bool
- func IsRedisSet(cfg Config) bool
- func StringToBytes(s string) []byte
- type BackgroundConfig
- type Cache
- func Instrument(name string, cache Cache, reg prometheus.Registerer) Cache
- func New(cfg Config, reg prometheus.Registerer, logger log.Logger) (Cache, error)
- func NewBackground(name string, cfg BackgroundConfig, cache Cache, reg prometheus.Registerer) Cache
- func NewCacheGenNumMiddleware(downstreamCache Cache) Cache
- func NewMockCache() Cache
- func NewNoopCache() Cache
- func NewSnappy(next Cache, logger log.Logger) Cache
- func NewTiered(caches []Cache) Cache
- func StopOnce(cache Cache) Cache
- type Config
- type FifoCache
- func (c *FifoCache) Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string, err error)
- func (c *FifoCache) Get(ctx context.Context, key string) ([]byte, bool)
- func (c *FifoCache) Stop()
- func (c *FifoCache) Store(ctx context.Context, keys []string, values [][]byte) error
- type FifoCacheConfig
- type GenNumMiddleware
- type Memcached
- type MemcachedClient
- type MemcachedClientConfig
- type MemcachedConfig
- type MemcachedJumpHashSelector
- type RedisCache
- type RedisClient
- type RedisConfig
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func ExtractCacheGenNumber ¶
ExtractCacheGenNumbersFromHeaders gets the cache gen from the context.
func InjectCacheGenNumber ¶
InjectCacheGenNumber returns a derived context containing the cache gen.
func IsEmptyTieredCache ¶
IsEmptyTieredCache is used to determine whether the current Cache is implemented by an empty tiered.
func IsMemcacheSet ¶
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 ¶
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 StringToBytes ¶
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) error Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string, err error) 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 ¶
NewCacheGenNumMiddleware creates a new GenNumMiddleware.
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:"-"` // AsyncCacheWriteBackConcurrency specifies the number of goroutines to use when asynchronously writing chunks fetched from the store to the chunk cache. AsyncCacheWriteBackConcurrency int `yaml:"async_cache_write_back_concurrency"` // AsyncCacheWriteBackBufferSize specifies the maximum number of fetched chunks to buffer for writing back to the chunk cache. AsyncCacheWriteBackBufferSize int `yaml:"async_cache_write_back_buffer_size"` }
Config for building Caches.
func (*Config) RegisterFlagsWithPrefix ¶
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, 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, err error)
Fetch implements Cache.
type FifoCacheConfig ¶
type FifoCacheConfig struct { MaxSizeBytes string `yaml:"max_size_bytes"` MaxSizeItems int `yaml:"max_size_items"` TTL time.Duration `yaml:"ttl"` DeprecatedValidity time.Duration `yaml:"validity"` DeprecatedSize int `yaml:"size"` PurgeInterval time.Duration }
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 ¶
func (cfg *FifoCacheConfig) Validate() error
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) Stop ¶
func (c GenNumMiddleware) Stop()
Stop calls Stop 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.
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 ¶
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.
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) *RedisCache
NewRedisCache creates a new RedisCache
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
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"` 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 ¶
func (cfg *RedisConfig) RegisterFlagsWithPrefix(prefix, description string, f *flag.FlagSet)
RegisterFlagsWithPrefix adds the flags required to config this to the given FlagSet