go-waku/waku/v2/protocol/lightpush/waku_lightpush.go

240 lines
6.8 KiB
Go
Raw Normal View History

package lightpush
import (
"context"
"encoding/hex"
"errors"
"math"
2022-10-19 19:39:32 +00:00
"github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/network"
libp2pProtocol "github.com/libp2p/go-libp2p/core/protocol"
"github.com/libp2p/go-msgio/protoio"
"github.com/waku-org/go-waku/logging"
"github.com/waku-org/go-waku/waku/v2/metrics"
"github.com/waku-org/go-waku/waku/v2/protocol"
"github.com/waku-org/go-waku/waku/v2/protocol/pb"
"github.com/waku-org/go-waku/waku/v2/protocol/relay"
"go.uber.org/zap"
)
2022-07-25 15:28:17 +00:00
// LightPushID_v20beta1 is the current Waku Lightpush protocol identifier
2021-09-30 15:59:51 +00:00
const LightPushID_v20beta1 = libp2pProtocol.ID("/vac/waku/lightpush/2.0.0-beta1")
var (
ErrNoPeersAvailable = errors.New("no suitable remote peers")
ErrInvalidId = errors.New("invalid request id")
)
type WakuLightPush struct {
h host.Host
relay *relay.WakuRelay
ctx context.Context
log *zap.Logger
started bool
}
2022-05-04 21:08:24 +00:00
// NewWakuRelay returns a new instance of Waku Lightpush struct
func NewWakuLightPush(ctx context.Context, h host.Host, relay *relay.WakuRelay, log *zap.Logger) *WakuLightPush {
wakuLP := new(WakuLightPush)
wakuLP.relay = relay
wakuLP.ctx = ctx
wakuLP.h = h
wakuLP.log = log.Named("lightpush")
2021-11-01 12:38:03 +00:00
return wakuLP
}
2022-05-04 21:08:24 +00:00
// Start inits the lighpush protocol
2021-11-01 12:38:03 +00:00
func (wakuLP *WakuLightPush) Start() error {
if wakuLP.relayIsNotAvailable() {
return errors.New("relay is required, without it, it is only a client and cannot be started")
}
2021-11-01 12:38:03 +00:00
wakuLP.h.SetStreamHandlerMatch(LightPushID_v20beta1, protocol.PrefixTextMatch(string(LightPushID_v20beta1)), wakuLP.onRequest)
wakuLP.log.Info("Light Push protocol started")
wakuLP.started = true
2021-11-01 12:38:03 +00:00
return nil
}
// relayIsNotAvailable determines if this node supports relaying messages for other lightpush clients
func (wakuLp *WakuLightPush) relayIsNotAvailable() bool {
return wakuLp.relay == nil
}
func (wakuLP *WakuLightPush) onRequest(s network.Stream) {
defer s.Close()
logger := wakuLP.log.With(logging.HostID("peer", s.Conn().RemotePeer()))
requestPushRPC := &pb.PushRPC{}
writer := protoio.NewDelimitedWriter(s)
reader := protoio.NewDelimitedReader(s, math.MaxInt32)
err := reader.ReadMsg(requestPushRPC)
if err != nil {
logger.Error("reading request", zap.Error(err))
metrics.RecordLightpushError(wakuLP.ctx, "decodeRpcFailure")
return
}
logger.Info("request received")
if requestPushRPC.Query != nil {
logger.Info("push request")
response := new(pb.PushResponse)
if !wakuLP.relayIsNotAvailable() {
2021-11-19 16:19:48 +00:00
pubSubTopic := requestPushRPC.Query.PubsubTopic
message := requestPushRPC.Query.Message
2021-11-01 12:38:03 +00:00
// TODO: Assumes success, should probably be extended to check for network, peers, etc
// It might make sense to use WithReadiness option here?
2021-11-20 00:03:05 +00:00
_, err := wakuLP.relay.PublishToTopic(wakuLP.ctx, message, pubSubTopic)
if err != nil {
2022-06-13 18:30:35 +00:00
logger.Error("publishing message", zap.Error(err))
response.IsSuccess = false
response.Info = "Could not publish message"
} else {
response.IsSuccess = true
2021-06-28 14:14:28 +00:00
response.Info = "Totally" // TODO: ask about this
}
} else {
logger.Debug("no relay protocol present, unsuccessful push")
response.IsSuccess = false
response.Info = "No relay protocol"
}
responsePushRPC := &pb.PushRPC{}
responsePushRPC.RequestId = requestPushRPC.RequestId
responsePushRPC.Response = response
err = writer.WriteMsg(responsePushRPC)
if err != nil {
logger.Error("writing response", zap.Error(err))
_ = s.Reset()
} else {
logger.Info("response sent")
}
}
if requestPushRPC.Response != nil {
if requestPushRPC.Response.IsSuccess {
logger.Info("request success")
} else {
logger.Info("request failure", zap.String("info=", requestPushRPC.Response.Info))
}
}
}
2021-11-01 12:38:03 +00:00
func (wakuLP *WakuLightPush) request(ctx context.Context, req *pb.PushRequest, opts ...LightPushOption) (*pb.PushResponse, error) {
params := new(LightPushParameters)
params.host = wakuLP.h
params.log = wakuLP.log
optList := DefaultOptions(wakuLP.h)
optList = append(optList, opts...)
for _, opt := range optList {
opt(params)
}
if params.selectedPeer == "" {
metrics.RecordLightpushError(wakuLP.ctx, "dialError")
return nil, ErrNoPeersAvailable
}
if len(params.requestId) == 0 {
return nil, ErrInvalidId
}
logger := wakuLP.log.With(logging.HostID("peer", params.selectedPeer))
2022-03-03 16:04:03 +00:00
// We connect first so dns4 addresses are resolved (NewStream does not do it)
err := wakuLP.h.Connect(ctx, wakuLP.h.Peerstore().PeerInfo(params.selectedPeer))
if err != nil {
logger.Error("connecting peer", zap.Error(err))
2022-03-03 16:04:03 +00:00
return nil, err
}
2021-09-30 15:59:51 +00:00
connOpt, err := wakuLP.h.NewStream(ctx, params.selectedPeer, LightPushID_v20beta1)
if err != nil {
logger.Error("creating stream to peer", zap.Error(err))
metrics.RecordLightpushError(wakuLP.ctx, "dialError")
return nil, err
}
defer connOpt.Close()
2021-08-13 11:56:09 +00:00
defer func() {
err := connOpt.Reset()
if err != nil {
metrics.RecordLightpushError(wakuLP.ctx, "dialError")
logger.Error("resetting connection", zap.Error(err))
2021-08-13 11:56:09 +00:00
}
}()
pushRequestRPC := &pb.PushRPC{RequestId: hex.EncodeToString(params.requestId), Query: req}
writer := protoio.NewDelimitedWriter(connOpt)
reader := protoio.NewDelimitedReader(connOpt, math.MaxInt32)
err = writer.WriteMsg(pushRequestRPC)
if err != nil {
logger.Error("writing request", zap.Error(err))
return nil, err
}
pushResponseRPC := &pb.PushRPC{}
err = reader.ReadMsg(pushResponseRPC)
if err != nil {
logger.Error("reading response", zap.Error(err))
metrics.RecordLightpushError(wakuLP.ctx, "decodeRPCFailure")
return nil, err
}
return pushResponseRPC.Response, nil
}
2022-05-04 21:08:24 +00:00
// IsStarted returns if the lightpush protocol has been mounted or not
func (wakuLP *WakuLightPush) IsStarted() bool {
return wakuLP.started
}
2022-05-04 21:08:24 +00:00
// Stop unmounts the lightpush protocol
func (wakuLP *WakuLightPush) Stop() {
if wakuLP.started {
wakuLP.h.RemoveStreamHandler(LightPushID_v20beta1)
wakuLP.started = false
}
}
2021-11-01 12:38:03 +00:00
2022-05-04 21:08:24 +00:00
// PublishToTopic is used to broadcast a WakuMessage to a pubsub topic via lightpush protocol
2021-11-20 00:03:05 +00:00
func (wakuLP *WakuLightPush) PublishToTopic(ctx context.Context, message *pb.WakuMessage, topic string, opts ...LightPushOption) ([]byte, error) {
2021-11-01 12:38:03 +00:00
if message == nil {
return nil, errors.New("message can't be null")
}
req := new(pb.PushRequest)
req.Message = message
req.PubsubTopic = topic
2021-11-01 12:38:03 +00:00
response, err := wakuLP.request(ctx, req, opts...)
2021-11-01 12:38:03 +00:00
if err != nil {
return nil, err
}
if response.IsSuccess {
hash, _, _ := message.Hash()
wakuLP.log.Info("waku.lightpush published", logging.HexString("hash", hash))
2021-11-01 12:38:03 +00:00
return hash, nil
} else {
return nil, errors.New(response.Info)
}
}
2022-05-04 21:08:24 +00:00
// Publish is used to broadcast a WakuMessage to the default waku pubsub topic via lightpush protocol
func (wakuLP *WakuLightPush) Publish(ctx context.Context, message *pb.WakuMessage, opts ...LightPushOption) ([]byte, error) {
2021-11-20 00:03:05 +00:00
return wakuLP.PublishToTopic(ctx, message, relay.DefaultWakuTopic, opts...)
}