mirror of
https://github.com/kaspanet/kaspad.git
synced 2025-06-22 22:12:33 +00:00
05db135d23
* [NOD-1124] Move Router to the router package. * [NOD-1124] Implement SetOnRouteCapacityReachedHandler. * [NOD-1124] Use Routes instead of bare channels. * [NOD-1124] Fix merge errors. * [NOD-1124] Connect the Router to the Connection. * [NOD-1124] Fix merge errors. * [NOD-1124] Move some variables around. * [NOD-1124] Fix unreachable code. * [NOD-1124] Fix a variable name. * [NOD-1124] Rename AddRoute to AddIncomingRoute. * [NOD-1124] Rename SetRouter to Start. * [NOD-1124] Make AddIncomingRoute create a Route by itself. * [NOD-1124] Replace IncomingRoute with EnqueueIncomingMessage. * [NOD-1124] Make Enqueue and Dequeue return isOpen instead of err. * [NOD-1124] Remove writeDuringDisconnectLock. * [NOD-1124] In sendLoop, move outgoingRoute to outside the loop. * [NOD-1124] Start the connection loops only when Start is called. * [NOD-1124] Replace OnIDReceivedHandler with AssociateRouterID. * [NOD-1124] Add isOpen to Enqueue and Dequeue. * [NOD-1124] Protect errChan from writing during disconnect.
97 lines
2.7 KiB
Go
97 lines
2.7 KiB
Go
package router
|
|
|
|
import (
|
|
"github.com/kaspanet/kaspad/wire"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// OnRouteCapacityReachedHandler is a function that is to
|
|
// be called when one of the routes reaches capacity.
|
|
type OnRouteCapacityReachedHandler func()
|
|
|
|
// Router routes messages by type to their respective
|
|
// input channels
|
|
type Router struct {
|
|
incomingRoutes map[string]*Route
|
|
outgoingRoute *Route
|
|
|
|
onRouteCapacityReachedHandler OnRouteCapacityReachedHandler
|
|
}
|
|
|
|
// NewRouter creates a new empty router
|
|
func NewRouter() *Router {
|
|
router := Router{
|
|
incomingRoutes: make(map[string]*Route),
|
|
outgoingRoute: NewRoute(),
|
|
}
|
|
router.outgoingRoute.setOnCapacityReachedHandler(func() {
|
|
router.onRouteCapacityReachedHandler()
|
|
})
|
|
return &router
|
|
}
|
|
|
|
// SetOnRouteCapacityReachedHandler sets the onRouteCapacityReachedHandler
|
|
// function for this router
|
|
func (r *Router) SetOnRouteCapacityReachedHandler(onRouteCapacityReachedHandler OnRouteCapacityReachedHandler) {
|
|
r.onRouteCapacityReachedHandler = onRouteCapacityReachedHandler
|
|
}
|
|
|
|
// AddIncomingRoute registers the messages of types `messageTypes` to
|
|
// be routed to the given `route`
|
|
func (r *Router) AddIncomingRoute(messageTypes []string) (*Route, error) {
|
|
route := NewRoute()
|
|
for _, messageType := range messageTypes {
|
|
if _, ok := r.incomingRoutes[messageType]; ok {
|
|
return nil, errors.Errorf("a route for '%s' already exists", messageType)
|
|
}
|
|
r.incomingRoutes[messageType] = route
|
|
}
|
|
route.setOnCapacityReachedHandler(func() {
|
|
r.onRouteCapacityReachedHandler()
|
|
})
|
|
return route, nil
|
|
}
|
|
|
|
// RemoveRoute unregisters the messages of types `messageTypes` from
|
|
// the router
|
|
func (r *Router) RemoveRoute(messageTypes []string) error {
|
|
for _, messageType := range messageTypes {
|
|
if _, ok := r.incomingRoutes[messageType]; !ok {
|
|
return errors.Errorf("a route for '%s' does not exist", messageType)
|
|
}
|
|
delete(r.incomingRoutes, messageType)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// EnqueueIncomingMessage enqueues the given message to the
|
|
// appropriate route
|
|
func (r *Router) EnqueueIncomingMessage(message wire.Message) (isOpen bool, err error) {
|
|
route, ok := r.incomingRoutes[message.Command()]
|
|
if !ok {
|
|
return false, errors.Errorf("a route for '%s' does not exist", message.Command())
|
|
}
|
|
return route.Enqueue(message), nil
|
|
}
|
|
|
|
// OutgoingRoute returns the outgoing route
|
|
func (r *Router) OutgoingRoute() *Route {
|
|
return r.outgoingRoute
|
|
}
|
|
|
|
// Close shuts down the router by closing all registered
|
|
// incoming routes and the outgoing route
|
|
func (r *Router) Close() error {
|
|
incomingRoutes := make(map[*Route]struct{})
|
|
for _, route := range r.incomingRoutes {
|
|
incomingRoutes[route] = struct{}{}
|
|
}
|
|
for route := range incomingRoutes {
|
|
err := route.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return r.outgoingRoute.Close()
|
|
}
|