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

type Cache 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

	// GetMultiWithError fetches multiple keys at once from a cache and returns an error
	// if the operation failed. It may return both results and an error if there are only partial
	// failures. One or more Option instances may be passed to modify the
	// behavior of this GetMultiWithError call.
	GetMultiWithError(ctx context.Context, keys []string, opts ...Option) (map[string][]byte, error)

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

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

	// Set stores a key and value into a cache.
	Set(ctx context.Context, key string, value []byte, ttl time.Duration) error

	// Add stores a key and value into a cache only if it does not already exist. If the
	// item was not stored because an entry already exists in the cache, ErrNotStored will
	// be returned.
	Add(ctx context.Context, key string, value []byte, ttl time.Duration) error

	// Delete deletes a key from a cache.
	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 CompressionConfig struct {
	Compression string `yaml:"compression"`
}

type ErroringMockCache struct {
	*MockCache
	GetMultiErr error
}

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

	// AddressesLookupPeriod specifies how often addresses are resolved with the
	// DNS provider.
	AddressesLookupPeriod time.Duration `yaml:"addresses_lookup_period" category:"advanced"`

	// AddressesLookupPoolSize specifies how many idle connections to the DNS provider
	// are kept open. Use 0 to disable keeping any idle connections open.
	AddressesLookupPoolSize uint `yaml:"addresses_lookup_pool_size" category:"advanced"`

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

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

	// 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 SnappyCache struct {
	// contains filtered or unexported fields
}

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

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