router

Documentation

Index

• type ChainRouter
  • func (cr *ChainRouter) AddChain(chain handler.Handler)
  • func (cr *ChainRouter) Benched(chainID ids.ID, nodeID ids.NodeID)
  • func (cr *ChainRouter) Connected(nodeID ids.NodeID, nodeVersion *version.Application, subnetID ids.ID)
  • func (cr *ChainRouter) Disconnected(nodeID ids.NodeID)
  • func (cr *ChainRouter) HandleInbound(ctx context.Context, msg message.InboundMessage)
  • func (cr *ChainRouter) HealthCheck() (interface{}, error)
  • func (cr *ChainRouter) Initialize(nodeID ids.NodeID, log logging.Logger, timeoutManager timeout.Manager, ...) error
  • func (cr *ChainRouter) RegisterRequest(ctx context.Context, nodeID ids.NodeID, requestingChainID ids.ID, ...)
  • func (cr *ChainRouter) Shutdown()
  • func (cr *ChainRouter) Unbenched(chainID ids.ID, nodeID ids.NodeID)
• type ExternalHandler
• type HealthConfig
• type InboundHandler
• type InboundHandlerFunc
  • func (f InboundHandlerFunc) HandleInbound(ctx context.Context, msg message.InboundMessage)
• type InternalHandler
• type Router
  • func Trace(router Router, tracer trace.Tracer) Router

Types

type ChainRouter

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

ChainRouter routes incoming messages from the validator network to the consensus engines that the messages are intended for. Note that consensus engines are uniquely identified by the ID of the chain that they are working on.

func (*ChainRouter) AddChain

func (cr *ChainRouter) AddChain(chain handler.Handler)

AddChain registers the specified chain so that incoming messages can be routed to it

func (*ChainRouter) Benched

func (cr *ChainRouter) Benched(chainID ids.ID, nodeID ids.NodeID)

Benched routes an incoming notification that a validator was benched

func (*ChainRouter) Connected

func (cr *ChainRouter) Connected(nodeID ids.NodeID, nodeVersion *version.Application, subnetID ids.ID)

Connected routes an incoming notification that a validator was just connected

func (*ChainRouter) Disconnected

func (cr *ChainRouter) Disconnected(nodeID ids.NodeID)

Disconnected routes an incoming notification that a validator was connected

func (*ChainRouter) HandleInbound

func (cr *ChainRouter) HandleInbound(ctx context.Context, msg message.InboundMessage)

func (*ChainRouter) HealthCheck

func (cr *ChainRouter) HealthCheck() (interface{}, error)

HealthCheck returns results of router health checks. Returns: 1) Information about health check results 2) An error if the health check reports unhealthy

func (*ChainRouter) Initialize

func (cr *ChainRouter) Initialize(
	nodeID ids.NodeID,
	log logging.Logger,
	timeoutManager timeout.Manager,
	closeTimeout time.Duration,
	criticalChains ids.Set,
	whitelistedSubnets ids.Set,
	onFatal func(exitCode int),
	healthConfig HealthConfig,
	metricsNamespace string,
	metricsRegisterer prometheus.Registerer,
) error

Initialize the router.

When this router receives an incoming message, it cancels the timeout in [timeouts] associated with the request that caused the incoming message, if applicable.

func (*ChainRouter) RegisterRequest

func (cr *ChainRouter) RegisterRequest(
	ctx context.Context,
	nodeID ids.NodeID,
	requestingChainID ids.ID,
	respondingChainID ids.ID,
	requestID uint32,
	op message.Op,
	failedMsg message.InboundMessage,
)

RegisterRequest marks that we should expect to receive a reply for a request issued by [requestingChainID] from the given validator's [respondingChainID] and the reply should have the given requestID.

The type of message we expect is [op].

Every registered request must be cleared either by receiving a valid reply and passing it to the appropriate chain or by a timeout. This method registers a timeout that calls such methods if we don't get a reply in time.

func (*ChainRouter) Shutdown

func (cr *ChainRouter) Shutdown()

Shutdown shuts down this router

func (*ChainRouter) Unbenched

func (cr *ChainRouter) Unbenched(chainID ids.ID, nodeID ids.NodeID)

Unbenched routes an incoming notification that a validator was just unbenched

type ExternalHandler

type ExternalHandler interface {
	InboundHandler

	Connected(nodeID ids.NodeID, nodeVersion *version.Application, subnetID ids.ID)
	Disconnected(nodeID ids.NodeID)
}

ExternalHandler handles messages from external parties

type HealthConfig

type HealthConfig struct {
	// Reports unhealthy if we drop more than [MaxDropRate] of messages
	MaxDropRate float64 `json:"maxDropRate"`

	// Halflife of averager used to calculate the message drop rate
	// Must be > 0.
	// Larger value --> Drop rate affected less by recent messages
	MaxDropRateHalflife time.Duration `json:"maxDropRateHalflife"`

	// Reports unhealthy if more than this number of requests are outstanding.
	// Must be > 0
	MaxOutstandingRequests int `json:"maxOutstandingRequests"`

	// Reports unhealthy if there is a request outstanding for longer than this
	MaxOutstandingDuration time.Duration `json:"maxOutstandingDuration"`

	// Reports unhealthy if there is at least 1 outstanding not processed
	// before this mark
	MaxRunTimeRequests time.Duration `json:"maxRunTimeRequests"`
}

HealthConfig describes parameters for router health checks.

type InboundHandler

type InboundHandler interface {
	HandleInbound(context.Context, message.InboundMessage)
}

InboundHandler handles inbound messages

type InboundHandlerFunc

type InboundHandlerFunc func(context.Context, message.InboundMessage)

The ExternalRouterFunc type is an adapter to allow the use of ordinary functions as ExternalRouters. If f is a function with the appropriate signature, ExternalRouterFunc(f) is an ExternalRouter that calls f.

func (InboundHandlerFunc) HandleInbound

func (f InboundHandlerFunc) HandleInbound(ctx context.Context, msg message.InboundMessage)

type InternalHandler

type InternalHandler interface {
	benchlist.Benchable

	RegisterRequest(
		ctx context.Context,
		nodeID ids.NodeID,
		sourceChainID ids.ID,
		destinationChainID ids.ID,
		requestID uint32,
		op message.Op,
		failedMsg message.InboundMessage,
	)
}

InternalHandler deals with messages internal to this node

type Router

type Router interface {
	ExternalHandler
	InternalHandler

	Initialize(
		nodeID ids.NodeID,
		log logging.Logger,
		timeouts timeout.Manager,
		shutdownTimeout time.Duration,
		criticalChains ids.Set,
		whiteListedSubnets ids.Set,
		onFatal func(exitCode int),
		healthConfig HealthConfig,
		metricsNamespace string,
		metricsRegisterer prometheus.Registerer,
	) error
	Shutdown()
	AddChain(chain handler.Handler)
	health.Checker
}

Router routes consensus messages to the Handler of the consensus engine that the messages are intended for

func Trace

func Trace(router Router, tracer trace.Tracer) Router