tracker

Documentation

Index

• type DiskTracker
• type ResourceTracker
  • func NewResourceTracker(reg prometheus.Registerer, resources resource.User, factory meter.Factory, ...) (ResourceTracker, error)
• type Targeter
  • func NewTargeter(logger logging.Logger, config *TargeterConfig, vdrs validators.Manager, ...) Targeter
• type TargeterConfig
• type Tracker

Types

type DiskTracker

type DiskTracker interface {
	Tracker
	AvailableDiskBytes() uint64
}

type ResourceTracker

type ResourceTracker interface {
	CPUTracker() Tracker
	DiskTracker() DiskTracker
	// Registers that the given node started processing at the given time.
	StartProcessing(ids.NodeID, time.Time)
	// Registers that the given node stopped processing at the given time.
	StopProcessing(ids.NodeID, time.Time)
}

ResourceTracker is an interface for tracking peers' usage of resources

func NewResourceTracker

func NewResourceTracker(
	reg prometheus.Registerer,
	resources resource.User,
	factory meter.Factory,
	halflife time.Duration,
) (ResourceTracker, error)

type Targeter

type Targeter interface {
	// Returns the target usage of the given node.
	TargetUsage(nodeID ids.NodeID) float64
}

func NewTargeter

func NewTargeter(
	logger logging.Logger,
	config *TargeterConfig,
	vdrs validators.Manager,
	tracker Tracker,
) Targeter

type TargeterConfig

type TargeterConfig struct {
	// VdrAlloc is the amount of the resource to split over validators, weighted
	// by stake.
	VdrAlloc float64 `json:"vdrAlloc"`

	// MaxNonVdrUsage is the amount of the resource which, if utilized, will
	// result in allocations being based only on the stake weighted allocation.
	MaxNonVdrUsage float64 `json:"maxNonVdrUsage"`

	// MaxNonVdrNodeUsage is the amount of the resource to allocate to a node
	// before adding the stake weighted allocation.
	MaxNonVdrNodeUsage float64 `json:"maxNonVdrNodeUsage"`
}

type Tracker

type Tracker interface {
	// Returns the current usage for the given node.
	Usage(nodeID ids.NodeID, now time.Time) float64
	// Returns the current usage by all nodes.
	TotalUsage() float64
	// Returns the duration between [now] and when the usage of [nodeID] reaches
	// [value], assuming that the node uses no more resources.
	// If the node's usage isn't known, or is already <= [value], returns the
	// zero duration.
	TimeUntilUsage(nodeID ids.NodeID, now time.Time, value float64) time.Duration
}