cache

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

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

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

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

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

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

type RedisClientItf interface {
	// Get gets the value from redis in []byte form.
	Get(ctx context.Context, key string) ([]byte, error)
	// SetEX sets the value to a key with timeout in seconds.
	SetEX(ctx context.Context, key string, seconds int64, value string) error
	// SetNX sets a value to a key with specified timeouts.
	// SetNX returns false if the key exists.
	SetNX(ctx context.Context, key string, seconds int64, value string) (bool, error)
	// Exists checks whether the key exists in redis.
	Exists(ctx context.Context, key string) (bool, error)
	// Expire sets the TTL of a key to specified value in seconds.
	Expire(ctx context.Context, key string, seconds int64) (bool, error)
	// TTL gets the time to live of a key / expiry time.
	TTL(ctx context.Context, key string) (int64, error)
	// HGet gets the value of a hash field.
	HGet(ctx context.Context, key, field string) ([]byte, error)
	// HExists determines if a hash field exists.
	HExists(ctx context.Context, key, field string) (bool, error)
	// HSet sets the string value of a hash field.
	HSet(ctx context.Context, key, field, value string) (bool, error)
	// Del deletes a key.
	Del(ctx context.Context, key ...interface{}) (int64, error)
	// Close closes the client, releasing any open resources.
	Close()
}

type RedisConfiguration struct {
	// IdleConnectionLimit describes maximum idle connection before it closed.
	IdleConnectionLimit int64
	// OpenConnectionLimit describes maximum open connection can be opened.
	OpenConnectionLimit int64
	// WaitOpenConnection describes if operation should wait
	// for open connection to do operation.
	WaitOpenConnection bool
	// Addresses list of available addresses for cluster connection.
	Addresses []string
	// Enables read-only commands on slave nodes.
	ReadOnly bool
	// Allows routing read-only commands to the closest master or slave node.
	// It automatically enables ReadOnly.
	RouteByLatency bool
	// Allows routing read-only commands to the random master or slave node.
	// It automatically enables ReadOnly.
	RouteRandomly bool
	// MaxRetries describes the maximum retry if command fails.
	// Too much retry will prevent other command from being executed.
	MaxRetries int64
	// DialTimeout is in seconds.
	DialTimeout int64
	// MaxConnAge is in seconds.
	MaxConnAge int64
	// IdleTimeout is in seconds.
	IdleTimeout int64
	// MinIdleConnection describes the minimum open idle connection to be keep at all time.
	MinIdleConnection int64
}

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

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

type RistrettoClientItf interface {
	// Get returns the value (if any) and a boolean representing whether the value was found or not.
	Get(ctx context.Context, key string) (res interface{}, exists bool)
	// Set attempts to add the key-value item to the cache.
	// If it returns false, then the Set was dropped and the key-value item isn't added to the cache.
	// If it returns true, there's still a chance it could be dropped by the policy
	// if its determined that the key-value item isn't worth keeping,
	// but otherwise the item will be added and other items will be evicted in order to make room.
	Set(ctx context.Context, key string, value interface{}) bool
	// SetEX works like Set but adds a key-value pair to the cache
	// that will expire after the specified TTL (time to live) has passed.
	// A zero value means the value never expires, which is identical to calling Set.
	// A negative value is a no-op and the value is discarded.
	SetEX(ctx context.Context, key string, value interface{}, TTL time.Duration) bool
	// Del deletes the key-value item from the cache if it exists.
	Del(ctx context.Context, key string)
	// Clear empties the cache store and zeroes all policy counters.
	Clear(ctx context.Context)
	// Close stops all goroutines and closes all channels.
	Close()
}

type RistrettoConfiguration struct {
	// NumCounters determines the number of counters (keys) to keep that hold
	// access frequency information. It's generally a good idea to have more
	// counters than the max cache capacity, as this will improve eviction
	// accuracy and subsequent hit ratios.
	//
	// For example, if you expect your cache to hold 1,000,000 items when full,
	// NumCounters should be 10,000,000 (10x). Each counter takes up 4 bits, so
	// keeping 10,000,000 counters would require 5MB of memory.
	NumCounters int64
	// MaxCost can be considered as the cache capacity, in whatever units you
	// choose to use.
	//
	// For example, if you want the cache to have a max capacity of 100MB, you
	// would set MaxCost to 100,000,000 and pass an item's number of bytes as
	// the `cost` parameter for calls to Set. If new items are accepted, the
	// eviction process will take care of making room for the new item and not
	// overflowing the MaxCost value.
	MaxCost int64
	// BufferItems determines the size of Get buffers.
	//
	// Unless you have a rare use case, using `64` as the BufferItems value
	// results in good performance.
	BufferItems int64
	// Metrics determines whether cache statistics are kept during the cache's
	// lifetime. There *is* some overhead to keeping statistics, so you should
	// only set this flag to true when testing or throughput performance isn't a
	// major factor.
	Metrics bool
}