mirror of
https://github.com/kaspanet/kaspad.git
synced 2025-03-30 15:08:33 +00:00
d14809694f
* [NOD-1223] Delete unused files/packages. * [NOD-1223] Move signal and limits to the os package. * [NOD-1223] Put database and dbaccess into the db package. * [NOD-1223] Fold the logs package into the logger package. * [NOD-1223] Rename domainmessage to appmessage. * [NOD-1223] Rename to/from DomainMessage to AppMessage. * [NOD-1223] Move appmessage to the app packge. * [NOD-1223] Move protocol to the app packge. * [NOD-1223] Move the network package to the infrastructure packge. * [NOD-1223] Rename cmd to executables. * [NOD-1223] Fix go.doc in the logger package.
104 lines
2.5 KiB
Go
104 lines
2.5 KiB
Go
package grpcserver
|
|
|
|
import (
|
|
"io"
|
|
"time"
|
|
|
|
routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
"github.com/kaspanet/kaspad/infrastructure/logger"
|
|
|
|
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/server/grpcserver/protowire"
|
|
)
|
|
|
|
type grpcStream interface {
|
|
Send(*protowire.KaspadMessage) error
|
|
Recv() (*protowire.KaspadMessage, error)
|
|
}
|
|
|
|
func (c *gRPCConnection) connectionLoops() error {
|
|
errChan := make(chan error, 1) // buffered channel because one of the loops might try write after disconnect
|
|
|
|
spawn("gRPCConnection.receiveLoop", func() { errChan <- c.receiveLoop() })
|
|
spawn("gRPCConnection.sendLoop", func() { errChan <- c.sendLoop() })
|
|
|
|
err := <-errChan
|
|
|
|
c.Disconnect()
|
|
|
|
return err
|
|
}
|
|
|
|
func (c *gRPCConnection) sendLoop() error {
|
|
outgoingRoute := c.router.OutgoingRoute()
|
|
// Once the connection is closed, the send loop empties the remaining messages in the channel.
|
|
for c.IsConnected() || !outgoingRoute.IsEmpty() {
|
|
message, err := outgoingRoute.Dequeue()
|
|
if err != nil {
|
|
if errors.Is(err, routerpkg.ErrRouteClosed) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
log.Debugf("outgoing '%s' message to %s", message.Command(), c)
|
|
log.Tracef("outgoing '%s' message to %s: %s", message.Command(), c, logger.NewLogClosure(func() string {
|
|
return spew.Sdump(message)
|
|
}))
|
|
|
|
messageProto, err := protowire.FromAppMessage(message)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = c.stream.Send(messageProto)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *gRPCConnection) receiveLoop() error {
|
|
messageNumber := uint64(0)
|
|
for c.IsConnected() {
|
|
protoMessage, err := c.stream.Recv()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
err = nil
|
|
}
|
|
return err
|
|
}
|
|
message, err := protoMessage.ToAppMessage()
|
|
if err != nil {
|
|
c.onInvalidMessageHandler(err)
|
|
return err
|
|
}
|
|
|
|
messageNumber++
|
|
message.SetMessageNumber(messageNumber)
|
|
message.SetReceivedAt(time.Now())
|
|
|
|
log.Debugf("incoming '%s' message from %s (message number %d)", message.Command(), c,
|
|
message.MessageNumber())
|
|
|
|
log.Tracef("incoming '%s' message from %s (message number %d): %s", message.Command(),
|
|
c, message.MessageNumber(), logger.NewLogClosure(func() string {
|
|
return spew.Sdump(message)
|
|
}))
|
|
|
|
err = c.router.EnqueueIncomingMessage(message)
|
|
if err != nil {
|
|
if errors.Is(err, routerpkg.ErrRouteClosed) {
|
|
return nil
|
|
}
|
|
c.onInvalidMessageHandler(err)
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|