cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

enable libp2p options

Browse Source
This commit is contained in:
Anton Evangelatov 2021-06-24 16:02:51 +02:00
parent a8d5ae5213
commit 9ec7cd7239
23 changed files with 760 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
chain/sync_test.go
View File

@ -279,7 +279,7 @@ func (tu *syncTestUtil) addSourceNode(gen int) {
stop, err := node.New(tu.ctx,
node.FullAPI(&out),
node.Online(),
node.Base(sourceRepo),
node.Repo(sourceRepo),
node.MockHost(tu.mn),
node.Test(),
@ -310,10 +310,11 @@ func (tu *syncTestUtil) addClientNode() int {
var out api.FullNode
r := repo.NewMemory(nil)
stop, err := node.New(tu.ctx,
node.FullAPI(&out),
node.Online(),
node.Repo(repo.NewMemory(nil)),
node.Base(r),
node.Repo(r),
node.MockHost(tu.mn),
node.Test(),

16
cmd/lotus-storage-miner/run.go
View File

@ -124,7 +124,7 @@ var runCmd = &cli.Command{
stop, err := node.New(ctx,
node.StorageMiner(&minerapi),
node.Override(new(dtypes.ShutdownChan), shutdownChan),
node.Online(),
node.Base(r),
node.Repo(r),
node.ApplyIf(func(s *node.Settings) bool { return cctx.IsSet("miner-api") },
@ -143,14 +143,14 @@ var runCmd = &cli.Command{
}
// Bootstrap with full node
remoteAddrs, err := nodeApi.NetAddrsListen(ctx)
if err != nil {
return xerrors.Errorf("getting full node libp2p address: %w", err)
}
//remoteAddrs, err := nodeApi.NetAddrsListen(ctx)
//if err != nil {
//return xerrors.Errorf("getting full node libp2p address: %w", err)
//}
if err := minerapi.NetConnect(ctx, remoteAddrs); err != nil {
return xerrors.Errorf("connecting to full node (libp2p): %w", err)
}
//if err := minerapi.NetConnect(ctx, remoteAddrs); err != nil {
//return xerrors.Errorf("connecting to full node (libp2p): %w", err)
//}
log.Infof("Remote version %s", v)

2
cmd/lotus/daemon.go
View File

@ -314,7 +314,7 @@ var DaemonCmd = &cli.Command{
stop, err := node.New(ctx,
node.FullAPI(&api, node.Lite(isLite)),
node.Online(),
node.Base(r),
node.Repo(r),
node.Override(new(dtypes.Bootstrapper), isBootstrapper),

BIN
dev.gen Normal file
View File

Binary file not shown.

20
itests/deals_test.go
View File

@ -63,9 +63,9 @@ func TestDealWithMarketAndMinerNode(t *testing.T) {
n := n
ns := fmt.Sprintf("%d", n)
t.Run(ns+"-fastretrieval-CAR", func(t *testing.T) { runTest(t, n, true, true) })
t.Run(ns+"-fastretrieval-NoCAR", func(t *testing.T) { runTest(t, n, true, false) })
t.Run(ns+"-stdretrieval-CAR", func(t *testing.T) { runTest(t, n, true, false) })
t.Run(ns+"-stdretrieval-NoCAR", func(t *testing.T) { runTest(t, n, false, false) })
//t.Run(ns+"-fastretrieval-NoCAR", func(t *testing.T) { runTest(t, n, true, false) })
//t.Run(ns+"-stdretrieval-CAR", func(t *testing.T) { runTest(t, n, true, false) })
//t.Run(ns+"-stdretrieval-NoCAR", func(t *testing.T) { runTest(t, n, false, false) })
}
}
@ -171,14 +171,14 @@ func TestDealsWithSealingAndRPC(t *testing.T) {
runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1})
})
t.Run("fastretrieval", func(t *testing.T) {
runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1, fastRetrieval: true})
})
//t.Run("fastretrieval", func(t *testing.T) {
//runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1, fastRetrieval: true})
//})
t.Run("fastretrieval-twodeals-sequential", func(t *testing.T) {
runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1, fastRetrieval: true})
runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1, fastRetrieval: true})
})
//t.Run("fastretrieval-twodeals-sequential", func(t *testing.T) {
//runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1, fastRetrieval: true})
//runConcurrentDeals(t, dh, fullDealCyclesOpts{n: 1, fastRetrieval: true})
//})
}
func TestQuotePriceForUnsealedRetrieval(t *testing.T) {

9
itests/kit/ensemble.go
View File

@ -273,10 +273,11 @@ func (n *Ensemble) Start() *Ensemble {
// Create all inactive full nodes.
for i, full := range n.inactive.fullnodes {
r := repo.NewMemory(nil)
opts := []node.Option{
node.FullAPI(&full.FullNode, node.Lite(full.options.lite)),
node.Online(),
node.Repo(repo.NewMemory(nil)),
node.Base(r),
node.Repo(r),
node.MockHost(n.mn),
node.Test(),
@ -496,11 +497,11 @@ func (n *Ensemble) Start() *Ensemble {
var mineBlock = make(chan lotusminer.MineReq)
opts := []node.Option{
node.StorageMiner(&m.StorageMiner),
node.Online(),
node.Base(r),
node.Repo(r),
node.Test(),
node.MockHost(n.mn),
node.If(!m.options.disableLibp2p, node.MockHost(n.mn)),
node.Override(new(v1api.FullNode), m.FullNode.FullNode),
node.Override(new(*lotusminer.Miner), lotusminer.NewTestMiner(mineBlock, m.ActorAddr)),

7
itests/kit/ensemble_presets.go
View File

@ -31,17 +31,18 @@ func EnsembleWithMinerAndMarketNodes(t *testing.T, opts ...interface{}) (*TestFu
main, market TestMiner
)
mainNodeOpts := []NodeOpt{WithSubsystem(SSealing), WithSubsystem(SSectorStorage), WithSubsystem(SMining)}
mainNodeOpts := []NodeOpt{WithSubsystem(SSealing), WithSubsystem(SSectorStorage), WithSubsystem(SMining), DisableLibp2p()}
mainNodeOpts = append(mainNodeOpts, nopts...)
blockTime := 100 * time.Millisecond
ens := NewEnsemble(t, eopts...).FullNode(&fullnode, nopts...).Miner(&main, &fullnode, mainNodeOpts...).Start()
ens.InterconnectAll().BeginMining(blockTime)
ens.BeginMining(blockTime)
//ens.InterconnectAll().BeginMining(blockTime)
marketNodeOpts := []NodeOpt{OwnerAddr(fullnode.DefaultKey), MainMiner(&main), WithSubsystem(SStorageMarket)}
marketNodeOpts = append(marketNodeOpts, nopts...)
ens.Miner(&market, &fullnode, marketNodeOpts...).Start().InterconnectAll()
ens.Miner(&market, &fullnode, marketNodeOpts...).Start().Connect(market, fullnode)
return &fullnode, &main, &market, ens
}

16
itests/kit/node_opts.go
View File

@ -26,10 +26,11 @@ type nodeOpts struct {
ownerKey *wallet.Key
extraNodeOpts []node.Option
subsystems MinerSubsystem
mainMiner *TestMiner
optBuilders []OptBuilder
proofType abi.RegisteredSealProof
subsystems MinerSubsystem
mainMiner *TestMiner
disableLibp2p bool
optBuilders []OptBuilder
proofType abi.RegisteredSealProof
}
// DefaultNodeOpts are the default options that will be applied to test nodes.
@ -64,6 +65,13 @@ func WithSubsystem(single MinerSubsystem) NodeOpt {
}
}
func DisableLibp2p() NodeOpt {
return func(opts *nodeOpts) error {
opts.disableLibp2p = true
return nil
}
}
func MainMiner(m *TestMiner) NodeOpt {
return func(opts *nodeOpts) error {
opts.mainMiner = m

300
localnet.json Normal file
View File

@ -0,0 +1,300 @@
{
"NetworkVersion": 13,
"Accounts": [
{
"Type": "account",
"Balance": "50000000000000000000000000",
"Meta": {
"Owner": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q"
}
}
],
"Miners": [
{
"ID": "t01000",
"Owner": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Worker": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"PeerId": "12D3KooWKTVTM22Qo5nyHDkJKjzGnvK6gmVhg2M2stnq7CnSqecL",
"MarketBalance": "0",
"PowerBalance": "0",
"SectorSize": 2048,
"Sectors": [
{
"CommR": {
"/": "bagboea4b5abcal2xmbqbnp3c7bc65qzkemph5zvfl3xhgrjitt3njhrcp2gpbbz7"
},
"CommD": {
"/": "baga6ea4seaqmqrhvx7o43zuzrq6pghpb3mhlh6wknltsdaxrojnpgmtanwryolq"
},
"SectorID": 0,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqmqrhvx7o43zuzrq6pghpb3mhlh6wknltsdaxrojnpgmtanwryolq"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "0",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcay3srmtysbo7yumd3blzm6zfzmtpmkz2cjjazfwkyou3s2rcxkcz"
},
"CommD": {
"/": "baga6ea4seaqiswaqzikmod67h5zgx6w2y5nyvkcyzrx2jviyuqjth2j2ctyxmaa"
},
"SectorID": 1,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqiswaqzikmod67h5zgx6w2y5nyvkcyzrx2jviyuqjth2j2ctyxmaa"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "1",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcbvoytejipdlbccrpen37rgwnzuvj5sbmepkr7j3x2d2rw25i3rbe"
},
"CommD": {
"/": "baga6ea4seaqn46eska7w7eodzexu5i3kztkh442pjdedyqupggaak3xuqxcguai"
},
"SectorID": 2,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqn46eska7w7eodzexu5i3kztkh442pjdedyqupggaak3xuqxcguai"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "2",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcavzmp4nc2m5gysdo2shnndpg7fj74jhrxltmudfx6y52gk2ytwyk"
},
"CommD": {
"/": "baga6ea4seaqaqw654v3skkrua5tjifz346kvccdsefozlhfew7tlsr6kjw7qmca"
},
"SectorID": 3,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqaqw654v3skkrua5tjifz346kvccdsefozlhfew7tlsr6kjw7qmca"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "3",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcbb3fmoofpvw2lygsqlxdvwey76gm3oougtafxgsqta64igtamksi"
},
"CommD": {
"/": "baga6ea4seaqkogt5mb4yts7tewnm6gqdsmeth2aqe3vacvloxkz57x3li3yxeoq"
},
"SectorID": 4,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqkogt5mb4yts7tewnm6gqdsmeth2aqe3vacvloxkz57x3li3yxeoq"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "4",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcaxjcv6kvi6qyzkck43hlicrungi455eyphn4uplf74lfbgnz2ej6"
},
"CommD": {
"/": "baga6ea4seaqeuhpoqqu6byechjjac5luaex422aurfblcafm4so2l26wauvionq"
},
"SectorID": 5,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqeuhpoqqu6byechjjac5luaex422aurfblcafm4so2l26wauvionq"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "5",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcbbjn2p3s7us6z5xtel3milaconaw4b5yrlvsr2xwn56r6xdfnhkn"
},
"CommD": {
"/": "baga6ea4seaqerpv676ub5kiunhehh4ts4ec67sbjwwwroubusatwyvdoi6ba4da"
},
"SectorID": 6,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqerpv676ub5kiunhehh4ts4ec67sbjwwwroubusatwyvdoi6ba4da"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "6",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcb6bwulp3c5uofugovtafdhsi42vk7ko3iz2f3kglbktfh5vggxr3"
},
"CommD": {
"/": "baga6ea4seaqhfvi2x3xej2gcy62hvp6pgjyvwwkhln7dtujmhu3wbcntitbrcny"
},
"SectorID": 7,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqhfvi2x3xej2gcy62hvp6pgjyvwwkhln7dtujmhu3wbcntitbrcny"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "7",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcbhkm7ipsg2h4u2n2jm4nydhpe7wspnz24pccrj243kpt64twyxro"
},
"CommD": {
"/": "baga6ea4seaqdkj5mab4o3tda6py5p5h6gn2ekvc7mvflyklnaxvoaf6fa3tk2hy"
},
"SectorID": 8,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqdkj5mab4o3tda6py5p5h6gn2ekvc7mvflyklnaxvoaf6fa3tk2hy"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "8",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
},
{
"CommR": {
"/": "bagboea4b5abcaec7bt3xxbqwwdioklblgmywfi5nlepmkm57elyxr7nss4whnckb"
},
"CommD": {
"/": "baga6ea4seaqmbnp4dmmd2meop6qok2b3rgdmloifhaincikjwny4facaxkhceby"
},
"SectorID": 9,
"Deal": {
"PieceCID": {
"/": "baga6ea4seaqmbnp4dmmd2meop6qok2b3rgdmloifhaincikjwny4facaxkhceby"
},
"PieceSize": 2048,
"VerifiedDeal": false,
"Client": "t3sd2vpjcqr53rd7x7vgbtno2ubdyswju5tcnb7q25ptkhg5iik4mb4zhzlu3ygpxbhypwqo4p6r2zhpvdb67q",
"Provider": "t01000",
"Label": "9",
"StartEpoch": 0,
"EndEpoch": 9001,
"StoragePricePerEpoch": "0",
"ProviderCollateral": "0",
"ClientCollateral": "0"
},
"ProofType": 5
}
]
}
],
"NetworkName": "localnet-c0485b38-b9e6-4423-9289-180767954029",
"VerifregRootKey": {
"Type": "multisig",
"Balance": "0",
"Meta": {
"Signers": [
"t1ceb34gnsc6qk5dt6n7xg6ycwzasjhbxm3iylkiy"
],
"Threshold": 1,
"VestingDuration": 0,
"VestingStart": 0
}
},
"RemainderAccount": {
"Type": "multisig",
"Balance": "0",
"Meta": {
"Signers": [
"t1ceb34gnsc6qk5dt6n7xg6ycwzasjhbxm3iylkiy"
],
"Threshold": 1,
"VestingDuration": 0,
"VestingStart": 0
}
}
}

35
node/builder.go
View File

@ -8,6 +8,7 @@ import (
metricsi "github.com/ipfs/go-metrics-interface"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/system"
logging "github.com/ipfs/go-log/v2"
@ -34,6 +35,8 @@ import (
_ "github.com/filecoin-project/lotus/lib/sigs/secp"
"github.com/filecoin-project/lotus/markets/storageadapter"
"github.com/filecoin-project/lotus/node/config"
"github.com/filecoin-project/lotus/node/impl/common"
"github.com/filecoin-project/lotus/node/impl/common/mock"
"github.com/filecoin-project/lotus/node/modules"
"github.com/filecoin-project/lotus/node/modules/dtypes"
"github.com/filecoin-project/lotus/node/modules/helpers"
@ -128,7 +131,7 @@ type Settings struct {
nodeType repo.RepoType
Online bool // Online option applied
Base bool // Base option applied
Config bool // Config option applied
Lite bool // Start node in "lite" mode
}
@ -207,18 +210,14 @@ func isFullOrLiteNode(s *Settings) bool { return s.nodeType == repo.FullNode }
func isFullNode(s *Settings) bool { return s.nodeType == repo.FullNode && !s.Lite }
func isLiteNode(s *Settings) bool { return s.nodeType == repo.FullNode && s.Lite }
// Online sets up basic libp2p node
func Online() Option {
func Base(r repo.Repo) Option {
return Options(
// make sure that online is applied before Config.
// This is important because Config overrides some of Online units
func(s *Settings) error { s.Online = true; return nil },
func(s *Settings) error { s.Base = true; return nil }, // mark Base as applied
ApplyIf(func(s *Settings) bool { return s.Config },
Error(errors.New("the Online option must be set before Config option")),
Error(errors.New("the Base() option must be set before Config option")),
),
LibP2P,
ApplyIfEnableLibP2P(r, LibP2P),
ApplyIf(isFullOrLiteNode, ChainNode),
ApplyIf(isType(repo.StorageMiner), MinerNode),
@ -226,7 +225,7 @@ func Online() Option {
}
// Config sets up constructors based on the provided Config
func ConfigCommon(cfg *config.Common) Option {
func ConfigCommon(cfg *config.Common, enableLibp2pNode bool) Option {
return Options(
func(s *Settings) error { s.Config = true; return nil },
Override(new(dtypes.APIEndpoint), func() (dtypes.APIEndpoint, error) {
@ -242,7 +241,14 @@ func ConfigCommon(cfg *config.Common) Option {
urls = append(urls, "http://"+ip+"/remote") // TODO: This makes no assumptions, and probably could...
return urls, nil
}),
ApplyIf(func(s *Settings) bool { return s.Online },
ApplyIf(func(s *Settings) bool { return s.Base }), // apply only if Base has already been applied
If(!enableLibp2pNode,
Override(new(common.NetAPI), From(new(mock.MockNetAPI))),
Override(new(api.Common), From(new(common.CommonAPI))),
),
If(enableLibp2pNode,
Override(new(common.NetAPI), From(new(common.Libp2pNetAPI))),
Override(new(api.Common), From(new(common.CommonAPI))),
Override(StartListeningKey, lp2p.StartListening(cfg.Libp2p.ListenAddresses)),
Override(ConnectionManagerKey, lp2p.ConnectionManager(
cfg.Libp2p.ConnMgrLow,
@ -255,10 +261,11 @@ func ConfigCommon(cfg *config.Common) Option {
ApplyIf(func(s *Settings) bool { return len(cfg.Libp2p.BootstrapPeers) > 0 },
Override(new(dtypes.BootstrapPeers), modules.ConfigBootstrap(cfg.Libp2p.BootstrapPeers)),
),
Override(AddrsFactoryKey, lp2p.AddrsFactory(
cfg.Libp2p.AnnounceAddresses,
cfg.Libp2p.NoAnnounceAddresses)),
),
Override(AddrsFactoryKey, lp2p.AddrsFactory(
cfg.Libp2p.AnnounceAddresses,
cfg.Libp2p.NoAnnounceAddresses)),
Override(new(dtypes.MetadataDS), modules.Datastore(cfg.Backup.DisableMetadataLog)),
)
}

4
node/builder_chain.go
View File

@ -160,9 +160,11 @@ func ConfigFullNode(c interface{}) Option {
return Error(xerrors.Errorf("invalid config from repo, got: %T", c))
}
enableLibp2pNode := true // always enable libp2p for full nodes
ipfsMaddr := cfg.Client.IpfsMAddr
return Options(
ConfigCommon(&cfg.Common),
ConfigCommon(&cfg.Common, enableLibp2pNode),
If(cfg.Client.UseIpfs,
Override(new(dtypes.ClientBlockstore), modules.IpfsClientBlockstore(ipfsMaddr, cfg.Client.IpfsOnlineMode)),

10
node/builder_miner.go
View File

@ -28,7 +28,6 @@ import (
"github.com/filecoin-project/lotus/miner"
"github.com/filecoin-project/lotus/node/config"
"github.com/filecoin-project/lotus/node/impl"
"github.com/filecoin-project/lotus/node/impl/common"
"github.com/filecoin-project/lotus/node/modules"
"github.com/filecoin-project/lotus/node/modules/dtypes"
"github.com/filecoin-project/lotus/node/repo"
@ -37,8 +36,6 @@ import (
)
var MinerNode = Options(
// API dependencies
Override(new(api.Common), From(new(common.CommonAPI))),
Override(new(sectorstorage.StorageAuth), modules.StorageAuth),
// Actor config
@ -57,8 +54,10 @@ func ConfigStorageMiner(c interface{}) Option {
return Error(xerrors.Errorf("invalid config from repo, got: %T", c))
}
enableLibp2pNode := cfg.Subsystems.EnableStorageMarket // we enable libp2p nodes if the storage market subsystem is enabled, otherwise we don't
return Options(
ConfigCommon(&cfg.Common),
ConfigCommon(&cfg.Common, enableLibp2pNode),
Override(new(stores.LocalStorage), From(new(repo.LockedRepo))),
Override(new(*stores.Local), modules.LocalStorage),
@ -191,9 +190,6 @@ func StorageMiner(out *api.StorageMiner) Option {
ApplyIf(func(s *Settings) bool { return s.Config },
Error(errors.New("the StorageMiner option must be set before Config option")),
),
ApplyIf(func(s *Settings) bool { return s.Online },
Error(errors.New("the StorageMiner option must be set before Online option")),
),
func(s *Settings) error {
s.nodeType = repo.StorageMiner

40
node/enable_libp2p.go Normal file
View File

@ -0,0 +1,40 @@
package node
import (
"github.com/filecoin-project/lotus/node/config"
"github.com/filecoin-project/lotus/node/repo"
)
func ApplyIfEnableLibP2P(r repo.Repo, opts ...Option) Option {
return ApplyIf(func(settings *Settings) bool {
lr, err := r.Lock(settings.nodeType)
if err != nil {
// log error
return false
}
c, err := lr.Config()
if err != nil {
// log error
return false
}
defer lr.Close()
switch settings.nodeType {
case repo.FullNode:
return true
case repo.StorageMiner:
cfg, ok := c.(*config.StorageMiner)
if !ok {
// log error
return false
}
enableLibP2P := cfg.Subsystems.EnableStorageMarket
return enableLibP2P
default:
// log error
return false
}
}, opts...)
}

202
node/impl/common/common.go
View File

@ -2,32 +2,18 @@ package common
import (
"context"
"sort"
"strings"
"github.com/gbrlsnchs/jwt/v3"
"github.com/google/uuid"
logging "github.com/ipfs/go-log/v2"
"go.uber.org/fx"
"golang.org/x/xerrors"
logging "github.com/ipfs/go-log/v2"
"github.com/libp2p/go-libp2p-core/host"
metrics "github.com/libp2p/go-libp2p-core/metrics"
"github.com/libp2p/go-libp2p-core/network"
"github.com/libp2p/go-libp2p-core/peer"
protocol "github.com/libp2p/go-libp2p-core/protocol"
swarm "github.com/libp2p/go-libp2p-swarm"
basichost "github.com/libp2p/go-libp2p/p2p/host/basic"
"github.com/libp2p/go-libp2p/p2p/net/conngater"
ma "github.com/multiformats/go-multiaddr"
"github.com/filecoin-project/go-jsonrpc/auth"
"github.com/filecoin-project/lotus/api"
apitypes "github.com/filecoin-project/lotus/api/types"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/node/modules/dtypes"
"github.com/filecoin-project/lotus/node/modules/lp2p"
)
var session = uuid.New()
@ -35,13 +21,9 @@ var session = uuid.New()
type CommonAPI struct {
fx.In
NetAPI
APISecret *dtypes.APIAlg
RawHost lp2p.RawHost
Host host.Host
Router lp2p.BaseIpfsRouting
ConnGater *conngater.BasicConnectionGater
Reporter metrics.Reporter
Sk *dtypes.ScoreKeeper
ShutdownChan dtypes.ShutdownChan
}
@ -66,170 +48,6 @@ func (a *CommonAPI) AuthNew(ctx context.Context, perms []auth.Permission) ([]byt
return jwt.Sign(&p, (*jwt.HMACSHA)(a.APISecret))
}
func (a *CommonAPI) NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error) {
return a.Host.Network().Connectedness(pid), nil
}
func (a *CommonAPI) NetPubsubScores(context.Context) ([]api.PubsubScore, error) {
scores := a.Sk.Get()
out := make([]api.PubsubScore, len(scores))
i := 0
for k, v := range scores {
out[i] = api.PubsubScore{ID: k, Score: v}
i++
}
sort.Slice(out, func(i, j int) bool {
return strings.Compare(string(out[i].ID), string(out[j].ID)) > 0
})
return out, nil
}
func (a *CommonAPI) NetPeers(context.Context) ([]peer.AddrInfo, error) {
conns := a.Host.Network().Conns()
out := make([]peer.AddrInfo, len(conns))
for i, conn := range conns {
out[i] = peer.AddrInfo{
ID: conn.RemotePeer(),
Addrs: []ma.Multiaddr{
conn.RemoteMultiaddr(),
},
}
}
return out, nil
}
func (a *CommonAPI) NetPeerInfo(_ context.Context, p peer.ID) (*api.ExtendedPeerInfo, error) {
info := &api.ExtendedPeerInfo{ID: p}
agent, err := a.Host.Peerstore().Get(p, "AgentVersion")
if err == nil {
info.Agent = agent.(string)
}
for _, a := range a.Host.Peerstore().Addrs(p) {
info.Addrs = append(info.Addrs, a.String())
}
sort.Strings(info.Addrs)
protocols, err := a.Host.Peerstore().GetProtocols(p)
if err == nil {
sort.Strings(protocols)
info.Protocols = protocols
}
if cm := a.Host.ConnManager().GetTagInfo(p); cm != nil {
info.ConnMgrMeta = &api.ConnMgrInfo{
FirstSeen: cm.FirstSeen,
Value: cm.Value,
Tags: cm.Tags,
Conns: cm.Conns,
}
}
return info, nil
}
func (a *CommonAPI) NetConnect(ctx context.Context, p peer.AddrInfo) error {
if swrm, ok := a.Host.Network().(*swarm.Swarm); ok {
swrm.Backoff().Clear(p.ID)
}
return a.Host.Connect(ctx, p)
}
func (a *CommonAPI) NetAddrsListen(context.Context) (peer.AddrInfo, error) {
return peer.AddrInfo{
ID: a.Host.ID(),
Addrs: a.Host.Addrs(),
}, nil
}
func (a *CommonAPI) NetDisconnect(ctx context.Context, p peer.ID) error {
return a.Host.Network().ClosePeer(p)
}
func (a *CommonAPI) NetFindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error) {
return a.Router.FindPeer(ctx, p)
}
func (a *CommonAPI) NetAutoNatStatus(ctx context.Context) (i api.NatInfo, err error) {
autonat := a.RawHost.(*basichost.BasicHost).GetAutoNat()
if autonat == nil {
return api.NatInfo{
Reachability: network.ReachabilityUnknown,
}, nil
}
var maddr string
if autonat.Status() == network.ReachabilityPublic {
pa, err := autonat.PublicAddr()
if err != nil {
return api.NatInfo{}, err
}
maddr = pa.String()
}
return api.NatInfo{
Reachability: autonat.Status(),
PublicAddr: maddr,
}, nil
}
func (a *CommonAPI) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
ag, err := a.Host.Peerstore().Get(p, "AgentVersion")
if err != nil {
return "", err
}
if ag == nil {
return "unknown", nil
}
return ag.(string), nil
}
func (a *CommonAPI) NetBandwidthStats(ctx context.Context) (metrics.Stats, error) {
return a.Reporter.GetBandwidthTotals(), nil
}
func (a *CommonAPI) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
out := make(map[string]metrics.Stats)
for p, s := range a.Reporter.GetBandwidthByPeer() {
out[p.String()] = s
}
return out, nil
}
func (a *CommonAPI) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
return a.Reporter.GetBandwidthByProtocol(), nil
}
func (a *CommonAPI) Discover(ctx context.Context) (apitypes.OpenRPCDocument, error) {
return build.OpenRPCDiscoverJSON_Full(), nil
}
func (a *CommonAPI) ID(context.Context) (peer.ID, error) {
return a.Host.ID(), nil
}
func (a *CommonAPI) Version(context.Context) (api.APIVersion, error) {
v, err := api.VersionForType(api.RunningNodeType)
if err != nil {
return api.APIVersion{}, err
}
return api.APIVersion{
Version: build.UserVersion(),
APIVersion: v,
BlockDelay: build.BlockDelaySecs,
}, nil
}
func (a *CommonAPI) LogList(context.Context) ([]string, error) {
return logging.GetSubsystems(), nil
}
@ -251,4 +69,16 @@ func (a *CommonAPI) Closing(ctx context.Context) (<-chan struct{}, error) {
return make(chan struct{}), nil // relies on jsonrpc closing
}
var _ api.Common = &CommonAPI{}
func (a *CommonAPI) Version(context.Context) (api.APIVersion, error) {
v, err := api.VersionForType(api.RunningNodeType)
if err != nil {
return api.APIVersion{}, err
}
return api.APIVersion{
Version: build.UserVersion(),
APIVersion: v,
BlockDelay: build.BlockDelaySecs,
}, nil
}

101
node/impl/common/mock/mock.go Normal file
View File

@ -0,0 +1,101 @@
package mock
import (
"context"
"errors"
"github.com/filecoin-project/lotus/api"
apitypes "github.com/filecoin-project/lotus/api/types"
"github.com/libp2p/go-libp2p-core/metrics"
"github.com/libp2p/go-libp2p-core/network"
"github.com/libp2p/go-libp2p-core/peer"
"github.com/libp2p/go-libp2p-core/protocol"
"go.uber.org/fx"
)
var (
errNotImplemented = errors.New("not implemented")
)
type MockNetAPI struct {
fx.In
}
func (a *MockNetAPI) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
return "", errNotImplemented
}
func (a *MockNetAPI) NetConnectedness(ctx context.Context, pid peer.ID) (conn network.Connectedness, err error) {
err = errNotImplemented
return
}
func (a *MockNetAPI) NetPubsubScores(context.Context) ([]api.PubsubScore, error) {
return nil, errNotImplemented
}
func (a *MockNetAPI) NetPeers(context.Context) ([]peer.AddrInfo, error) {
return nil, errNotImplemented
}
func (a *MockNetAPI) NetPeerInfo(_ context.Context, p peer.ID) (*api.ExtendedPeerInfo, error) {
return nil, errNotImplemented
}
func (a *MockNetAPI) NetConnect(ctx context.Context, p peer.AddrInfo) error {
return errNotImplemented
}
func (a *MockNetAPI) NetAddrsListen(context.Context) (ai peer.AddrInfo, err error) {
err = errNotImplemented
return
}
func (a *MockNetAPI) NetDisconnect(ctx context.Context, p peer.ID) error {
return errNotImplemented
}
func (a *MockNetAPI) NetFindPeer(ctx context.Context, p peer.ID) (ai peer.AddrInfo, err error) {
err = errNotImplemented
return
}
func (a *MockNetAPI) NetAutoNatStatus(ctx context.Context) (i api.NatInfo, err error) {
err = errNotImplemented
return
}
func (a *MockNetAPI) NetBandwidthStats(ctx context.Context) (s metrics.Stats, err error) {
err = errNotImplemented
return
}
func (a *MockNetAPI) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
return nil, errNotImplemented
}
func (a *MockNetAPI) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
return nil, errNotImplemented
}
func (a *MockNetAPI) Discover(ctx context.Context) (apitypes.OpenRPCDocument, error) {
return nil, errNotImplemented
}
func (a *MockNetAPI) ID(context.Context) (p peer.ID, err error) {
err = errNotImplemented
return
}
func (a *MockNetAPI) NetBlockAdd(ctx context.Context, acl api.NetBlockList) error {
return errNotImplemented
}
func (a *MockNetAPI) NetBlockRemove(ctx context.Context, acl api.NetBlockList) error {
return errNotImplemented
}
func (a *MockNetAPI) NetBlockList(ctx context.Context) (result api.NetBlockList, err error) {
err = errNotImplemented
return
}

34
node/impl/common/net.go Normal file
View File

@ -0,0 +1,34 @@
package common
import (
"context"
metrics "github.com/libp2p/go-libp2p-core/metrics"
"github.com/libp2p/go-libp2p-core/network"
"github.com/libp2p/go-libp2p-core/peer"
protocol "github.com/libp2p/go-libp2p-core/protocol"
"github.com/filecoin-project/lotus/api"
apitypes "github.com/filecoin-project/lotus/api/types"
)
type NetAPI interface {
NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error)
NetPubsubScores(context.Context) ([]api.PubsubScore, error)
NetPeers(context.Context) ([]peer.AddrInfo, error)
NetPeerInfo(_ context.Context, p peer.ID) (*api.ExtendedPeerInfo, error)
NetConnect(ctx context.Context, p peer.AddrInfo) error
NetAddrsListen(context.Context) (peer.AddrInfo, error)
NetDisconnect(ctx context.Context, p peer.ID) error
NetFindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error)
NetAutoNatStatus(ctx context.Context) (i api.NatInfo, err error)
NetAgentVersion(ctx context.Context, p peer.ID) (string, error)
NetBandwidthStats(ctx context.Context) (metrics.Stats, error)
NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error)
NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error)
Discover(ctx context.Context) (apitypes.OpenRPCDocument, error)
ID(context.Context) (peer.ID, error)
NetBlockAdd(ctx context.Context, acl api.NetBlockList) error
NetBlockRemove(ctx context.Context, acl api.NetBlockList) error
NetBlockList(ctx context.Context) (api.NetBlockList, error)
}

6
node/impl/common/conngater.go → node/impl/common/net_conngater.go
View File

@ -14,7 +14,7 @@ import (
var cLog = logging.Logger("conngater")
func (a *CommonAPI) NetBlockAdd(ctx context.Context, acl api.NetBlockList) error {
func (a *Libp2pNetAPI) NetBlockAdd(ctx context.Context, acl api.NetBlockList) error {
for _, p := range acl.Peers {
err := a.ConnGater.BlockPeer(p)
if err != nil {
@ -89,7 +89,7 @@ func (a *CommonAPI) NetBlockAdd(ctx context.Context, acl api.NetBlockList) error
return nil
}
func (a *CommonAPI) NetBlockRemove(ctx context.Context, acl api.NetBlockList) error {
func (a *Libp2pNetAPI) NetBlockRemove(ctx context.Context, acl api.NetBlockList) error {
for _, p := range acl.Peers {
err := a.ConnGater.UnblockPeer(p)
if err != nil {
@ -124,7 +124,7 @@ func (a *CommonAPI) NetBlockRemove(ctx context.Context, acl api.NetBlockList) er
return nil
}
func (a *CommonAPI) NetBlockList(ctx context.Context) (result api.NetBlockList, err error) {
func (a *Libp2pNetAPI) NetBlockList(ctx context.Context) (result api.NetBlockList, err error) {
result.Peers = a.ConnGater.ListBlockedPeers()
for _, ip := range a.ConnGater.ListBlockedAddrs() {
result.IPAddrs = append(result.IPAddrs, ip.String())

186
node/impl/common/net_libp2p.go Normal file
View File

@ -0,0 +1,186 @@
package common
import (
"context"
"sort"
"strings"
"github.com/libp2p/go-libp2p-core/host"
metrics "github.com/libp2p/go-libp2p-core/metrics"
"github.com/libp2p/go-libp2p-core/network"
"github.com/libp2p/go-libp2p-core/peer"
protocol "github.com/libp2p/go-libp2p-core/protocol"
swarm "github.com/libp2p/go-libp2p-swarm"
basichost "github.com/libp2p/go-libp2p/p2p/host/basic"
"github.com/libp2p/go-libp2p/p2p/net/conngater"
ma "github.com/multiformats/go-multiaddr"
"go.uber.org/fx"
"github.com/filecoin-project/lotus/api"
apitypes "github.com/filecoin-project/lotus/api/types"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/node/modules/dtypes"
"github.com/filecoin-project/lotus/node/modules/lp2p"
)
type Libp2pNetAPI struct {
fx.In
RawHost lp2p.RawHost
Host host.Host
Router lp2p.BaseIpfsRouting
ConnGater *conngater.BasicConnectionGater
Reporter metrics.Reporter
Sk *dtypes.ScoreKeeper
}
func (a *Libp2pNetAPI) NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error) {
return a.Host.Network().Connectedness(pid), nil
}
func (a *Libp2pNetAPI) NetPubsubScores(context.Context) ([]api.PubsubScore, error) {
scores := a.Sk.Get()
out := make([]api.PubsubScore, len(scores))
i := 0
for k, v := range scores {
out[i] = api.PubsubScore{ID: k, Score: v}
i++
}
sort.Slice(out, func(i, j int) bool {
return strings.Compare(string(out[i].ID), string(out[j].ID)) > 0
})
return out, nil
}
func (a *Libp2pNetAPI) NetPeers(context.Context) ([]peer.AddrInfo, error) {
conns := a.Host.Network().Conns()
out := make([]peer.AddrInfo, len(conns))
for i, conn := range conns {
out[i] = peer.AddrInfo{
ID: conn.RemotePeer(),
Addrs: []ma.Multiaddr{
conn.RemoteMultiaddr(),
},
}
}
return out, nil
}
func (a *Libp2pNetAPI) NetPeerInfo(_ context.Context, p peer.ID) (*api.ExtendedPeerInfo, error) {
info := &api.ExtendedPeerInfo{ID: p}
agent, err := a.Host.Peerstore().Get(p, "AgentVersion")
if err == nil {
info.Agent = agent.(string)
}
for _, a := range a.Host.Peerstore().Addrs(p) {
info.Addrs = append(info.Addrs, a.String())
}
sort.Strings(info.Addrs)
protocols, err := a.Host.Peerstore().GetProtocols(p)
if err == nil {
sort.Strings(protocols)
info.Protocols = protocols
}
if cm := a.Host.ConnManager().GetTagInfo(p); cm != nil {
info.ConnMgrMeta = &api.ConnMgrInfo{
FirstSeen: cm.FirstSeen,
Value: cm.Value,
Tags: cm.Tags,
Conns: cm.Conns,
}
}
return info, nil
}
func (a *Libp2pNetAPI) NetConnect(ctx context.Context, p peer.AddrInfo) error {
if swrm, ok := a.Host.Network().(*swarm.Swarm); ok {
swrm.Backoff().Clear(p.ID)
}
return a.Host.Connect(ctx, p)
}
func (a *Libp2pNetAPI) NetAddrsListen(context.Context) (peer.AddrInfo, error) {
return peer.AddrInfo{
ID: a.Host.ID(),
Addrs: a.Host.Addrs(),
}, nil
}
func (a *Libp2pNetAPI) NetDisconnect(ctx context.Context, p peer.ID) error {
return a.Host.Network().ClosePeer(p)
}
func (a *Libp2pNetAPI) NetFindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error) {
return a.Router.FindPeer(ctx, p)
}
func (a *Libp2pNetAPI) NetAutoNatStatus(ctx context.Context) (i api.NatInfo, err error) {
autonat := a.RawHost.(*basichost.BasicHost).GetAutoNat()
if autonat == nil {
return api.NatInfo{
Reachability: network.ReachabilityUnknown,
}, nil
}
var maddr string
if autonat.Status() == network.ReachabilityPublic {
pa, err := autonat.PublicAddr()
if err != nil {
return api.NatInfo{}, err
}
maddr = pa.String()
}
return api.NatInfo{
Reachability: autonat.Status(),
PublicAddr: maddr,
}, nil
}
func (a *Libp2pNetAPI) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
ag, err := a.Host.Peerstore().Get(p, "AgentVersion")
if err != nil {
return "", err
}
if ag == nil {
return "unknown", nil
}
return ag.(string), nil
}
func (a *Libp2pNetAPI) NetBandwidthStats(ctx context.Context) (metrics.Stats, error) {
return a.Reporter.GetBandwidthTotals(), nil
}
func (a *Libp2pNetAPI) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
out := make(map[string]metrics.Stats)
for p, s := range a.Reporter.GetBandwidthByPeer() {
out[p.String()] = s
}
return out, nil
}
func (a *Libp2pNetAPI) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
return a.Reporter.GetBandwidthByProtocol(), nil
}
func (a *Libp2pNetAPI) Discover(ctx context.Context) (apitypes.OpenRPCDocument, error) {
return build.OpenRPCDiscoverJSON_Full(), nil
}
func (a *Libp2pNetAPI) ID(context.Context) (peer.ID, error) {
return a.Host.ID(), nil
}

3
node/impl/storminer.go
View File

@ -15,7 +15,6 @@ import (
"github.com/filecoin-project/lotus/build"
"github.com/google/uuid"
"github.com/ipfs/go-cid"
"github.com/libp2p/go-libp2p-core/host"
"github.com/libp2p/go-libp2p-core/peer"
"golang.org/x/xerrors"
@ -59,6 +58,7 @@ type StorageMinerAPI struct {
DataTransfer dtypes.ProviderDataTransfer `optional:"true"`
DealPublisher *storageadapter.DealPublisher `optional:"true"`
SectorBlocks *sectorblocks.SectorBlocks `optional:"true"`
Host dtypes.Libp2pHost `optional:"true"`
// Miner / storage
Miner *storage.Miner `optional:"true"`
@ -67,7 +67,6 @@ type StorageMinerAPI struct {
IStorageMgr sectorstorage.SectorManager `optional:"true"`
stores.SectorIndex
storiface.WorkerReturn `optional:"true"`
Host host.Host
AddrSel *storage.AddressSelector
Epp gen.WinningPoStProver `optional:"true"`

2
node/modules/dtypes/storage.go
View File

@ -6,6 +6,7 @@ import (
"github.com/ipfs/go-graphsync"
exchange "github.com/ipfs/go-ipfs-exchange-interface"
format "github.com/ipfs/go-ipld-format"
"github.com/libp2p/go-libp2p-core/host"
"github.com/filecoin-project/go-fil-markets/storagemarket/impl/requestvalidation"
"github.com/filecoin-project/go-multistore"
@ -83,6 +84,7 @@ type ClientDataTransfer datatransfer.Manager
type ProviderDealStore *statestore.StateStore
type ProviderPieceStore piecestore.PieceStore
type Libp2pHost host.Host
type ProviderRequestValidator *requestvalidation.UnifiedRequestValidator
// ProviderDataTransfer is a data transfer manager for the provider

2
node/modules/storageminer.go
View File

@ -211,6 +211,8 @@ type StorageMinerParams struct {
}
func StorageMiner(fc config.MinerFeeConfig) func(params StorageMinerParams) (*storage.Miner, error) {
fmt.Printf("setting up storage miner with %#v \n", fc)
return func(params StorageMinerParams) (*storage.Miner, error) {
var (
ds = params.MetadataDS

4
node/testopts.go
View File

@ -10,8 +10,8 @@ import (
func MockHost(mn mocknet.Mocknet) Option {
return Options(
ApplyIf(func(s *Settings) bool { return !s.Online },
Error(errors.New("MockHost must be specified after Online")),
ApplyIf(func(s *Settings) bool { return !s.Base },
Error(errors.New("MockHost must be specified after Base")),
),
Override(new(lp2p.RawHost), lp2p.MockHost),

4
storage/miner.go
View File

@ -6,11 +6,11 @@ import (
"time"
"github.com/filecoin-project/go-bitfield"
"github.com/libp2p/go-libp2p-core/host"
"github.com/ipfs/go-cid"
"github.com/ipfs/go-datastore"
logging "github.com/ipfs/go-log/v2"
"github.com/libp2p/go-libp2p-core/host"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
@ -143,13 +143,13 @@ func NewMiner(api fullNodeFilteredAPI,
m := &Miner{
api: api,
feeCfg: feeCfg,
h: h,
sealer: sealer,
ds: ds,
sc: sc,
verif: verif,
prover: prover,
addrSel: as,
h: h,
maddr: maddr,
getSealConfig: gsd,