proxy

Documentation

Index

• Variables
• func NewDefaultPreparedCache(size int) (proxycore.PreparedCache, error)
• func Run(ctx context.Context, args []string) int
• type Config
• type Proxy
  • func NewProxy(ctx context.Context, config Config) *Proxy
  • func (p *Proxy) Close() error
  • func (p *Proxy) Listen(address string) error
  • func (p *Proxy) ListenAndServe(address string) error
  • func (p *Proxy) OnEvent(event proxycore.Event)
  • func (p *Proxy) OutageDuration() time.Duration
  • func (p *Proxy) Ready() bool
  • func (p *Proxy) Serve() error
• type RetryDecision
  • func (r RetryDecision) String() string
• type RetryPolicy
  • func NewDefaultRetryPolicy() RetryPolicy

Variables

var ErrProxyClosed = errors.New("proxy closed")

Functions

func NewDefaultPreparedCache

func NewDefaultPreparedCache(size int) (proxycore.PreparedCache, error)

NewDefaultPreparedCache creates a new default prepared cache capping the max item capacity to `size`.

func Run

func Run(ctx context.Context, args []string) int

Run starts the proxy command. 'args' shouldn't include the executable (i.e. os.Args[1:]). It returns the exit code for the proxy.

Types

type Config

type Config struct {
	Version           primitive.ProtocolVersion
	MaxVersion        primitive.ProtocolVersion
	Auth              proxycore.Authenticator
	Resolver          proxycore.EndpointResolver
	ReconnectPolicy   proxycore.ReconnectPolicy
	RetryPolicy       RetryPolicy
	NumConns          int
	Logger            *zap.Logger
	HeartBeatInterval time.Duration
	IdleTimeout       time.Duration
	// PreparedCache a cache that stores prepared queries. If not set it uses the default implementation with a max
	// capacity of ~100MB.
	PreparedCache proxycore.PreparedCache
}

type Proxy

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

func NewProxy

func NewProxy(ctx context.Context, config Config) *Proxy

func (*Proxy) Close

func (p *Proxy) Close() error

func (*Proxy) Listen

func (p *Proxy) Listen(address string) error

func (*Proxy) ListenAndServe

func (p *Proxy) ListenAndServe(address string) error

func (*Proxy) OnEvent

func (p *Proxy) OnEvent(event proxycore.Event)

func (*Proxy) OutageDuration

func (p *Proxy) OutageDuration() time.Duration

func (*Proxy) Ready

func (p *Proxy) Ready() bool

func (*Proxy) Serve

func (p *Proxy) Serve() error

type RetryDecision

type RetryDecision int

RetryDecision is a type used for deciding what to do when a request has failed.

const (
	// RetrySame should be returned when a request should be retried on the same host.
	RetrySame RetryDecision = iota
	// RetryNext should be returned when a request should be retried on the next host according to the request's query
	// plan.
	RetryNext
	// ReturnError should be returned when a request's original error should be forwarded along to the client.
	ReturnError
)

func (RetryDecision) String

func (r RetryDecision) String() string

type RetryPolicy

type RetryPolicy interface {
	// OnReadTimeout handles the retry decision for a server-side read timeout error (Read_timeout = 0x1200).
	// This occurs when a replica read request times out during a read query.
	OnReadTimeout(msg *message.ReadTimeout, retryCount int) RetryDecision

	// OnWriteTimeout handles the retry decision for a server-side write timeout error (Write_timeout = 0x1100).
	// This occurs when a replica write request times out during a write query.
	OnWriteTimeout(msg *message.WriteTimeout, retryCount int) RetryDecision

	// OnUnavailable handles the retry decision for a server-side unavailable exception (Unavailable = 0x1000).
	// This occurs when a coordinator determines that there are not enough replicas to handle a query at the requested
	// consistency level.
	OnUnavailable(msg *message.Unavailable, retryCount int) RetryDecision

	// OnErrorResponse handles the retry decision for other potentially recoverable errors.
	// This can be called for the following error types: server error (ServerError = 0x0000),
	// overloaded (Overloaded = 0x1001), truncate error (Truncate_error = 0x1003), read failure (Read_failure = 0x1300),
	// and write failure (Write_failure = 0x1500).
	OnErrorResponse(msg message.Error, retryCount int) RetryDecision
}

RetryPolicy is an interface for defining retry behavior when a server-side error occurs.

func NewDefaultRetryPolicy

func NewDefaultRetryPolicy() RetryPolicy

NewDefaultRetryPolicy creates a new default retry policy. The default retry policy takes a conservative approach to retrying requests. In most cases it retries only once in cases where a retry is likely to succeed.