mirror of
https://github.com/kaspanet/kaspad.git
synced 2026-03-04 00:08:22 +00:00
6076309b3e
* [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-1142] Implement ping flows. * [NOD-1142] Add ping flows to startFlows. * [NOD-1142] Fix merge errors. * [NOD-1142] Fix a typo. * [NOD-1142] Add comments to exported functions. * [NOD-1142] Fix bad flow name. * [NOD-1142] Remove a redundant empty line. * [NOD-1142] Fix a typo. * [NOD-1142] Simplify for loop. * [NOD-1142] Rename HandlePing to HandleIncomingPings and StartPingLoop to StartSendingPings. * [NOD-1142] Fix no-longer-infinite loop. * [NOD-1142] Represent ping duration as time.Duration instead of an int64. * [NOD-1142] Rename HandleIncomingPings to ReceivePings and StartSendingPings to SendPings. * [NOD-1142] Move pingInterval to within SendPings. * [NOD-1142] Rephrase a comment.
112 lines
3.0 KiB
Go
112 lines
3.0 KiB
Go
package protocol
|
|
|
|
import (
|
|
"github.com/kaspanet/kaspad/blockdag"
|
|
"github.com/kaspanet/kaspad/netadapter"
|
|
routerpkg "github.com/kaspanet/kaspad/netadapter/router"
|
|
"github.com/kaspanet/kaspad/protocol/handlerelayblockrequests"
|
|
"github.com/kaspanet/kaspad/protocol/handlerelayinvs"
|
|
peerpkg "github.com/kaspanet/kaspad/protocol/peer"
|
|
"github.com/kaspanet/kaspad/protocol/ping"
|
|
"github.com/kaspanet/kaspad/wire"
|
|
"sync/atomic"
|
|
)
|
|
|
|
// Manager manages the p2p protocol
|
|
type Manager struct {
|
|
netAdapter *netadapter.NetAdapter
|
|
}
|
|
|
|
// NewManager creates a new instance of the p2p protocol manager
|
|
func NewManager(listeningAddrs []string, dag *blockdag.BlockDAG) (*Manager, error) {
|
|
netAdapter, err := netadapter.NewNetAdapter(listeningAddrs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
routerInitializer := newRouterInitializer(netAdapter, dag)
|
|
netAdapter.SetRouterInitializer(routerInitializer)
|
|
|
|
manager := Manager{
|
|
netAdapter: netAdapter,
|
|
}
|
|
return &manager, nil
|
|
}
|
|
|
|
// Start starts the p2p protocol
|
|
func (p *Manager) Start() error {
|
|
return p.netAdapter.Start()
|
|
}
|
|
|
|
// Stop stops the p2p protocol
|
|
func (p *Manager) Stop() error {
|
|
return p.netAdapter.Stop()
|
|
}
|
|
|
|
func newRouterInitializer(netAdapter *netadapter.NetAdapter, dag *blockdag.BlockDAG) netadapter.RouterInitializer {
|
|
return func() (*routerpkg.Router, error) {
|
|
router := routerpkg.NewRouter()
|
|
spawn(func() {
|
|
err := startFlows(netAdapter, router, dag)
|
|
if err != nil {
|
|
// TODO(libp2p) Ban peer
|
|
}
|
|
})
|
|
return router, nil
|
|
}
|
|
}
|
|
|
|
func startFlows(netAdapter *netadapter.NetAdapter, router *routerpkg.Router, dag *blockdag.BlockDAG) error {
|
|
stop := make(chan error)
|
|
stopped := uint32(0)
|
|
|
|
outgoingRoute := router.OutgoingRoute()
|
|
peer := new(peerpkg.Peer)
|
|
|
|
addFlow("HandleRelayInvs", router, []string{wire.CmdInvRelayBlock, wire.CmdBlock}, &stopped, stop,
|
|
func(incomingRoute *routerpkg.Route) error {
|
|
return handlerelayinvs.HandleRelayInvs(incomingRoute, outgoingRoute, peer, netAdapter, dag)
|
|
},
|
|
)
|
|
|
|
addFlow("HandleRelayBlockRequests", router, []string{wire.CmdGetRelayBlocks}, &stopped, stop,
|
|
func(incomingRoute *routerpkg.Route) error {
|
|
return handlerelayblockrequests.HandleRelayBlockRequests(incomingRoute, outgoingRoute, peer, dag)
|
|
},
|
|
)
|
|
|
|
addFlow("ReceivePings", router, []string{wire.CmdPing}, &stopped, stop,
|
|
func(incomingRoute *routerpkg.Route) error {
|
|
return ping.ReceivePings(incomingRoute, outgoingRoute)
|
|
},
|
|
)
|
|
|
|
addFlow("SendPings", router, []string{wire.CmdPong}, &stopped, stop,
|
|
func(incomingRoute *routerpkg.Route) error {
|
|
return ping.SendPings(incomingRoute, outgoingRoute, peer)
|
|
},
|
|
)
|
|
|
|
err := <-stop
|
|
return err
|
|
}
|
|
|
|
func addFlow(name string, router *routerpkg.Router, messageTypes []string, stopped *uint32,
|
|
stopChan chan error, flow func(route *routerpkg.Route) error) {
|
|
|
|
route, err := router.AddIncomingRoute(messageTypes)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
spawn(func() {
|
|
err := flow(route)
|
|
if err != nil {
|
|
log.Errorf("error from %s flow: %s", name, err)
|
|
}
|
|
if atomic.AddUint32(stopped, 1) == 1 {
|
|
stopChan <- err
|
|
}
|
|
})
|
|
}
|