rediscluster

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

type ClusterHandle struct {
	Handle  interface{}
	Address string
	N       int
}

type ConnHostPolicyEnum int8

type DefaultLogger struct{}

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

type Future = redis.Future

type LogClusterSlotsError struct {
	Conn  *redisconn.Connection // Connection which were used for CLUSTER SLOTS
	Error error                 // observed error
}

type LogContextClosed struct{ Error error }

type LogEvent interface {
	// contains filtered or unexported methods
}

type LogHostEvent struct {
	Conn  *redisconn.Connection // Connection which triggers event.
	Event redisconn.LogEvent
}

type LogSlotRangeError struct{}

type Logger interface {
	// Report will be called when some events happens during cluster's lifetime.
	// Default implementation just prints this information using standard log package.
	Report(c *Cluster, event LogEvent)
	// ReqStat is called after request receives it's answer with request/result information
	// and time spend to fulfill request.
	// Default implementation is no-op.
	ReqStat(c *Cluster, conn *redisconn.Connection, req Request, res interface{}, nanos int64)
}

type NoopLogger struct{}

type Opts struct {
	// HostOpts - per host options
	// Note that HostOpts.Handle will be overwritten to ClusterHandle{ cluster.opts.Handle, conn.address}
	HostOpts redisconn.Opts
	// ConnsPerHost - how many connections are established to each host
	// if ConnsPerHost < 1 then ConnsPerHost = 2
	ConnsPerHost int
	// ConnHostPolicy - either prefer to send to first connection until it is disconnected, or
	//					send to all connections in round robin maner.
	// default: ConnHostPreferFirst
	ConnHostPolicy ConnHostPolicyEnum
	// Handle is returned with Cluster.Handle()
	// Also it is part of per-connection handle
	Handle interface{}
	// Name of a cluster.
	Name string
	// Check interval - default cluster configuration reloading interval
	// default: 5 seconds, min: 100 millisecond, max: 10 minutes
	// Note, that MOVE and ASK redis errors will force configuration reloading,
	// therefore there is not need to make it very frequent.
	CheckInterval time.Duration
	// MovedRetries - follow MOVED|ASK redirections this number of times
	// default: 3, min: 1, max: 10
	MovedRetries int
	// WaitToMigrate - wait this time if not all transaction keys were migrated
	// from one shard to another and then repeat transaction.
	// default: 20 millisecond, min: 100 microseconds, max: 100 milliseconds
	WaitToMigrate time.Duration
	// Logger used for logging cluster events and account request stats
	Logger Logger

	// RoundRobinSeed - used to choose between master and replica.
	RoundRobinSeed RoundRobinSeed
	// LatencyOrientedRR - when MasterAndSlaves is used, prefer hosts with lower latency
	LatencyOrientedRR bool
}

type PolicyMan struct {
	*Cluster
	// Policy is default policy for Send and SendMany
	Policy ReplicaPolicyEnum
}

type ReplicaPolicyEnum int8

type Request = redis.Request

type RoundRobinSeed interface {
	// Current returns "deterministic random" value used for choosing replica.
	Current() uint32
}

type Scanner struct {
	redis.ScannerBase
	// contains filtered or unexported fields
}

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