lotus/cmd/lotus-storage-miner/info.go

149 lines
4.1 KiB
Go
Raw Normal View History

2019-10-11 23:47:29 +00:00
package main
import (
"context"
2019-10-11 23:47:29 +00:00
"fmt"
"gopkg.in/urfave/cli.v2"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/types"
lcli "github.com/filecoin-project/lotus/cli"
sealing "github.com/filecoin-project/storage-fsm"
2019-10-11 23:47:29 +00:00
)
var infoCmd = &cli.Command{
Name: "info",
Usage: "Print storage miner info",
Action: func(cctx *cli.Context) error {
nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
if err != nil {
return err
}
defer closer()
api, acloser, err := lcli.GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer acloser()
2019-10-11 23:47:29 +00:00
ctx := lcli.ReqContext(cctx)
maddr, err := nodeApi.ActorAddress(ctx)
if err != nil {
return err
}
fmt.Printf("Miner: %s\n", maddr)
2019-11-07 10:46:11 +00:00
// Sector size
sizeByte, err := api.StateMinerSectorSize(ctx, maddr, types.EmptyTSK)
2019-11-07 10:46:11 +00:00
if err != nil {
return err
}
2019-11-07 12:05:03 +00:00
fmt.Printf("Sector Size: %s\n", types.SizeStr(types.NewInt(uint64(sizeByte))))
2019-11-07 10:46:11 +00:00
pow, err := api.StateMinerPower(ctx, maddr, types.EmptyTSK)
if err != nil {
return err
}
percI := types.BigDiv(types.BigMul(pow.MinerPower, types.NewInt(1000000)), pow.TotalPower)
fmt.Printf("Power: %s / %s (%0.4f%%)\n", types.SizeStr(pow.MinerPower), types.SizeStr(pow.TotalPower), float64(percI.Int64())/10000)
secCounts, err := api.StateMinerSectorCount(ctx, maddr, types.EmptyTSK)
if err != nil {
return err
}
faults, err := api.StateMinerFaults(ctx, maddr, types.EmptyTSK)
2020-01-30 18:38:03 +00:00
if err != nil {
return err
}
fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Sset), types.NewInt(uint64(sizeByte)))))
2020-01-30 18:38:03 +00:00
if len(faults) == 0 {
fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset), types.NewInt(uint64(sizeByte)))))
2020-01-30 18:38:03 +00:00
} else {
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(uint64(len(faults))), types.NewInt(uint64(sizeByte)))),
2020-01-31 01:27:38 +00:00
float64(10000*uint64(len(faults))/secCounts.Pset)/100.)
2020-01-30 18:38:03 +00:00
}
2020-03-03 22:19:22 +00:00
/*// TODO: indicate whether the post worker is in use
2019-11-08 18:15:13 +00:00
wstat, err := nodeApi.WorkerStats(ctx)
if err != nil {
return err
}
2019-11-21 16:23:42 +00:00
fmt.Printf("Worker use:\n")
2019-11-21 18:38:43 +00:00
fmt.Printf("\tLocal: %d / %d (+%d reserved)\n", wstat.LocalTotal-wstat.LocalReserved-wstat.LocalFree, wstat.LocalTotal-wstat.LocalReserved, wstat.LocalReserved)
fmt.Printf("\tRemote: %d / %d\n", wstat.RemotesTotal-wstat.RemotesFree, wstat.RemotesTotal)
2019-11-08 18:15:13 +00:00
fmt.Printf("Queues:\n")
fmt.Printf("\tAddPiece: %d\n", wstat.AddPieceWait)
fmt.Printf("\tPreCommit: %d\n", wstat.PreCommitWait)
fmt.Printf("\tCommit: %d\n", wstat.CommitWait)
2020-03-03 22:19:22 +00:00
fmt.Printf("\tUnseal: %d\n", wstat.UnsealWait)*/
2020-04-15 22:16:24 +00:00
/*ps, err := api.StateMinerPostState(ctx, maddr, types.EmptyTSK)
if err != nil {
return err
}
2020-02-21 18:20:22 +00:00
if ps.ProvingPeriodStart != 0 {
head, err := api.ChainHead(ctx)
if err != nil {
return err
}
2019-12-02 16:47:09 +00:00
fallback := ps.ProvingPeriodStart - head.Height()
fallbackS := fallback * build.BlockDelay
next := fallback + power.WindowedPostChallengeDuration
2019-12-02 16:47:09 +00:00
nextS := next * build.BlockDelay
fmt.Printf("PoSt Submissions:\n")
fmt.Printf("\tFallback: Epoch %d (in %d blocks, ~%dm %ds)\n", ps.ProvingPeriodStart, fallback, fallbackS/60, fallbackS%60)
2020-02-21 18:20:22 +00:00
fmt.Printf("\tDeadline: Epoch %d (in %d blocks, ~%dm %ds)\n", ps.ProvingPeriodStart+build.SlashablePowerDelay, next, nextS/60, nextS%60)
fmt.Printf("\tConsecutive Failures: %d\n", ps.NumConsecutiveFailures)
} else {
fmt.Printf("Proving Period: Not Proving\n")
2020-04-15 22:16:24 +00:00
}*/
sinfo, err := sectorsInfo(ctx, nodeApi)
2019-10-11 23:47:29 +00:00
if err != nil {
return err
}
fmt.Println("Sectors: ", sinfo)
2019-10-11 23:47:29 +00:00
// TODO: grab actr state / info
// * Sealed sectors (count / bytes)
// * Power
return nil
},
}
2020-04-06 20:23:37 +00:00
func sectorsInfo(ctx context.Context, napi api.StorageMiner) (map[sealing.SectorState]int, error) {
sectors, err := napi.SectorsList(ctx)
if err != nil {
return nil, err
}
2020-04-06 20:23:37 +00:00
out := map[sealing.SectorState]int{
"Total": len(sectors),
}
for _, s := range sectors {
st, err := napi.SectorsStatus(ctx, s)
if err != nil {
return nil, err
}
2020-04-03 16:24:45 +00:00
out[st.State]++
}
return out, nil
}