redisutil

type ConnectionTester interface {
	// TestConnection returns an error if c is not healthy.  lastUsed is the
	// time when the connection was returned to the pool.  c must not be nil.
	TestConnection(ctx context.Context, c redis.Conn, lastUsed time.Time) (err error)
}

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

type DefaultDialerConfig struct {
	// Addr is the address of the Redis server.  It must not be nil and must be
	// valid.
	Addr *netutil.HostPort

	// Resolver is used to resolve the hostname.  If nil, a default pure-Go
	// [net.Resolver] is used.
	//
	// TODO(a.garipov):  Add the [netutil.Resolver] interface?
	Resolver *net.Resolver

	// Network is the network to dial.  If empty, "ip" is used.  If not empty,
	// must be one of:
	//   - "ip"
	//   - "ip4"
	//   - "ip6"
	Network string

	// DBIndex is the index of Redis database to use.  Zero is the default
	// index.
	DBIndex uint8
}

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

type DefaultPoolConfig struct {
	// Logger is used to log the operation of the Redis pool.  If nil,
	// [slog.Default] is used.
	Logger *slog.Logger

	// ConnectionTester checks the health of an idle connection before the
	// connection is used again.  If nil, no checks are performed.
	ConnectionTester ConnectionTester

	// Dialer is used to create and configure connections.  It should not be
	// nil.
	Dialer Dialer

	// Metrics is used for the collection of the Redis pool statistics.  If nil,
	// [EmptyPoolMetrics] is used.
	Metrics PoolMetrics

	// IdleTimeout is the time after remaining, idle connection will be closed.
	// If the value is zero, then idle connections are not closed.  Applications
	// should set the timeout to a value less than the server's timeout.
	// IdleTimeout should not be negative.
	IdleTimeout time.Duration

	// MaxConnLifetime is the total duration of any connection's lifetime.  If
	// the value is zero then the pool does not close connections based on age.
	// MaxConnLifetime should not be negative.
	MaxConnLifetime time.Duration

	// MaxActive is the maximum number of connections allocated by the Redis
	// connection-pool at a given time.  When zero, there is no limit on the
	// number of connections in the pool.  MaxActive should not be negative.
	MaxActive int

	// MaxIdle is the maximum number of idle connections in the pool.  When
	// zero, there is no limit.  MaxIdle should not be negative.
	MaxIdle int

	// Wait, if true, makes the pool wait for a connection once the
	// [DefaultPoolConfig.MaxActive] limit is reached.
	Wait bool
}

type Dialer interface {
	// DialContext creates and configures a connection with the given context.
	// c must not be in a special state (subscribed to pubsub channel,
	// transaction started, etc.).
	//
	// See [redis.Pool.DialContext].
	DialContext(ctx context.Context) (c redis.Conn, err error)
}

type EmptyPoolMetrics struct{}

type Environment struct {
	// Host is the value of the REDIS_HOST environment variable, which is used
	// together with Port to create the address to connect to.  The default
	// value is "localhost".
	Host string `env:"REDIS_HOST" envDefault:"localhost"`

	// Network is the value of the REDIS_NETWORK environment variable, which
	// shows what kind of IP protocol version to use:
	//   - "ip" means both;
	//   - "ip4" means IPv4 only;
	//   - "ip6" means IPv6 only.
	// All other values are invalid.  The default value is "ip4".
	Network string `env:"REDIS_NETWORK" envDefault:"ip4"`

	// IdleTimeout is the value of the REDIS_IDLE_TIMEOUT environment variable,
	// which is used to set the idle timeout for connections in a pool; see
	// [DefaultPoolConfig.IdleTimeout].  The duration should be in the
	// [time.Duration] format.  The default value is "5m".
	IdleTimeout timeutil.Duration `env:"REDIS_IDLE_TIMEOUT" envDefault:"5m"`

	// MaxConnLifetime is the value of the REDIS_MAX_CONN_LIFETIME environment
	// variable, which is used to set the maximum total duration of connections
	// in a pool; see [DefaultPoolConfig.MaxConnLifetime].  The duration should
	// be in the [time.Duration] format.  The default value is "0s", which means
	// that the lifetime is not limited.
	MaxConnLifetime timeutil.Duration `env:"REDIS_MAX_CONN_LIFETIME" envDefault:"0s"`

	// MaxActive is the value of the REDIS_MAX_ACTIVE environment variable,
	// which is used to set the maximum number of connections in a pool; see
	// [DefaultPoolConfig.MaxActive].  The default value is 100.
	MaxActive int `env:"REDIS_MAX_ACTIVE" envDefault:"100"`

	// MaxIdle is the value of the REDIS_MAX_IDLE environment variable, which is
	// used to set the maximum number of idle connections in a pool; see
	// [DefaultPoolConfig.MaxIdle].  The default value is 100.
	MaxIdle int `env:"REDIS_MAX_IDLE" envDefault:"100"`

	// Port is the value of the REDIS_PORT environment variable, which is used
	// together with HOST to create the address to connect to.  The default
	// value is 6379.
	Port uint16 `env:"REDIS_PORT" envDefault:"6379"`

	// DBIndex is the value of the REDIS_DB environment variable, denoting the
	// index of Redis database to use.  The default value is 0.
	DBIndex uint8 `env:"REDIS_DB" envDefault:"0"`

	// Wait is the value of the REDIS_WAIT environment variable, which selects
	// if the pool must wait for a connection once the MaxActive limit is
	// reached; see [DefaultPoolConfig.Wait].  The default is to wait.
	Wait bool `env:"REDIS_WAIT" envDefault:"1"`
}

type Pool interface {
	// Get returns a connection from the pool.  If the context expires before
	// the connection is complete, an error must be returned; any expiration on
	// the context must not affect the returned connection.  If the function
	// completes without error, then the application should close the returned
	// connection.
	Get(ctx context.Context) (c redis.Conn, err error)

	// Close must release the resources used by the pool.
	Close() (err error)
}

type PoolMetrics interface {
	// Update updates the total number of active connections and increments the
	// total number of errors if necessary.
	Update(ctx context.Context, s redis.PoolStats, err error)
}

type Role string

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

type RoleCheckerConfig struct {
	// Logger is used to log the operation of the checker.  If nil,
	// [slog.Default] is used.
	Logger *slog.Logger

	// Role is the required role.  If empty, [RoleMaster] is used; otherwise it
	// must be a valid Role.
	Role Role
}