cache

type AddressProvider interface {
	// Resolve resolves the provided list of memcached cluster to the actual nodes
	Resolve(context.Context, []string) error

	// Addresses returns the nodes
	Addresses() []string
}

type Allocator interface {
	// Get returns a byte slice with at least sz capacity. Length of the slice is
	// not guaranteed and so must be asserted by callers (cache clients).
	Get(sz int) *[]byte
	// Put returns the byte slice to the underlying allocator. The cache clients
	// will only call this method during error handling when allocated values are
	// not returned to the caller as cache results.
	Put(b *[]byte)
}

type BackendConfig struct {
	Backend   string                `yaml:"backend"`
	Memcached MemcachedClientConfig `yaml:"memcached"`
	Redis     RedisClientConfig     `yaml:"redis"`
}

type Cache interface {
	// StoreAsync writes data into the cache asynchronously.
	//
	// Note that individual byte buffers may be retained by the cache!
	StoreAsync(data map[string][]byte, ttl time.Duration)

	// Fetch multiple keys from cache. Returns map of input keys to data.
	// If key isn't in the map, data for given key was not found. One or more
	// Option instances may be passed to modify the behavior of this Fetch call.
	Fetch(ctx context.Context, keys []string, opts ...Option) map[string][]byte

	// Delete cache entry with the given key if it exists.
	Delete(ctx context.Context, key string) error

	// Name returns the name of this particular cache instance.
	Name() string
}

type CompressionConfig struct {
	Compression string `yaml:"compression"`
}

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

type Item struct {
	Data      []byte
	ExpiresAt time.Time
}

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

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

type MemcachedClientConfig struct {
	// Addresses specifies the list of memcached addresses. The addresses get
	// resolved with the DNS provider.
	Addresses flagext.StringSliceCSV `yaml:"addresses"`

	// Timeout specifies the socket read/write timeout.
	Timeout time.Duration `yaml:"timeout"`

	// ConnectTimeout specifies the connection timeout.
	ConnectTimeout time.Duration `yaml:"connect_timeout"`

	// WriteBufferSizeBytes specifies the size of the write buffer (in bytes). The buffer
	// is allocated for each connection.
	WriteBufferSizeBytes int `yaml:"write_buffer_size_bytes" category:"experimental"`

	// ReadBufferSizeBytes specifies the size of the read buffer (in bytes). The buffer
	// is allocated for each connection.
	ReadBufferSizeBytes int `yaml:"read_buffer_size_bytes" category:"experimental"`

	// MinIdleConnectionsHeadroomPercentage specifies the minimum number of idle connections
	// to keep open as a percentage of the number of recently used idle connections.
	// If negative, idle connections are kept open indefinitely.
	MinIdleConnectionsHeadroomPercentage float64 `yaml:"min_idle_connections_headroom_percentage" category:"advanced"`

	// MaxIdleConnections specifies the maximum number of idle connections that
	// will be maintained per address. For better performances, this should be
	// set to a number higher than your peak parallel requests.
	MaxIdleConnections int `yaml:"max_idle_connections" category:"advanced"`

	// MaxAsyncConcurrency specifies the maximum number of SetAsync goroutines.
	MaxAsyncConcurrency int `yaml:"max_async_concurrency" category:"advanced"`

	// MaxAsyncBufferSize specifies the queue buffer size for SetAsync operations.
	MaxAsyncBufferSize int `yaml:"max_async_buffer_size" category:"advanced"`

	// MaxGetMultiConcurrency specifies the maximum number of concurrent GetMulti() operations.
	// If set to 0, concurrency is unlimited.
	MaxGetMultiConcurrency int `yaml:"max_get_multi_concurrency" category:"advanced"`

	// MaxGetMultiBatchSize specifies the maximum number of keys a single underlying
	// GetMulti() should run. If more keys are specified, internally keys are split
	// into multiple batches and fetched concurrently, honoring MaxGetMultiConcurrency parallelism.
	// If set to 0, the max batch size is unlimited.
	MaxGetMultiBatchSize int `yaml:"max_get_multi_batch_size" category:"advanced"`

	// MaxItemSize specifies the maximum size of an item stored in memcached, in bytes.
	// Items bigger than MaxItemSize are skipped. If set to 0, no maximum size is enforced.
	MaxItemSize int `yaml:"max_item_size" category:"advanced"`

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

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

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

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

type Option func(opts *Options)

type Options struct {
	Alloc Allocator
}

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

type RedisClientConfig struct {
	// Endpoint specifies the endpoint of Redis server.
	Endpoint flagext.StringSliceCSV `yaml:"endpoint"`

	// Use the specified Username to authenticate the current connection
	// with one of the connections defined in the ACL list when connecting
	// to a Redis 6.0 instance, or greater, that is using the Redis ACL system.
	Username string `yaml:"username"`

	// Optional password. Must match the password specified in the
	// requirepass server configuration option (if connecting to a Redis 5.0 instance, or lower),
	// or the User Password when connecting to a Redis 6.0 instance, or greater,
	// that is using the Redis ACL system.
	Password flagext.Secret `yaml:"password"`

	// DB Database to be selected after connecting to the server.
	DB int `yaml:"db"`

	// MasterName is Redis Sentinel master name. An empty string for Redis Server or Redis Cluster.
	MasterName string `yaml:"master_name" category:"advanced"`

	// DialTimeout specifies the client dial timeout.
	DialTimeout time.Duration `yaml:"dial_timeout" category:"advanced"`

	// ReadTimeout specifies the client read timeout.
	ReadTimeout time.Duration `yaml:"read_timeout" category:"advanced"`

	// WriteTimeout specifies the client write timeout.
	WriteTimeout time.Duration `yaml:"write_timeout" category:"advanced"`

	// Maximum number of socket connections.
	ConnectionPoolSize int `yaml:"connection_pool_size" category:"advanced"`

	// Amount of time client waits for connection if all connections
	// are busy before returning an error.
	// Default is ReadTimeout + 1 second.
	ConnectionPoolTimeout time.Duration `yaml:"connection_pool_timeout" category:"advanced"`

	// MinIdleConnections specifies the minimum number of idle connections which is useful when establishing
	// new connection is slow.
	MinIdleConnections int `yaml:"min_idle_connections" category:"advanced"`

	// Amount of time after which client closes idle connections.
	// Should be less than server's timeout.
	// -1 disables idle timeout check.
	IdleTimeout time.Duration `yaml:"idle_timeout" category:"advanced"`

	// MaxConnectionAge is connection age at which client retires (closes) the connection.
	// Default 0 is to not close aged connections.
	MaxConnectionAge time.Duration `yaml:"max_connection_age" category:"advanced"`

	// MaxItemSize specifies the maximum size of an item stored in Redis.
	// Items bigger than MaxItemSize are skipped.
	// If set to 0, no maximum size is enforced.
	MaxItemSize int `yaml:"max_item_size" category:"advanced"`

	// MaxAsyncConcurrency specifies the maximum number of SetAsync goroutines.
	MaxAsyncConcurrency int `yaml:"max_async_concurrency" category:"advanced"`

	// MaxAsyncBufferSize specifies the queue buffer size for SetAsync operations.
	MaxAsyncBufferSize int `yaml:"max_async_buffer_size" category:"advanced"`

	// MaxGetMultiConcurrency specifies the maximum number of concurrent GetMulti() operations.
	// If set to 0, concurrency is unlimited.
	MaxGetMultiConcurrency int `yaml:"max_get_multi_concurrency" category:"advanced"`

	// MaxGetMultiBatchSize specifies the maximum size per batch for mget.
	MaxGetMultiBatchSize int `yaml:"max_get_multi_batch_size" category:"advanced"`

	// TLSEnabled enable TLS for Redis connection.
	TLSEnabled bool `yaml:"tls_enabled" category:"advanced"`

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

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

type RemoteCacheClient interface {
	// GetMulti fetches multiple keys at once from a cache. In case of error,
	// an empty map is returned and the error tracked/logged. One or more Option
	// instances may be passed to modify the behavior of this GetMulti call.
	GetMulti(ctx context.Context, keys []string, opts ...Option) map[string][]byte

	// SetAsync enqueues an asynchronous operation to store a key into a cache.
	// In case the underlying async operation fails, the error will be tracked/logged.
	SetAsync(key string, value []byte, ttl time.Duration)

	// SetMultiAsync enqueues asynchronous operations to store a keys and values
	// into a cache. In case the underlying async operations fail, the error will
	// be tracked/logged.
	SetMultiAsync(data map[string][]byte, ttl time.Duration)

	// Delete deletes a key from a cache.
	// This is a synchronous operation. If an asynchronous set operation for key is still
	// pending to be processed, it will wait for it to complete before performing deletion.
	Delete(ctx context.Context, key string) error

	// Stop client and release underlying resources.
	Stop()

	// Name returns the name of this particular cache instance.
	Name() string
}

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

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