routing

Documentation

Index

• type ErrNodeNotFound
  • func NewErrNodeNotFound(peerID peer.ID) ErrNodeNotFound
  • func (e ErrNodeNotFound) Error() string
• type NodeInfoProvider
  • func NewNodeInfoProvider(params NodeInfoProviderParams) *NodeInfoProvider
  • func (n *NodeInfoProvider) GetNodeInfo(ctx context.Context) models.NodeInfo
  • func (n *NodeInfoProvider) RegisterComputeInfoProvider(provider models.ComputeNodeInfoProvider)
• type NodeInfoProviderParams
• type NodeInfoPublisher
  • func NewNodeInfoPublisher(params NodeInfoPublisherParams) *NodeInfoPublisher
  • func (n *NodeInfoPublisher) Publish(ctx context.Context) error
  • func (n *NodeInfoPublisher) Stop(ctx context.Context)
• type NodeInfoPublisherIntervalConfig
  • func (n NodeInfoPublisherIntervalConfig) IsEagerPublishEnabled() bool
  • func (n NodeInfoPublisherIntervalConfig) IsZero() bool
• type NodeInfoPublisherParams
• type NodeInfoStore

Types

type ErrNodeNotFound

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

ErrNodeNotFound is returned when nodeInfo was not found for a requested peer id

func NewErrNodeNotFound

func NewErrNodeNotFound(peerID peer.ID) ErrNodeNotFound

func (ErrNodeNotFound) Error

func (e ErrNodeNotFound) Error() string

type NodeInfoProvider

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

func NewNodeInfoProvider

func NewNodeInfoProvider(params NodeInfoProviderParams) *NodeInfoProvider

func (*NodeInfoProvider) GetNodeInfo

func (n *NodeInfoProvider) GetNodeInfo(ctx context.Context) models.NodeInfo

func (*NodeInfoProvider) RegisterComputeInfoProvider

func (n *NodeInfoProvider) RegisterComputeInfoProvider(provider models.ComputeNodeInfoProvider)

RegisterComputeInfoProvider registers a compute info provider with the node info provider.

type NodeInfoProviderParams

type NodeInfoProviderParams struct {
	Host                host.Host
	IdentityService     identify.IDService
	Labels              map[string]string
	ComputeInfoProvider models.ComputeNodeInfoProvider
	BacalhauVersion     models.BuildVersionInfo
}

type NodeInfoPublisher

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

func NewNodeInfoPublisher

func NewNodeInfoPublisher(params NodeInfoPublisherParams) *NodeInfoPublisher

func (*NodeInfoPublisher) Publish

func (n *NodeInfoPublisher) Publish(ctx context.Context) error

Publish publishes the node info to the pubsub topic manually and won't wait for the background task to do it.

func (*NodeInfoPublisher) Stop

func (n *NodeInfoPublisher) Stop(ctx context.Context)

Stop stops the background task that publishes the node info periodically

type NodeInfoPublisherIntervalConfig

type NodeInfoPublisherIntervalConfig struct {
	// Interval is the interval between publishing node info
	Interval time.Duration

	// During node startup, we can publish node info more frequently to speed up the discovery process.
	// EagerPublishInterval is the interval between publishing node info during startup.
	EagerPublishInterval time.Duration
	// EagerPublishDuration is the duration of the eager publish period. After this period, the node will publish node info
	// with the standard interval.
	EagerPublishDuration time.Duration
}

func (NodeInfoPublisherIntervalConfig) IsEagerPublishEnabled

func (n NodeInfoPublisherIntervalConfig) IsEagerPublishEnabled() bool

IsEagerPublishEnabled returns true if eager publish is enabled

func (NodeInfoPublisherIntervalConfig) IsZero

func (n NodeInfoPublisherIntervalConfig) IsZero() bool

IsZero returns true if the interval config is zero

type NodeInfoPublisherParams

type NodeInfoPublisherParams struct {
	PubSub           pubsub.Publisher[models.NodeInfo]
	NodeInfoProvider models.NodeInfoProvider
	IntervalConfig   NodeInfoPublisherIntervalConfig
}

type NodeInfoStore

type NodeInfoStore interface {
	libp2p_routing.PeerRouting
	// Add adds a node info to the repo.
	Add(ctx context.Context, nodeInfo models.NodeInfo) error
	// Get returns the node info for the given peer ID.
	Get(ctx context.Context, peerID peer.ID) (models.NodeInfo, error)
	// List returns a list of nodes
	List(ctx context.Context) ([]models.NodeInfo, error)
	// ListForEngine returns a list of nodes that support the given engine.
	ListForEngine(ctx context.Context, engine string) ([]models.NodeInfo, error)
	// Delete deletes a node info from the repo.
	Delete(ctx context.Context, peerID peer.ID) error
}