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

api: Single method for static miner info

Browse Source
This commit is contained in:
Łukasz Magiera 2020-04-16 19:36:36 +02:00
parent 8338be3a6e
commit afdfc8807d
20 changed files with 84 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
api/api_full.go
View File

@ -120,10 +120,8 @@ type FullNode interface {
StateMinerSectors(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*ChainSectorInfo, error) StateMinerSectors(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*ChainSectorInfo, error)
StateMinerProvingSet(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error) StateMinerProvingSet(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error) StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
StateMinerWorker(context.Context, address.Address, types.TipSetKey) (address.Address, error) StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error) StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error)
StateMinerPeerID(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error)
StateMinerSectorSize(context.Context, address.Address, types.TipSetKey) (abi.SectorSize, error)
StateMinerFaults(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error) StateMinerFaults(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error)
StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
StatePledgeCollateral(context.Context, types.TipSetKey) (types.BigInt, error) StatePledgeCollateral(context.Context, types.TipSetKey) (types.BigInt, error)

16
api/apistruct/struct.go
View File

@ -116,9 +116,7 @@ type FullNodeStruct struct {
StateMinerSectors func(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*api.ChainSectorInfo, error) `perm:"read"` StateMinerSectors func(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*api.ChainSectorInfo, error) `perm:"read"`
StateMinerProvingSet func(context.Context, address.Address, types.TipSetKey) ([]*api.ChainSectorInfo, error) `perm:"read"` StateMinerProvingSet func(context.Context, address.Address, types.TipSetKey) ([]*api.ChainSectorInfo, error) `perm:"read"`
StateMinerPower func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error) `perm:"read"` StateMinerPower func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error) `perm:"read"`
StateMinerWorker func(context.Context, address.Address, types.TipSetKey) (address.Address, error) `perm:"read"` StateMinerInfo func(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error) `perm:"read"`
StateMinerPeerID func(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error) `perm:"read"`
StateMinerSectorSize func(context.Context, address.Address, types.TipSetKey) (abi.SectorSize, error) `perm:"read"`
StateMinerDeadlines func(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error) `perm:"read"` StateMinerDeadlines func(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error) `perm:"read"`
StateMinerFaults func(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error) `perm:"read"` StateMinerFaults func(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error) `perm:"read"`
StateSectorPreCommitInfo func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"` StateSectorPreCommitInfo func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"`
@ -492,16 +490,8 @@ func (c *FullNodeStruct) StateMinerPower(ctx context.Context, a address.Address,
return c.Internal.StateMinerPower(ctx, a, tsk) return c.Internal.StateMinerPower(ctx, a, tsk)
} }
func (c *FullNodeStruct) StateMinerWorker(ctx context.Context, m address.Address, tsk types.TipSetKey) (address.Address, error) { func (c *FullNodeStruct) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
return c.Internal.StateMinerWorker(ctx, m, tsk) return c.Internal.StateMinerInfo(ctx, actor, tsk)
}
func (c *FullNodeStruct) StateMinerPeerID(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error) {
return c.Internal.StateMinerPeerID(ctx, m, tsk)
}
func (c *FullNodeStruct) StateMinerSectorSize(ctx context.Context, actor address.Address, tsk types.TipSetKey) (abi.SectorSize, error) {
return c.Internal.StateMinerSectorSize(ctx, actor, tsk)
} }
func (c *FullNodeStruct) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) (*miner.Deadlines, error) { func (c *FullNodeStruct) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) (*miner.Deadlines, error) {

2
build/version.go
View File

@ -31,7 +31,7 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
} }
// APIVersion is a semver version of the rpc api exposed // APIVersion is a semver version of the rpc api exposed
var APIVersion Version = newVer(0, 2, 0) var APIVersion Version = newVer(0, 3, 0)
const ( const (
majorMask = 0xff0000 majorMask = 0xff0000

41
chain/stmgr/utils.go
View File

@ -25,7 +25,6 @@ import (
cid "github.com/ipfs/go-cid" cid "github.com/ipfs/go-cid"
blockstore "github.com/ipfs/go-ipfs-blockstore" blockstore "github.com/ipfs/go-ipfs-blockstore"
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"github.com/libp2p/go-libp2p-core/peer"
cbg "github.com/whyrusleeping/cbor-gen" cbg "github.com/whyrusleeping/cbor-gen"
"golang.org/x/xerrors" "golang.org/x/xerrors"
) )
@ -56,22 +55,6 @@ func GetMinerWorkerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr
return vm.ResolveToKeyAddr(state, cst, mas.Info.Worker) return vm.ResolveToKeyAddr(state, cst, mas.Info.Worker)
} }
func GetMinerOwner(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (address.Address, error) {
var mas miner.State
_, err := sm.LoadActorStateRaw(ctx, maddr, &mas, st)
if err != nil {
return address.Undef, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
}
cst := cbor.NewCborStore(sm.cs.Blockstore())
state, err := state.LoadStateTree(cst, st)
if err != nil {
return address.Undef, xerrors.Errorf("load state tree: %w", err)
}
return vm.ResolveToKeyAddr(state, cst, mas.Info.Owner)
}
func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (types.BigInt, types.BigInt, error) { func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (types.BigInt, types.BigInt, error) {
return getPowerRaw(ctx, sm, ts.ParentState(), maddr) return getPowerRaw(ctx, sm, ts.ParentState(), maddr)
} }
@ -101,20 +84,6 @@ func getPowerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr addres
return mpow, ps.TotalQualityAdjPower, nil return mpow, ps.TotalQualityAdjPower, nil
} }
func GetMinerPeerID(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (peer.ID, error) {
var mas miner.State
_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
if err != nil {
return "", xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
}
return mas.Info.PeerId, nil
}
func GetMinerWorker(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (address.Address, error) {
return GetMinerWorkerRaw(ctx, sm, sm.parentState(ts), maddr)
}
func SectorSetSizes(ctx context.Context, sm *StateManager, maddr address.Address, ts *types.TipSet) (api.MinerSectors, error) { func SectorSetSizes(ctx context.Context, sm *StateManager, maddr address.Address, ts *types.TipSet) (api.MinerSectors, error) {
var mas miner.State var mas miner.State
_, err := sm.LoadActorState(ctx, maddr, &mas, ts) _, err := sm.LoadActorState(ctx, maddr, &mas, ts)
@ -161,8 +130,14 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
return LoadSectorsFromSet(ctx, sm.ChainStore().Blockstore(), mas.Sectors, filter) return LoadSectorsFromSet(ctx, sm.ChainStore().Blockstore(), mas.Sectors, filter)
} }
func GetMinerSectorSize(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (abi.SectorSize, error) { func StateMinerInfo(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (miner.MinerInfo, error) {
return getMinerSectorSizeRaw(ctx, sm, ts.ParentState(), maddr) var mas miner.State
_, err := sm.LoadActorStateRaw(ctx, maddr, &mas, ts.ParentState())
if err != nil {
return miner.MinerInfo{}, xerrors.Errorf("(get ssize) failed to load miner actor state: %w", err)
}
return mas.Info, nil
} }
func getMinerSectorSizeRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (abi.SectorSize, error) { func getMinerSectorSizeRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (abi.SectorSize, error) {

6
cli/client.go
View File

@ -375,16 +375,16 @@ var clientQueryAskCmd = &cli.Command{
} }
pid = p pid = p
} else { } else {
p, err := api.StateMinerPeerID(ctx, maddr, types.EmptyTSK) mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
if err != nil { if err != nil {
return xerrors.Errorf("failed to get peerID for miner: %w", err) return xerrors.Errorf("failed to get peerID for miner: %w", err)
} }
if p == peer.ID("SETME") { if mi.PeerId == peer.ID("SETME") {
return fmt.Errorf("the miner hasn't initialized yet") return fmt.Errorf("the miner hasn't initialized yet")
} }
pid = p pid = mi.PeerId
} }
ask, err := api.ClientQueryAsk(ctx, pid, maddr) ask, err := api.ClientQueryAsk(ctx, pid, maddr)

4
cli/state.go
View File

@ -594,12 +594,12 @@ var stateSectorSizeCmd = &cli.Command{
return err return err
} }
ssize, err := api.StateMinerSectorSize(ctx, addr, ts.Key()) mi, err := api.StateMinerInfo(ctx, addr, ts.Key())
if err != nil { if err != nil {
return err return err
} }
fmt.Printf("%d\n", ssize) fmt.Printf("%d\n", mi.SectorSize)
return nil return nil
}, },
} }

12
cmd/lotus-storage-miner/info.go
View File

@ -38,12 +38,12 @@ var infoCmd = &cli.Command{
fmt.Printf("Miner: %s\n", maddr) fmt.Printf("Miner: %s\n", maddr)
// Sector size // Sector size
sizeByte, err := api.StateMinerSectorSize(ctx, maddr, types.EmptyTSK) mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
if err != nil { if err != nil {
return err return err
} }
fmt.Printf("Sector Size: %s\n", types.SizeStr(types.NewInt(uint64(sizeByte)))) fmt.Printf("Sector Size: %s\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))))
pow, err := api.StateMinerPower(ctx, maddr, types.EmptyTSK) pow, err := api.StateMinerPower(ctx, maddr, types.EmptyTSK)
if err != nil { if err != nil {
@ -62,13 +62,13 @@ var infoCmd = &cli.Command{
return err return err
} }
fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Sset), types.NewInt(uint64(sizeByte))))) fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Sset), types.NewInt(uint64(mi.SectorSize)))))
if len(faults) == 0 { if len(faults) == 0 {
fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset), types.NewInt(uint64(sizeByte))))) fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset), types.NewInt(uint64(mi.SectorSize)))))
} else { } else {
fmt.Printf("\tProving: %s (%s Faulty, %.2f%%)\n", fmt.Printf("\tProving: %s (%s Faulty, %.2f%%)\n",
types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset-uint64(len(faults))), types.NewInt(uint64(sizeByte)))), types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset-uint64(len(faults))), types.NewInt(uint64(mi.SectorSize)))),
types.SizeStr(types.BigMul(types.NewInt(uint64(len(faults))), types.NewInt(uint64(sizeByte)))), types.SizeStr(types.BigMul(types.NewInt(uint64(len(faults))), types.NewInt(uint64(mi.SectorSize)))),
float64(10000*uint64(len(faults))/secCounts.Pset)/100.) float64(10000*uint64(len(faults))/secCounts.Pset)/100.)
} }

4
cmd/lotus-storage-miner/init.go
View File

@ -544,7 +544,7 @@ func makeHostKey(lr repo.LockedRepo) (crypto.PrivKey, error) {
} }
func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error { func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error {
waddr, err := api.StateMinerWorker(ctx, addr, types.EmptyTSK) mi, err := api.StateMinerInfo(ctx, addr, types.EmptyTSK)
if err != nil { if err != nil {
return xerrors.Errorf("getWorkerAddr returned bad address: %w", err) return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
} }
@ -556,7 +556,7 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
msg := &types.Message{ msg := &types.Message{
To: addr, To: addr,
From: waddr, From: mi.Worker,
Method: builtin.MethodsMiner.ChangePeerID, Method: builtin.MethodsMiner.ChangePeerID,
Params: enc, Params: enc,
Value: types.NewInt(0), Value: types.NewInt(0),

8
cmd/lotus-storage-miner/rewards.go
View File

@ -42,7 +42,7 @@ var rewardsRedeemCmd = &cli.Command{
return err return err
} }
worker, err := api.StateMinerWorker(ctx, maddr, types.EmptyTSK) mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
if err != nil { if err != nil {
return err return err
} }
@ -52,16 +52,16 @@ var rewardsRedeemCmd = &cli.Command{
return err return err
} }
workerNonce, err := api.MpoolGetNonce(ctx, worker) workerNonce, err := api.MpoolGetNonce(ctx, mi.Worker)
if err != nil { if err != nil {
return err return err
} }
panic("todo correct method; call miner actor") panic("todo correct method; call miner actor")
smsg, err := api.WalletSignMessage(ctx, worker, &types.Message{ smsg, err := api.WalletSignMessage(ctx, mi.Worker, &types.Message{
To: builtin.RewardActorAddr, To: builtin.RewardActorAddr,
From: worker, From: mi.Worker,
Nonce: workerNonce, Nonce: workerNonce,
Value: types.NewInt(0), Value: types.NewInt(0),
GasPrice: types.NewInt(1), GasPrice: types.NewInt(1),

4
markets/retrievaladapter/provider.go
View File

@ -35,8 +35,8 @@ func (rpn *retrievalProviderNode) GetMinerWorkerAddress(ctx context.Context, min
return address.Undef, err return address.Undef, err
} }
addr, err := rpn.full.StateMinerWorker(ctx, miner, tsk) mi, err := rpn.full.StateMinerInfo(ctx, miner, tsk)
return addr, err return mi.Worker, err
} }
func (rpn *retrievalProviderNode) UnsealSector(ctx context.Context, sectorID uint64, offset uint64, length uint64) (io.ReadCloser, error) { func (rpn *retrievalProviderNode) UnsealSector(ctx context.Context, sectorID uint64, offset uint64, length uint64) (io.ReadCloser, error) {

21
markets/storageadapter/client.go
View File

@ -72,21 +72,12 @@ func (n *ClientNodeAdapter) ListStorageProviders(ctx context.Context, encodedTs
var out []*storagemarket.StorageProviderInfo var out []*storagemarket.StorageProviderInfo
for _, addr := range addresses { for _, addr := range addresses {
workerAddr, err := n.StateMinerWorker(ctx, addr, tsk) mi, err := n.StateMinerInfo(ctx, addr, tsk)
if err != nil { if err != nil {
return nil, err return nil, err
} }
sectorSize, err := n.StateMinerSectorSize(ctx, addr, tsk) storageProviderInfo := utils.NewStorageProviderInfo(addr, mi.Worker, mi.SectorSize, mi.PeerId)
if err != nil {
return nil, err
}
peerID, err := n.StateMinerPeerID(ctx, addr, tsk)
if err != nil {
return nil, err
}
storageProviderInfo := utils.NewStorageProviderInfo(addr, workerAddr, sectorSize, peerID)
out = append(out, &storageProviderInfo) out = append(out, &storageProviderInfo)
} }
@ -176,12 +167,12 @@ func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal stor
return 0, xerrors.Errorf("getting deal pubsish message: %w", err) return 0, xerrors.Errorf("getting deal pubsish message: %w", err)
} }
pw, err := stmgr.GetMinerWorker(ctx, c.sm, nil, deal.Proposal.Provider) mi, err := stmgr.StateMinerInfo(ctx, c.sm, nil, deal.Proposal.Provider)
if err != nil { if err != nil {
return 0, xerrors.Errorf("getting miner worker failed: %w", err) return 0, xerrors.Errorf("getting miner worker failed: %w", err)
} }
if pubmsg.From != pw { if pubmsg.From != mi.Worker {
return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider) return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider)
} }
@ -363,7 +354,7 @@ func (n *ClientNodeAdapter) ValidateAskSignature(ctx context.Context, ask *stora
return false, err return false, err
} }
w, err := n.StateMinerWorker(ctx, ask.Ask.Miner, tsk) mi, err := n.StateMinerInfo(ctx, ask.Ask.Miner, tsk)
if err != nil { if err != nil {
return false, xerrors.Errorf("failed to get worker for miner in ask", err) return false, xerrors.Errorf("failed to get worker for miner in ask", err)
} }
@ -373,7 +364,7 @@ func (n *ClientNodeAdapter) ValidateAskSignature(ctx context.Context, ask *stora
return false, xerrors.Errorf("failed to re-serialize ask") return false, xerrors.Errorf("failed to re-serialize ask")
} }
err = sigs.Verify(ask.Signature, w, sigb) err = sigs.Verify(ask.Signature, mi.Worker, sigb)
return err == nil, err return err == nil, err
} }

10
markets/storageadapter/provider.go
View File

@ -56,7 +56,7 @@ func NewProviderNodeAdapter(dag dtypes.StagingDAG, secb *sectorblocks.SectorBloc
func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemarket.MinerDeal) (abi.DealID, cid.Cid, error) { func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemarket.MinerDeal) (abi.DealID, cid.Cid, error) {
log.Info("publishing deal") log.Info("publishing deal")
worker, err := n.StateMinerWorker(ctx, deal.Proposal.Provider, types.EmptyTSK) mi, err := n.StateMinerInfo(ctx, deal.Proposal.Provider, types.EmptyTSK)
if err != nil { if err != nil {
return 0, cid.Undef, err return 0, cid.Undef, err
} }
@ -72,7 +72,7 @@ func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemark
// TODO: We may want this to happen after fetching data // TODO: We may want this to happen after fetching data
smsg, err := n.MpoolPushMessage(ctx, &types.Message{ smsg, err := n.MpoolPushMessage(ctx, &types.Message{
To: builtin.StorageMarketActorAddr, To: builtin.StorageMarketActorAddr,
From: worker, From: mi.Worker,
Value: types.NewInt(0), Value: types.NewInt(0),
GasPrice: types.NewInt(0), GasPrice: types.NewInt(0),
GasLimit: 1000000, GasLimit: 1000000,
@ -150,7 +150,11 @@ func (n *ProviderNodeAdapter) GetMinerWorkerAddress(ctx context.Context, miner a
return address.Undef, err return address.Undef, err
} }
return n.StateMinerWorker(ctx, miner, tsk) mi, err := n.StateMinerInfo(ctx, miner, tsk)
if err != nil {
return address.Address{}, err
}
return mi.Worker, nil
} }
func (n *ProviderNodeAdapter) SignBytes(ctx context.Context, signer address.Address, b []byte) (*crypto.Signature, error) { func (n *ProviderNodeAdapter) SignBytes(ctx context.Context, signer address.Address, b []byte) (*crypto.Signature, error) {

4
miner/miner.go
View File

@ -361,7 +361,7 @@ func (m *Miner) mineOne(ctx context.Context, addr address.Address, base *MiningB
} }
func (m *Miner) computeTicket(ctx context.Context, addr address.Address, brand *types.BeaconEntry, base *MiningBase) (*types.Ticket, error) { func (m *Miner) computeTicket(ctx context.Context, addr address.Address, brand *types.BeaconEntry, base *MiningBase) (*types.Ticket, error) {
w, err := m.api.StateMinerWorker(ctx, addr, types.EmptyTSK) mi, err := m.api.StateMinerInfo(ctx, addr, types.EmptyTSK)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -376,7 +376,7 @@ func (m *Miner) computeTicket(ctx context.Context, addr address.Address, brand *
return nil, err return nil, err
} }
vrfOut, err := gen.ComputeVRF(ctx, m.api.WalletSign, w, input) vrfOut, err := gen.ComputeVRF(ctx, m.api.WalletSign, mi.Worker, input)
if err != nil { if err != nil {
return nil, err return nil, err
} }

20
node/impl/client/client.go
View File

@ -70,27 +70,17 @@ func (a *API) ClientStartDeal(ctx context.Context, params *api.StartDealParams)
return nil, xerrors.Errorf("provided address doesn't exist in wallet") return nil, xerrors.Errorf("provided address doesn't exist in wallet")
} }
pid, err := a.StateMinerPeerID(ctx, params.Miner, types.EmptyTSK) mi, err := a.StateMinerInfo(ctx, params.Miner, types.EmptyTSK)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed getting peer ID: %w", err) return nil, xerrors.Errorf("failed getting peer ID: %w", err)
} }
mw, err := a.StateMinerWorker(ctx, params.Miner, types.EmptyTSK) rt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
if err != nil {
return nil, xerrors.Errorf("failed getting miner worker: %w", err)
}
ssize, err := a.StateMinerSectorSize(ctx, params.Miner, types.EmptyTSK)
if err != nil {
return nil, xerrors.Errorf("failed checking miners sector size: %w", err)
}
rt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
if err != nil { if err != nil {
return nil, xerrors.Errorf("bad sector size: %w", err) return nil, xerrors.Errorf("bad sector size: %w", err)
} }
providerInfo := utils.NewStorageProviderInfo(params.Miner, mw, 0, pid) providerInfo := utils.NewStorageProviderInfo(params.Miner, mi.Worker, 0, mi.PeerId)
ts, err := a.ChainHead(ctx) ts, err := a.ChainHead(ctx)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed getting chain height: %w", err) return nil, xerrors.Errorf("failed getting chain height: %w", err)
@ -333,12 +323,12 @@ func (a *API) ClientListImports(ctx context.Context) ([]api.Import, error) {
func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref api.FileRef) error { func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref api.FileRef) error {
if order.MinerPeerID == "" { if order.MinerPeerID == "" {
pid, err := a.StateMinerPeerID(ctx, order.Miner, types.EmptyTSK) mi, err := a.StateMinerInfo(ctx, order.Miner, types.EmptyTSK)
if err != nil { if err != nil {
return err return err
} }
order.MinerPeerID = pid order.MinerPeerID = mi.PeerId
} }
if order.Size == 0 { if order.Size == 0 {

23
node/impl/full/state.go
View File

@ -9,7 +9,6 @@ import (
cid "github.com/ipfs/go-cid" cid "github.com/ipfs/go-cid"
"github.com/ipfs/go-hamt-ipld" "github.com/ipfs/go-hamt-ipld"
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"github.com/libp2p/go-libp2p-core/peer"
cbg "github.com/whyrusleeping/cbor-gen" cbg "github.com/whyrusleeping/cbor-gen"
"go.uber.org/fx" "go.uber.org/fx"
"golang.org/x/xerrors" "golang.org/x/xerrors"
@ -72,28 +71,12 @@ func (a *StateAPI) StateMinerProvingSet(ctx context.Context, addr address.Addres
return stmgr.GetProvingSetRaw(ctx, a.StateManager, mas) return stmgr.GetProvingSetRaw(ctx, a.StateManager, mas)
} }
func (a *StateAPI) StateMinerWorker(ctx context.Context, m address.Address, tsk types.TipSetKey) (address.Address, error) { func (a *StateAPI) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(tsk)
if err != nil { if err != nil {
return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err) return miner.MinerInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
return stmgr.GetMinerWorker(ctx, a.StateManager, ts, m) return stmgr.StateMinerInfo(ctx, a.StateManager, ts, actor)
}
func (a *StateAPI) StateMinerPeerID(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk)
if err != nil {
return "", xerrors.Errorf("loading tipset %s: %w", tsk, err)
}
return stmgr.GetMinerPeerID(ctx, a.StateManager, ts, m)
}
func (a *StateAPI) StateMinerSectorSize(ctx context.Context, actor address.Address, tsk types.TipSetKey) (abi.SectorSize, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk)
if err != nil {
return 0, xerrors.Errorf("loading tipset %s: %w", tsk, err)
}
return stmgr.GetMinerSectorSize(ctx, a.StateManager, ts, actor)
} }
func (a *StateAPI) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) (*miner.Deadlines, error) { func (a *StateAPI) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) (*miner.Deadlines, error) {

6
node/impl/storminer.go
View File

@ -60,7 +60,11 @@ func (sm *StorageMinerAPI) ActorAddress(context.Context) (address.Address, error
} }
func (sm *StorageMinerAPI) ActorSectorSize(ctx context.Context, addr address.Address) (abi.SectorSize, error) { func (sm *StorageMinerAPI) ActorSectorSize(ctx context.Context, addr address.Address) (abi.SectorSize, error) {
return sm.Full.StateMinerSectorSize(ctx, addr, types.EmptyTSK) mi, err := sm.Full.StateMinerInfo(ctx, addr, types.EmptyTSK)
if err != nil {
return 0, err
}
return mi.SectorSize, nil
} }
func (sm *StorageMinerAPI) PledgeSector(ctx context.Context) error { func (sm *StorageMinerAPI) PledgeSector(ctx context.Context) error {

14
node/modules/storageminer.go
View File

@ -91,12 +91,12 @@ func StorageNetworkName(ctx helpers.MetricsCtx, a lapi.FullNode) (dtypes.Network
} }
func ProofsConfig(maddr dtypes.MinerAddress, fnapi lapi.FullNode) (*ffiwrapper.Config, error) { func ProofsConfig(maddr dtypes.MinerAddress, fnapi lapi.FullNode) (*ffiwrapper.Config, error) {
ssize, err := fnapi.StateMinerSectorSize(context.TODO(), address.Address(maddr), types.EmptyTSK) mi, err := fnapi.StateMinerInfo(context.TODO(), address.Address(maddr), types.EmptyTSK)
if err != nil { if err != nil {
return nil, err return nil, err
} }
spt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize) spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
if err != nil { if err != nil {
return nil, xerrors.Errorf("bad sector size: %w", err) return nil, xerrors.Errorf("bad sector size: %w", err)
} }
@ -130,17 +130,17 @@ func StorageMiner(mctx helpers.MetricsCtx, lc fx.Lifecycle, api lapi.FullNode, h
ctx := helpers.LifecycleCtx(mctx, lc) ctx := helpers.LifecycleCtx(mctx, lc)
worker, err := api.StateMinerWorker(ctx, maddr, types.EmptyTSK) mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
if err != nil { if err != nil {
return nil, err return nil, err
} }
fps, err := storage.NewWindowedPoStScheduler(api, sealer, maddr, worker) fps, err := storage.NewWindowedPoStScheduler(api, sealer, maddr, mi.Worker)
if err != nil { if err != nil {
return nil, err return nil, err
} }
sm, err := storage.NewMiner(api, maddr, worker, h, ds, sealer, sc, verif, tktFn) sm, err := storage.NewMiner(api, maddr, mi.Worker, h, ds, sealer, sc, verif, tktFn)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -317,12 +317,12 @@ func StorageProvider(ctx helpers.MetricsCtx, fapi lapi.FullNode, h host.Host, ds
return nil, err return nil, err
} }
ssize, err := fapi.StateMinerSectorSize(ctx, minerAddress, types.EmptyTSK) mi, err := fapi.StateMinerInfo(ctx, minerAddress, types.EmptyTSK)
if err != nil { if err != nil {
return nil, err return nil, err
} }
rt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize) rt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
if err != nil { if err != nil {
return nil, err return nil, err
} }

14
storage/adapter_storage_miner.go
View File

@ -40,7 +40,12 @@ func (s SealingAPIAdapter) StateMinerSectorSize(ctx context.Context, maddr addre
return 0, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) return 0, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
} }
return s.delegate.StateMinerSectorSize(ctx, maddr, tsk) // TODO: update storage-fsm to just StateMinerInfo
mi, err := s.delegate.StateMinerInfo(ctx, maddr, tsk)
if err != nil {
return 0, err
}
return mi.SectorSize, nil
} }
func (s SealingAPIAdapter) StateMinerWorkerAddress(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (address.Address, error) { func (s SealingAPIAdapter) StateMinerWorkerAddress(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (address.Address, error) {
@ -49,7 +54,12 @@ func (s SealingAPIAdapter) StateMinerWorkerAddress(ctx context.Context, maddr ad
return address.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) return address.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
} }
return s.delegate.StateMinerWorker(ctx, maddr, tsk) // TODO: update storage-fsm to just StateMinerInfo
mi, err := s.delegate.StateMinerInfo(ctx, maddr, tsk)
if err != nil {
return address.Undef, err
}
return mi.Worker, nil
} }
func (s SealingAPIAdapter) StateMinerDeadlines(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (*miner.Deadlines, error) { func (s SealingAPIAdapter) StateMinerDeadlines(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (*miner.Deadlines, error) {

7
storage/miner.go
View File

@ -49,11 +49,10 @@ type Miner struct {
type storageMinerApi interface { type storageMinerApi interface {
// Call a read only method on actors (no interaction with the chain required) // Call a read only method on actors (no interaction with the chain required)
StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error) StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error)
StateMinerWorker(context.Context, address.Address, types.TipSetKey) (address.Address, error)
StateMinerDeadlines(ctx context.Context, maddr address.Address, tok types.TipSetKey) (*miner.Deadlines, error) StateMinerDeadlines(ctx context.Context, maddr address.Address, tok types.TipSetKey) (*miner.Deadlines, error)
StateMinerSectors(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*api.ChainSectorInfo, error) StateMinerSectors(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*api.ChainSectorInfo, error)
StateMinerSectorSize(context.Context, address.Address, types.TipSetKey) (abi.SectorSize, error)
StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
StateWaitMsg(context.Context, cid.Cid) (*api.MsgLookup, error) // TODO: removeme eventually StateWaitMsg(context.Context, cid.Cid) (*api.MsgLookup, error) // TODO: removeme eventually
StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error) StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
@ -138,12 +137,12 @@ func NewWinningPoStProver(api api.FullNode, sb storage.Prover, miner dtypes.Mine
return nil, err return nil, err
} }
mss, err := api.StateMinerSectorSize(context.TODO(), ma, types.EmptyTSK) mi, err := api.StateMinerInfo(context.TODO(), ma, types.EmptyTSK)
if err != nil { if err != nil {
return nil, xerrors.Errorf("getting sector size: %w", err) return nil, xerrors.Errorf("getting sector size: %w", err)
} }
spt, err := ffiwrapper.SealProofTypeFromSectorSize(mss) spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
storage/wdpost_sched.go
View File

@ -37,12 +37,12 @@ type WindowPoStScheduler struct {
} }
func NewWindowedPoStScheduler(api storageMinerApi, sb storage.Prover, actor address.Address, worker address.Address) (*WindowPoStScheduler, error) { func NewWindowedPoStScheduler(api storageMinerApi, sb storage.Prover, actor address.Address, worker address.Address) (*WindowPoStScheduler, error) {
mss, err := api.StateMinerSectorSize(context.TODO(), actor, types.EmptyTSK) mi, err := api.StateMinerInfo(context.TODO(), actor, types.EmptyTSK)
if err != nil { if err != nil {
return nil, xerrors.Errorf("getting sector size: %w", err) return nil, xerrors.Errorf("getting sector size: %w", err)
} }
spt, err := ffiwrapper.SealProofTypeFromSectorSize(mss) spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
if err != nil { if err != nil {
return nil, err return nil, err
} }