Merge remote-tracking branch 'origin/feat/hello-parts' into feat/f2-chain

node/fxlog.go

@@ -0,0 +1,17 @@
+package node
+
+import (
+	logging "github.com/ipfs/go-log"
+
+	"go.uber.org/fx"
+)
+
+type debugPrinter struct {
+	l logging.StandardLogger
+}
+
+func (p *debugPrinter) Printf(f string, a ...interface{}) {
+	p.l.Debugf(f, a...)
+}
+
+var _ fx.Printer = new(debugPrinter)

node/hello/hello.go

@@ -0,0 +1,100 @@
+package hello
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-lotus/cborrpc"
+	"github.com/libp2p/go-libp2p-core/host"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log"
+	inet "github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/protocol"
+)
+
+const ProtocolID = "/fil/hello/1.0.0"
+
+var log = logging.Logger("hello")
+
+func init() {
+	cbor.RegisterCborType(Message{})
+}
+
+type Message struct {
+	HeaviestTipSet       []cid.Cid
+	HeaviestTipSetWeight uint64
+	GenesisHash          cid.Cid
+}
+
+type NewStreamFunc func(context.Context, peer.ID, ...protocol.ID) (inet.Stream, error)
+
+type Service struct {
+	newStream NewStreamFunc
+
+	//cs        *ChainStore
+	//syncer    *Syncer
+}
+
+func NewHelloService(h host.Host) *Service {
+	return &Service{
+		newStream: h.NewStream,
+	}
+}
+
+func (hs *Service) HandleStream(s inet.Stream) {
+	defer s.Close()
+
+	var hmsg Message
+	if err := cborrpc.ReadCborRPC(s, &hmsg); err != nil {
+		log.Infow("failed to read hello message", "error", err)
+		return
+	}
+	log.Debugw("genesis from hello",
+		"tipset", hmsg.HeaviestTipSet,
+		"peer", s.Conn().RemotePeer(),
+		"hash", hmsg.GenesisHash)
+
+	/*if hmsg.GenesisHash != hs.syncer.genesis.Cids()[0] {
+		log.Error("other peer has different genesis!")
+		s.Conn().Close()
+		return
+	}
+
+	ts, err := hs.syncer.FetchTipSet(context.Background(), s.Conn().RemotePeer(), hmsg.HeaviestTipSet)
+	if err != nil {
+		log.Errorf("failed to fetch tipset from peer during hello: %s", err)
+		return
+	}
+
+	hs.syncer.InformNewHead(s.Conn().RemotePeer(), ts)*/
+}
+
+func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
+	/*s, err := hs.newStream(ctx, pid, ProtocolID)
+	if err != nil {
+		return err
+	}
+
+	hts := hs.cs.GetHeaviestTipSet()
+	weight := hs.cs.Weight(hts)
+	gen, err := hs.cs.GetGenesis()
+	if err != nil {
+		return err
+	}
+
+	hmsg := &Message{
+		HeaviestTipSet:       hts.Cids(),
+		HeaviestTipSetWeight: weight,
+		GenesisHash:          gen.Cid(),
+	}
+	fmt.Println("SENDING HELLO MESSAGE: ", hts.Cids())
+	fmt.Println("hello message genesis: ", gen.Cid())
+
+	if err := WriteCborRPC(s, hmsg); err != nil {
+		return err
+	}*/
+
+	return nil
+}

node/modules/core.go

@@ -1,10 +1,13 @@
 package modules
 
 import (
+	logging "github.com/ipfs/go-log"
 	"github.com/libp2p/go-libp2p-core/peerstore"
 	record "github.com/libp2p/go-libp2p-record"
 )
 
+var log = logging.Logger("modules")
+
 // RecordValidator provides namesys compatible routing record validator
 func RecordValidator(ps peerstore.Peerstore) record.Validator {
 	return record.NamespacedValidator{

node/modules/hello.go

@@ -0,0 +1,25 @@
+package modules
+
+import (
+	"github.com/filecoin-project/go-lotus/node/hello"
+	"github.com/filecoin-project/go-lotus/node/modules/helpers"
+	"github.com/libp2p/go-libp2p-core/host"
+	inet "github.com/libp2p/go-libp2p-core/network"
+	"go.uber.org/fx"
+)
+
+func RunHello(mctx helpers.MetricsCtx, lc fx.Lifecycle, h host.Host, svc *hello.Service) {
+	h.SetStreamHandler(hello.ProtocolID, svc.HandleStream)
+
+	bundle := inet.NotifyBundle{
+		ConnectedF: func(_ inet.Network, c inet.Conn) {
+			go func() {
+				if err := svc.SayHello(helpers.LifecycleCtx(mctx, lc), c.RemotePeer()); err != nil {
+					log.Warnw("failed to say hello", "error", err)
+					return
+				}
+			}()
+		},
+	}
+	h.Network().Notify(&bundle)
+}