peer

Documentation

Index

• type CRStatesPeersInfo
  • func (i *CRStatesPeersInfo) GetCrStates() map[tc.TrafficMonitorName]tc.CRStates
  • func (i *CRStatesPeersInfo) GetPeerAvailability(peer tc.TrafficMonitorName) bool
  • func (i *CRStatesPeersInfo) HasAvailablePeers() bool
• type CRStatesPeersThreadsafe
  • func NewCRStatesPeersThreadsafe(quorumMin int) CRStatesPeersThreadsafe
  • func (t *CRStatesPeersThreadsafe) GetCRStatesPeersInfo() CRStatesPeersInfo
  • func (t *CRStatesPeersThreadsafe) GetCrstates() map[tc.TrafficMonitorName]tc.CRStates
  • func (t *CRStatesPeersThreadsafe) GetPeerAvailability(peer tc.TrafficMonitorName) bool
  • func (t *CRStatesPeersThreadsafe) GetPeersOnline() map[tc.TrafficMonitorName]bool
  • func (t *CRStatesPeersThreadsafe) GetQueryTimes() map[tc.TrafficMonitorName]time.Time
  • func (t *CRStatesPeersThreadsafe) HasOptimisticQuorum() (bool, int, int, int)
  • func (t *CRStatesPeersThreadsafe) OptimisticQuorumEnabled() bool
  • func (t *CRStatesPeersThreadsafe) Set(result Result)
  • func (t *CRStatesPeersThreadsafe) SetPeers(newPeers map[tc.TrafficMonitorName]struct{})
  • func (t *CRStatesPeersThreadsafe) SetTimeout(timeout time.Duration)
• type CRStatesThreadsafe
  • func NewCRStatesThreadsafe() CRStatesThreadsafe
  • func (t *CRStatesThreadsafe) AddCache(cacheName tc.CacheName, available tc.IsAvailable)
  • func (t *CRStatesThreadsafe) DeleteCache(name tc.CacheName)
  • func (t *CRStatesThreadsafe) DeleteDeliveryService(name tc.DeliveryServiceName)
  • func (t *CRStatesThreadsafe) Get() tc.CRStates
  • func (t *CRStatesThreadsafe) GetCache(name tc.CacheName) (available tc.IsAvailable, ok bool)
  • func (t *CRStatesThreadsafe) GetCaches() map[tc.CacheName]tc.IsAvailable
  • func (t *CRStatesThreadsafe) GetDeliveryService(name tc.DeliveryServiceName) (ds tc.CRStatesDeliveryService, ok bool)
  • func (t *CRStatesThreadsafe) GetDeliveryServices() map[tc.DeliveryServiceName]tc.CRStatesDeliveryService
  • func (t *CRStatesThreadsafe) SetCache(cacheName tc.CacheName, available tc.IsAvailable)
  • func (t *CRStatesThreadsafe) SetDeliveryService(name tc.DeliveryServiceName, ds tc.CRStatesDeliveryService)
• type Handler
  • func NewHandler() Handler
  • func (handler Handler) Handle(id string, r io.Reader, format string, reqTime time.Duration, reqEnd time.Time, ...)
• type Result

Types

type CRStatesPeersInfo

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

func (*CRStatesPeersInfo) GetCrStates

func (i *CRStatesPeersInfo) GetCrStates() map[tc.TrafficMonitorName]tc.CRStates

func (*CRStatesPeersInfo) GetPeerAvailability

func (i *CRStatesPeersInfo) GetPeerAvailability(peer tc.TrafficMonitorName) bool

func (*CRStatesPeersInfo) HasAvailablePeers

func (i *CRStatesPeersInfo) HasAvailablePeers() bool

type CRStatesPeersThreadsafe

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

CRStatesPeersThreadsafe provides safe access for multiple goroutines to read a map of Traffic Monitor peers to their returned Crstates, with a single goroutine writer. This could be made lock-free, if the performance was necessary

func NewCRStatesPeersThreadsafe

func NewCRStatesPeersThreadsafe(quorumMin int) CRStatesPeersThreadsafe

NewCRStatesPeersThreadsafe creates a new CRStatesPeers object safe for multiple goroutine readers and a single writer.

func (*CRStatesPeersThreadsafe) GetCRStatesPeersInfo

func (t *CRStatesPeersThreadsafe) GetCRStatesPeersInfo() CRStatesPeersInfo

GetCRStatesPeersInfo returns a CRStatesPeersInfo which contains a copy of some internal fields of this CRStatesPeersThreadsafe. This all happens within a single, locked read transaction so that all fields are in sync with each other. This is to avoid making multiple read copies within the same goroutine for the same operation, which is very inefficient.

func (*CRStatesPeersThreadsafe) GetCrstates

func (t *CRStatesPeersThreadsafe) GetCrstates() map[tc.TrafficMonitorName]tc.CRStates

GetCrstates returns the internal Traffic Monitor peer Crstates data. This MUST NOT be modified.

func (*CRStatesPeersThreadsafe) GetPeerAvailability

func (t *CRStatesPeersThreadsafe) GetPeerAvailability(peer tc.TrafficMonitorName) bool

GetPeerAvailability returns the state of the given peer

func (*CRStatesPeersThreadsafe) GetPeersOnline

func (t *CRStatesPeersThreadsafe) GetPeersOnline() map[tc.TrafficMonitorName]bool

GetPeersOnline return a map of peers which are marked ONLINE in the latest CRConfig from Traffic Ops. This is NOT guaranteed to actually _contain_ all OFFLINE monitors returned by other functions, such as `GetPeerAvailability` and `GetQueryTimes`, but bool defaults to false, so the value of any key is guaranteed to be correct.

func (*CRStatesPeersThreadsafe) GetQueryTimes

func (t *CRStatesPeersThreadsafe) GetQueryTimes() map[tc.TrafficMonitorName]time.Time

GetQueryTimes returns the last query time of all peers

func (*CRStatesPeersThreadsafe) HasOptimisticQuorum

func (t *CRStatesPeersThreadsafe) HasOptimisticQuorum() (bool, int, int, int)

HasOptimisticQuorum returns true when the number of available peers is equal to or greater than the peer_optimistic_quorum_min setting.

func (*CRStatesPeersThreadsafe) OptimisticQuorumEnabled

func (t *CRStatesPeersThreadsafe) OptimisticQuorumEnabled() bool

OptimisticQuorumEnabled returns true when peer_optimistic_quorum_min is set to a value greater than zero and the number of peers is greater than 1. Optimistic quorum requires a minimum of three Traffic Monitors; every individual monitor requires at least two peers to prevent a split-brain scenario that would be caused by having a single peer. If a single peer was legal (i.e.: two Traffic Monitors), neither peer would know which peer is reachable, and consequently both would serve 503s. This would force all Traffic Routers to use only their last-known state until the peering is restored, despite the fact that one of the two Traffic Monitors could still be reachable. A future enhancement could employ a heuristic to enable two monitors to determine whether they are offline independently by combining peer connectivity state with a calculation around the number of caches that are reachable, which might also include a rate of change in cache health state.

func (*CRStatesPeersThreadsafe) Set

func (t *CRStatesPeersThreadsafe) Set(result Result)

Set sets the internal Traffic Monitor peer state and Crstates data. This MUST NOT be called by multiple goroutines.

func (*CRStatesPeersThreadsafe) SetPeers

func (t *CRStatesPeersThreadsafe) SetPeers(newPeers map[tc.TrafficMonitorName]struct{})

func (*CRStatesPeersThreadsafe) SetTimeout

func (t *CRStatesPeersThreadsafe) SetTimeout(timeout time.Duration)

type CRStatesThreadsafe

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

CRStatesThreadsafe provides safe access for multiple goroutines to read a single Crstates object, with a single goroutine writer. This could be made lock-free, if the performance was necessary TODO add separate locks for Caches and DeliveryService maps?

func NewCRStatesThreadsafe

func NewCRStatesThreadsafe() CRStatesThreadsafe

NewCRStatesThreadsafe creates a new CRStatesThreadsafe object safe for multiple goroutine readers and a single writer.

func (*CRStatesThreadsafe) AddCache

func (t *CRStatesThreadsafe) AddCache(cacheName tc.CacheName, available tc.IsAvailable)

AddCache adds the internal availability data for a particular cache.

func (*CRStatesThreadsafe) DeleteCache

func (t *CRStatesThreadsafe) DeleteCache(name tc.CacheName)

DeleteCache deletes the given cache from the internal data.

func (*CRStatesThreadsafe) DeleteDeliveryService

func (t *CRStatesThreadsafe) DeleteDeliveryService(name tc.DeliveryServiceName)

DeleteDeliveryService deletes the given delivery service from the internal data. This MUST NOT be called by multiple goroutines.

func (*CRStatesThreadsafe) Get

func (t *CRStatesThreadsafe) Get() tc.CRStates

Get returns the internal Crstates object for reading.

func (*CRStatesThreadsafe) GetCache

func (t *CRStatesThreadsafe) GetCache(name tc.CacheName) (available tc.IsAvailable, ok bool)

GetCache returns the availability data of the given cache. This does not mutate, and is thus safe for multiple goroutines to call.

func (*CRStatesThreadsafe) GetCaches

func (t *CRStatesThreadsafe) GetCaches() map[tc.CacheName]tc.IsAvailable

GetCaches returns the availability data of all caches. This does not mutate, and is thus safe for multiple goroutines to call.

func (*CRStatesThreadsafe) GetDeliveryService

func (t *CRStatesThreadsafe) GetDeliveryService(name tc.DeliveryServiceName) (ds tc.CRStatesDeliveryService, ok bool)

GetDeliveryService returns the availability data of the given delivery service. This does not mutate, and is thus safe for multiple goroutines to call.

func (*CRStatesThreadsafe) GetDeliveryServices

func (t *CRStatesThreadsafe) GetDeliveryServices() map[tc.DeliveryServiceName]tc.CRStatesDeliveryService

GetDeliveryServices returns the internal Crstates delivery services map for reading.

func (*CRStatesThreadsafe) SetCache

func (t *CRStatesThreadsafe) SetCache(cacheName tc.CacheName, available tc.IsAvailable)

SetCache sets the internal availability data for a particular cache. It does NOT set data if the cache doesn't already exist. By adding newly received caches with `AddCache`, this allows easily avoiding a race condition when an in-flight poller tries to set a cache which has been removed.

func (*CRStatesThreadsafe) SetDeliveryService

func (t *CRStatesThreadsafe) SetDeliveryService(name tc.DeliveryServiceName, ds tc.CRStatesDeliveryService)

SetDeliveryService sets the availability data for the given delivery service.

type Handler

type Handler struct {
	ResultChannel chan Result
}

Handler handles peer Traffic Monitor data, taking a raw reader, parsing the data, and passing a result object to the ResultChannel. This fulfills the common `Handler` interface.

func NewHandler

func NewHandler() Handler

NewHandler returns a new peer Handler.

func (Handler) Handle

func (handler Handler) Handle(id string, r io.Reader, format string, reqTime time.Duration, reqEnd time.Time, err error, pollID uint64, usingIPv4 bool, pollCtx interface{}, pollFinished chan<- uint64)

Handle handles a response from a polled Traffic Monitor peer, parsing the data and forwarding it to the ResultChannel.

type Result

type Result struct {
	ID           tc.TrafficMonitorName
	Available    bool
	Errors       []error
	PeerStates   tc.CRStates
	PollID       uint64
	PollFinished chan<- uint64
	Time         time.Time
}

Result contains the data parsed from polling a peer Traffic Monitor.