Package peer contains interfaces pertaining to peers, peer lists, peer list updaters, and generally how to choose a peer for an outbound request.

The `` package tree provides the corresponding implementations.

Outbounds for some transports support selecting a different peer from a peer list for each individual request, for example load balancers and for pinning requests to a consistent peer. A peer instance models the host and port of a remote listening socket for a particular transport protocol, like HTTP and TChannel. For example, YARPC might have a TChannel peer instance to track connections to

Some transports, like HTTP and TChannel support peer selection on their outbounds. A `peer.Chooser` allows an outbound to obtain a peer for a given request and also manages the lifecycle of all components it uses. A peer chooser is typically also a `peer.List`, thus a `peer.ChooserList`.

Peer list updaters send `Update` message to a `peer.List` to add and remove peers. Peer list updaters have no specific interface, but must in practice implement `transport.Lifecycle` to bookend when they start and stop sending updates. A `peer.Binder` is a function that binds a `peer.List` to a peer list updater and returns the `transport.Lifecycle` of the peer list updater.

Not all `transport.Transport` instances support peer lists. To support peer selection, they must also implement `peer.Transport`, which has the `RetainPeer` and `ReleasePeer` methods, so a peer list can hold strong references to peers maintained by a transport, and receive notifications when peers start connecting, become available, become unavailable, and when their pending request count changes.

A peer list must provide a `peer.Subscriber` for each peer it retains or releases. The subscriber may be the peer list itself, though most peer lists contain an internal representation of each of their retained peers for book-keeping and sorting which benefits from receiving notifications for state changes directly.



This section is empty.


This section is empty.


This section is empty.


type Binder

type Binder func(List) transport.Lifecycle

Binder is a callback for peer.Bind that accepts a peer list and binds it to a peer list updater for the duration of the returned peer list updater. The peer list updater must implement the lifecycle interface, and start and stop updates over that lifecycle. The binder must not block on updating the list, because update may block until the peer list has started. The binder must return a peer list updater that will begin updating when it starts, and stop updating when it stops.

type Chooser

type Chooser interface {

	// Choose a Peer for the next call, block until a peer is available (or timeout)
	Choose(context.Context, *transport.Request) (peer Peer, onFinish func(error), err error)

Chooser is a collection of Peers. Outbounds request peers from the peer.Chooser to determine where to send requests. The chooser is responsible for managing the lifecycle of any retained peers.

type ChooserList

type ChooserList interface {

ChooserList is both a Chooser and a List, useful for expressing both capabilities of a single instance.

type ConnectionStatus

type ConnectionStatus int

ConnectionStatus maintains information about the Peer's connection state

const (
	// Unavailable indicates the Peer is unavailable for requests
	Unavailable ConnectionStatus = iota

	// Connecting indicates the Peer is in the process of connecting

	// Available indicates the Peer is available for requests

func (ConnectionStatus) String

func (i ConnectionStatus) String() string

type ErrChooseContextHasNoDeadline

type ErrChooseContextHasNoDeadline string

ErrChooseContextHasNoDeadline is returned when a context is sent to a peerlist with no deadline DEPRECATED use yarpcerrors api instead.

func (ErrChooseContextHasNoDeadline) Error

type ErrInvalidPeerConversion

type ErrInvalidPeerConversion struct {
	Peer         Peer
	ExpectedType string

ErrInvalidPeerConversion is called when a peer can't be properly converted

func (ErrInvalidPeerConversion) Error

func (e ErrInvalidPeerConversion) Error() string

type ErrInvalidPeerType

type ErrInvalidPeerType struct {
	ExpectedType   string
	PeerIdentifier Identifier

ErrInvalidPeerType is when a specfic peer type is required, but was not passed in

func (ErrInvalidPeerType) Error

func (e ErrInvalidPeerType) Error() string

type ErrInvalidTransportConversion

type ErrInvalidTransportConversion struct {
	Transport    Transport
	ExpectedType string

ErrInvalidTransportConversion is called when a transport can't be properly converted

func (ErrInvalidTransportConversion) Error

type ErrPeerAddAlreadyInList

type ErrPeerAddAlreadyInList string

ErrPeerAddAlreadyInList is returned to peer list updater if the peerlist is already tracking a peer for the added identifier

func (ErrPeerAddAlreadyInList) Error

func (e ErrPeerAddAlreadyInList) Error() string

type ErrPeerHasNoReferenceToSubscriber

type ErrPeerHasNoReferenceToSubscriber struct {
	PeerIdentifier Identifier
	PeerSubscriber Subscriber

ErrPeerHasNoReferenceToSubscriber is called when a Peer is expected to operate on a PeerSubscriber it has no reference to

func (ErrPeerHasNoReferenceToSubscriber) Error

type ErrPeerListAlreadyStarted

type ErrPeerListAlreadyStarted string

ErrPeerListAlreadyStarted represents a failure because Start() was already called on the peerlist.

func (ErrPeerListAlreadyStarted) Error

type ErrPeerListNotStarted

type ErrPeerListNotStarted string

ErrPeerListNotStarted represents a failure because Start() was not called on a peerlist or if Stop() was called.

func (ErrPeerListNotStarted) Error

func (e ErrPeerListNotStarted) Error() string

type ErrPeerRemoveNotInList

type ErrPeerRemoveNotInList string

ErrPeerRemoveNotInList is returned to peer list updater if the peerlist is not tracking the peer to remove for a given identifier

func (ErrPeerRemoveNotInList) Error

func (e ErrPeerRemoveNotInList) Error() string

type ErrTransportHasNoReferenceToPeer

type ErrTransportHasNoReferenceToPeer struct {
	TransportName  string
	PeerIdentifier string

ErrTransportHasNoReferenceToPeer is called when a transport is expected to operate on a Peer it has no reference to

func (ErrTransportHasNoReferenceToPeer) Error

type Identifier

type Identifier interface {
	Identifier() string

Identifier is able to uniquely identify a peer (e.g. hostport)

type List

type List interface {
	// Update performs the additions and removals to the Peer List
	Update(updates ListUpdates) error

List listens to adds and removes of Peers from a peer list updater. A Chooser will implement the List interface in order to receive updates to the list of Peers it is keeping track of.

type ListImplementation

type ListImplementation interface {

	Add(StatusPeer) Subscriber
	Remove(StatusPeer, Subscriber)
	// Choose must return an available peer under a list read lock, so must
	// not block.
	Choose(context.Context, *transport.Request) StatusPeer

ListImplementation is a collection of available peers, with its own subscribers for peer status change notifications. The available peer list encapsulates the logic for selecting from among available peers, whereas a ChooserList is responsible for retaining, releasing, and monitoring peer availability. Use "".List in conjunction with a ListImplementation to produce a "".List.

peerlist.List and ListImplementation compose well with sharding schemes the degenerate to returning the only available peer.

The peerlist.List calls Add, Remove, and Choose under a write lock so the implementation is free to perform mutations on its own data without locks.

Deprecated in favor of "".Implementation.

type ListUpdates

type ListUpdates struct {
	// Additions are the identifiers that should be added to the list
	Additions []Identifier

	// Removals are the identifiers that should be removed to the list
	Removals []Identifier

ListUpdates specifies the updates to be made to a List

type Peer

type Peer interface {

	// Tell the peer that a request is starting

	// Tell the peer that a request has finished

Peer captures a concrete peer implementation for a particular transport, providing both observability (Identifier and Status), along with load change notifications (StartRequest) (EndRequest). Transports reveal peers to peer lists, which in turn offer them to outbounds when they choose a peer. Having Start/End request messages allows the outbound to broadcast load changes to all subscribed load balancers. The peer should be created by a transport so we can maintain multiple references to the same peer (e.g., hostport).

type Status

type Status struct {
	// Current number of pending requests on this peer
	PendingRequestCount int

	// Current status of the Peer's connection
	ConnectionStatus ConnectionStatus

Status holds all the information about a peer's state that would be useful to Subscribers

func (Status) String

func (s Status) String() string

type StatusPeer

type StatusPeer interface {

	// Get the status of the Peer
	Status() Status

StatusPeer captures a concrete peer implementation for a particular transport, exposing its Identifier and Status. StatusPeer provides observability without mutability.

type Subscriber

type Subscriber interface {
	// The Peer Notifies the Subscriber when its status changes (e.g.
	// connections status, pending requests)
	// NotifyStatusChanged may call methods of the corresponding Peer,
	// particularly Status.
	// So, subscriber methods must not be called while holding a lock on the
	// Transport.

Subscriber listens to changes of a Peer over time.

type Transport

type Transport interface {
	// Get or create a Peer for the Subscriber
	RetainPeer(Identifier, Subscriber) (Peer, error)

	// Unallocate a peer from the Subscriber
	ReleasePeer(Identifier, Subscriber) error

Transport manages Peers across different Subscribers.

A Subscriber will request a Peer for a specific PeerIdentifier and the Transport has the ability to create a new Peer or return an existing one.

RetainPeer and ReleasePeer must not call or synchronize with goroutines that call methods of the Subscriber.


Path Synopsis
Package peertest is a generated GoMock package.
Package peertest is a generated GoMock package.