roxyresolver

type ATCTarget struct {
	ServiceName    string
	ShardNumber    uint32
	HasShardNumber bool
	UniqueID       string
	Location       string
	ServerName     string
	Balancer       BalancerType
	CPS            float64
}

type BalancerType uint8

type DNSTarget struct {
	ResolverAddr     *net.TCPAddr
	Host             string
	Port             string
	ServerName       string
	Balancer         BalancerType
	PollInterval     time.Duration
	CooldownInterval time.Duration
}

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

type EtcdTarget struct {
	Path       string
	Port       string
	ServerName string
	Balancer   BalancerType
}

type Event struct {
	// Type is the type of event, i.e. which data has changed.
	Type EventType

	// Err is the global error.
	//
	// Valid for: ErrorEvent.
	Err error

	// Key is the unique identifier for this address.
	//
	// Valid for: UpdateEvent, DeleteEvent, BadDataEvent, StatusChangeEvent.
	Key string

	// Data is the resolved address data.
	//
	// Valid for: UpdateEvent, StatusChangeEvent.
	Data Resolved

	// ServiceConfigJSON is the new gRPC service config.
	//
	// Valid for: NewServiceConfigEvent.
	ServiceConfigJSON string
}

type EventType uint8

type IPTarget struct {
	Addrs      []*net.TCPAddr
	ServerName string
	Balancer   BalancerType
}

type NodeDeletedError struct {
	Path string
}

type Options struct {
	// Context is the context within which the resolver runs.  If this
	// context is cancelled or reaches its deadline, the resolver will
	// stop.
	//
	// This field is mandatory.
	Context context.Context

	// Random is the source of randomness for balancer algorithms that need
	// one.
	//
	// If provided, it MUST be thread-safe; see the syncrand package for
	// more information.  If nil, the syncrand.Global() instance will be
	// used.
	Random *rand.Rand

	// Target is the resolve target.  The target's Scheme field determines
	// which Resolver implementation will be used.
	//
	// This field is mandatory.
	Target Target

	// IsTLS should be set to true iff the consumer of the resolved
	// addresses will be using TLS to communicate with them.  It is used
	// for automatic port guessing.
	IsTLS bool
}

type PollingResolveFunc func() ([]Resolved, error)

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

type PollingResolverOptions struct {
	// Context is the context within which the resolver runs.  If this
	// context is cancelled or reaches its deadline, the resolver will
	// stop.
	//
	// This field is mandatory.
	Context context.Context

	// Random is the source of randomness for balancer algorithms that need
	// one.
	//
	// If provided, it MUST be thread-safe; see the syncrand package for
	// more information.  If nil, the syncrand.Global() instance will be
	// used.
	Random *rand.Rand

	// PollInterval is the interval between automatic calls to ResolveFunc.
	// If zero, DefaultPollInterval is used.  If negative, MaxPollInterval
	// is used.
	PollInterval time.Duration

	// CooldownInterval is the minimum interval between calls to
	// ResolveFunc, whether automatic or triggered by ResolveNow.  If zero,
	// DefaultCooldownInterval is used.  If negative, the final value of
	// PollInterval is used.
	CooldownInterval time.Duration

	// Balancer selects which load balancer algorithm to use.
	Balancer BalancerType

	// ResolveFunc will be called periodically to resolve addresses.
	//
	// This field is mandatory.
	ResolveFunc PollingResolveFunc

	// ClientConn is a gRPC ClientConn that will receive state updates.
	ClientConn resolver.ClientConn

	// ServiceConfigJSON is the gRPC Service Config which will be provided
	// to ClientConn on each state update.
	ServiceConfigJSON string
}

type ResolveError struct {
	UniqueID string
	Err      error
}

type Resolved struct {
	// UniqueID is a stable unique identifier for this server.
	UniqueID string

	// Location is a string denoting the geographic location of this server.
	//
	// This field is only set by the ATC resolver.
	Location string

	// ServerName is either the empty string or the recommended value of
	// the "crypto/tls".(*Config).ServerName field.
	ServerName string

	// SRVPriority is the priority field of this SRV record.
	//
	// This field is only set by the SRV resolver.
	SRVPriority uint16

	// SRVWeight is the weight field of this SRV record.
	//
	// This field is only set by the SRV resolver.
	SRVWeight uint16

	// ShardNumber is the shard ID number.
	//
	// This field is only set by some resolvers.
	ShardNumber uint32

	// Weight is the proportional weight for this server.
	//
	// This field is only set by some resolvers.
	Weight float32

	// HasSRV is true if both SRVPriority and SRVWeight are set.
	HasSRV bool

	// HasShardNumber is true if ShardNumber is set.
	HasShardNumber bool

	// HasWeight is true if Weight is set.
	HasWeight bool

	// Err is the error encountered while resolving this server's address.
	Err error

	// Addr is the address of this server.
	Addr net.Addr

	// Address is the address of this server, in gRPC format.
	Address resolver.Address

	// Dynamic points to mutable, mutex-protected data associated with this
	// server.  Two Resolved addresses can share the same *Dynamic if they
	// point to the same server (e.g. have the same IP address).
	Dynamic *Dynamic
}

type ResolvedList []Resolved

type Resolver interface {
	// Err returns any errors encountered since the last call to Err or
	// ResolveAll.
	Err() error

	// ResolveAll returns all resolved addresses, plus any errors
	// encountered since the last call to Err or ResolveAll.
	ResolveAll() ([]Resolved, error)

	// Resolve returns the resolved address of a healthy backend, if one is
	// available, or else returns the error that prevented it from doing
	// so.
	Resolve() (Resolved, error)

	// Update changes the status of a server.
	Update(opts UpdateOptions)

	// Watch registers a WatchFunc.  The WatchFunc will be called
	// immediately with synthetic events for each resolved address
	// currently known, plus it will be called whenever the Resolver's
	// state changes.
	Watch(WatchFunc) WatchID

	// CancelWatch cancels a previous call to Watch.
	CancelWatch(WatchID)

	// ResolveNow requests that the resolver issue a re-resolve poll ASAP,
	// if that makes sense for the particular Resolver implementation.
	ResolveNow(resolver.ResolveNowOptions)

	// Close stops the resolver and frees all resources.
	Close()
}

type SRVTarget struct {
	ResolverAddr     *net.TCPAddr
	Domain           string
	Service          string
	ServerName       string
	Balancer         BalancerType
	PollInterval     time.Duration
	CooldownInterval time.Duration
}

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

type StaticResolverOptions struct {
	// Records lists the Resolved addresses for this resolver to return.
	Records []Resolved

	// Random is the source of randomness for balancer algorithms that need
	// one.
	//
	// If provided, it MUST be thread-safe; see the syncrand package for
	// more information.  If nil, the syncrand.Global() instance will be
	// used.
	Random *rand.Rand

	// Balancer selects which load balancer algorithm to use.
	Balancer BalancerType

	// ClientConn is a gRPC ClientConn that will receive state updates.
	ClientConn resolver.ClientConn

	// ServiceConfigJSON is the gRPC Service Config which will be provided
	// to ClientConn on each state update.
	ServiceConfigJSON string
}

type StatusError struct {
	Status membership.ServerSetStatus
}

type Target struct {
	// Scheme indicates which Resolver implementation to use.
	//
	// If not specified, "dns" is assumed.
	Scheme string

	// Authority provides information about which server to query to do the
	// resolving.
	//
	// Most schemes do not permit the Authority field to be specified.
	Authority string

	// Endpoint provides information about which name to resolve.
	//
	// This field is mandatory.
	Endpoint string

	// Query is a collection of key-value mappings.
	Query url.Values

	// ServerName is the suggested value for the
	// "crypto/tls".(*Config).ServerName field.
	//
	// It is filled in by Parse, FromGRPCTarget, or PostProcess.
	ServerName string

	// HasSlash is true if the string representation was originally of the
	// form "scheme://authority/endpoint?query", rather than
	// "scheme:endpoint?query".
	//
	// It is a Scheme-specific hint to PostProcess that a leading slash
	// before Endpoint can be inferred if necessary.
	HasSlash bool
}

type UnixTarget struct {
	Addr       *net.UnixAddr
	IsAbstract bool
	ServerName string
	Balancer   BalancerType
}

type UpdateOptions struct {
	// Addr is the address of the server to act upon.
	Addr net.Addr

	// HasHealthy is true if Healthy has a value.
	HasHealthy bool

	// Healthy is true if the server is ready to serve, false if it is not.
	Healthy bool
}

type WatchFunc func([]Event)

type WatchID uint64

type WatchingResolveFunc func(ctx context.Context, wg *sync.WaitGroup, backoff expbackoff.ExpBackoff) (<-chan []Event, error)

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

type WatchingResolverOptions struct {
	// Context is the context within which the resolver runs.  If this
	// context is cancelled or reaches its deadline, the resolver will
	// stop.
	//
	// This field is mandatory.
	Context context.Context

	// Random is the source of randomness for balancer algorithms that need
	// one.
	//
	// If provided, it MUST be thread-safe; see the syncrand package for
	// more information.  If nil, the syncrand.Global() instance will be
	// used.
	Random *rand.Rand

	// Balancer selects which load balancer algorithm to use.
	Balancer BalancerType

	// ResolveFunc will be called as needed to (re)start the event stream.
	//
	// This field is mandatory.
	ResolveFunc WatchingResolveFunc

	// ClientConn is a gRPC ClientConn that will receive state updates.
	ClientConn resolver.ClientConn

	// ServiceConfigJSON is the gRPC Service Config which will be provided
	// to ClientConn on each state update.
	ServiceConfigJSON string
}

type ZKTarget struct {
	Path       string
	Port       string
	ServerName string
	Balancer   BalancerType
}