lotus/node/modules/services.go

161 lines
4.8 KiB
Go
Raw Normal View History

2019-07-08 14:07:09 +00:00
package modules
import (
2020-08-11 12:48:32 +00:00
"context"
"github.com/ipfs/go-datastore"
"github.com/ipfs/go-datastore/namespace"
eventbus "github.com/libp2p/go-eventbus"
event "github.com/libp2p/go-libp2p-core/event"
2019-07-08 14:07:09 +00:00
"github.com/libp2p/go-libp2p-core/host"
"github.com/libp2p/go-libp2p-core/peer"
2019-07-08 14:07:09 +00:00
pubsub "github.com/libp2p/go-libp2p-pubsub"
"go.uber.org/fx"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-fil-markets/retrievalmarket"
"github.com/filecoin-project/go-fil-markets/retrievalmarket/discovery"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain"
"github.com/filecoin-project/lotus/chain/beacon"
2020-04-14 03:05:19 +00:00
"github.com/filecoin-project/lotus/chain/beacon/drand"
2019-11-09 23:00:22 +00:00
"github.com/filecoin-project/lotus/chain/blocksync"
2019-12-01 23:11:43 +00:00
"github.com/filecoin-project/lotus/chain/messagepool"
"github.com/filecoin-project/lotus/chain/stmgr"
2020-04-14 03:05:19 +00:00
"github.com/filecoin-project/lotus/chain/store"
"github.com/filecoin-project/lotus/chain/sub"
2020-08-11 12:48:32 +00:00
"github.com/filecoin-project/lotus/journal"
2020-02-22 11:36:22 +00:00
"github.com/filecoin-project/lotus/lib/peermgr"
"github.com/filecoin-project/lotus/node/hello"
"github.com/filecoin-project/lotus/node/modules/dtypes"
"github.com/filecoin-project/lotus/node/modules/helpers"
2020-08-11 12:48:32 +00:00
"github.com/filecoin-project/lotus/node/repo"
2019-07-08 14:07:09 +00:00
)
func RunHello(mctx helpers.MetricsCtx, lc fx.Lifecycle, h host.Host, svc *hello.Service) error {
2019-07-08 14:07:09 +00:00
h.SetStreamHandler(hello.ProtocolID, svc.HandleStream)
sub, err := h.EventBus().Subscribe(new(event.EvtPeerIdentificationCompleted), eventbus.BufSize(1024))
if err != nil {
return xerrors.Errorf("failed to subscribe to event bus: %w", err)
}
go func() {
for evt := range sub.Out() {
pic := evt.(event.EvtPeerIdentificationCompleted)
2019-07-08 14:07:09 +00:00
go func() {
if err := svc.SayHello(helpers.LifecycleCtx(mctx, lc), pic.Peer); err != nil {
protos, _ := h.Peerstore().GetProtocols(pic.Peer)
agent, _ := h.Peerstore().Get(pic.Peer, "AgentVersion")
if protosContains(protos, hello.ProtocolID) {
log.Warnw("failed to say hello", "error", err, "peer", pic.Peer, "supported", protos, "agent", agent)
} else {
log.Debugw("failed to say hello", "error", err, "peer", pic.Peer, "supported", protos, "agent", agent)
}
2019-07-08 14:07:09 +00:00
return
}
}()
}
}()
return nil
2019-07-08 14:07:09 +00:00
}
func protosContains(protos []string, search string) bool {
for _, p := range protos {
if p == search {
return true
}
}
return false
}
2019-10-17 08:57:56 +00:00
func RunPeerMgr(mctx helpers.MetricsCtx, lc fx.Lifecycle, pmgr *peermgr.PeerMgr) {
go pmgr.Run(helpers.LifecycleCtx(mctx, lc))
}
2019-11-09 23:00:22 +00:00
func RunBlockSync(h host.Host, svc *blocksync.BlockSyncService) {
h.SetStreamHandler(blocksync.BlockSyncProtocolID, svc.HandleStream)
2019-07-08 14:07:09 +00:00
}
2020-07-27 15:31:36 +00:00
func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, s *chain.Syncer, bserv dtypes.ChainBlockService, chain *store.ChainStore, stmgr *stmgr.StateManager, h host.Host, nn dtypes.NetworkName) {
2019-07-08 14:07:09 +00:00
ctx := helpers.LifecycleCtx(mctx, lc)
2020-03-31 23:13:37 +00:00
blocksub, err := ps.Subscribe(build.BlocksTopic(nn))
2019-07-08 14:07:09 +00:00
if err != nil {
panic(err)
}
v := sub.NewBlockValidator(
chain, stmgr,
func(p peer.ID) {
ps.BlacklistPeer(p)
h.ConnManager().TagPeer(p, "badblock", -1000)
})
2020-02-17 05:51:18 +00:00
2020-03-31 23:13:37 +00:00
if err := ps.RegisterTopicValidator(build.BlocksTopic(nn), v.Validate); err != nil {
2020-02-17 05:51:18 +00:00
panic(err)
}
2020-07-27 15:31:36 +00:00
go sub.HandleIncomingBlocks(ctx, blocksub, s, bserv, h.ConnManager())
2019-07-08 14:07:09 +00:00
}
2020-03-31 23:13:37 +00:00
func HandleIncomingMessages(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, mpool *messagepool.MessagePool, nn dtypes.NetworkName) {
2019-07-08 14:07:09 +00:00
ctx := helpers.LifecycleCtx(mctx, lc)
2020-03-31 23:13:37 +00:00
msgsub, err := ps.Subscribe(build.MessagesTopic(nn))
2019-07-08 14:07:09 +00:00
if err != nil {
panic(err)
}
2020-02-28 01:39:07 +00:00
v := sub.NewMessageValidator(mpool)
2020-02-17 05:51:18 +00:00
2020-03-31 23:13:37 +00:00
if err := ps.RegisterTopicValidator(build.MessagesTopic(nn), v.Validate); err != nil {
2020-02-17 05:51:18 +00:00
panic(err)
}
2019-07-08 14:07:09 +00:00
go sub.HandleIncomingMessages(ctx, mpool, msgsub)
}
2019-08-01 17:12:41 +00:00
func NewLocalDiscovery(ds dtypes.MetadataDS) *discovery.Local {
return discovery.NewLocal(namespace.Wrap(ds, datastore.NewKey("/deals/local")))
}
func RetrievalResolver(l *discovery.Local) retrievalmarket.PeerResolver {
2019-08-26 13:45:36 +00:00
return discovery.Multi(l)
}
type RandomBeaconParams struct {
fx.In
PubSub *pubsub.PubSub `optional:"true"`
2020-06-23 19:10:27 +00:00
Cs *store.ChainStore
DrandConfig dtypes.DrandConfig
}
func BuiltinDrandConfig() dtypes.DrandConfig {
return build.DrandConfig()
}
func RandomBeacon(p RandomBeaconParams, _ dtypes.AfterGenesisSet) (beacon.RandomBeacon, error) {
gen, err := p.Cs.GetGenesis()
2020-04-14 03:05:19 +00:00
if err != nil {
return nil, err
}
//return beacon.NewMockBeacon(build.BlockDelaySecs * time.Second)
return drand.NewDrandBeacon(gen.Timestamp, build.BlockDelaySecs, p.PubSub, p.DrandConfig)
}
2020-08-11 12:48:32 +00:00
func OpenFilesystemJournal(lr repo.LockedRepo, lc fx.Lifecycle, disabled journal.DisabledEvents) (journal.Journal, error) {
jrnl, err := journal.OpenFSJournal(lr, disabled)
if err != nil {
return nil, err
}
lc.Append(fx.Hook{
OnStop: func(_ context.Context) error { return jrnl.Close() },
})
return jrnl, err
}