lotus/cmd/lotus-miner/info.go

683 lines
20 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"
"math"
corebig "math/big"
"os"
2020-05-01 12:06:19 +00:00
"sort"
"strings"
"text/tabwriter"
2020-06-04 15:10:41 +00:00
"time"
2019-10-11 23:47:29 +00:00
2020-05-01 12:06:19 +00:00
"github.com/fatih/color"
2022-06-14 15:00:51 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
2021-08-27 11:36:40 +00:00
"github.com/mattn/go-isatty"
"github.com/urfave/cli/v2"
2020-06-05 22:59:01 +00:00
"golang.org/x/xerrors"
2019-10-11 23:47:29 +00:00
2021-01-05 09:53:27 +00:00
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-fil-markets/retrievalmarket"
"github.com/filecoin-project/go-fil-markets/storagemarket"
2020-09-07 03:49:10 +00:00
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big"
2021-01-05 09:53:27 +00:00
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/api/v1api"
"github.com/filecoin-project/lotus/blockstore"
2020-06-04 15:10:41 +00:00
"github.com/filecoin-project/lotus/build"
2020-09-18 21:46:42 +00:00
"github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
2021-01-05 09:53:27 +00:00
"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
"github.com/filecoin-project/lotus/chain/types"
lcli "github.com/filecoin-project/lotus/cli"
2021-08-17 13:29:38 +00:00
"github.com/filecoin-project/lotus/journal/alerting"
sealing "github.com/filecoin-project/lotus/storage/pipeline"
"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
2019-10-11 23:47:29 +00:00
)
var infoCmd = &cli.Command{
Name: "info",
Usage: "Print miner info",
2020-08-04 18:57:40 +00:00
Subcommands: []*cli.Command{
infoAllCmd,
},
Flags: []cli.Flag{
&cli.BoolFlag{
Name: "hide-sectors-info",
Usage: "hide sectors info",
},
2021-01-05 09:53:27 +00:00
&cli.IntFlag{
Name: "blocks",
Usage: "Log of produced <blocks> newest blocks and rewards(Miner Fee excluded)",
},
},
2020-08-04 18:57:40 +00:00
Action: infoCmdAct,
}
2020-05-01 12:06:19 +00:00
2020-08-04 18:57:40 +00:00
func infoCmdAct(cctx *cli.Context) error {
2021-07-29 11:51:26 +00:00
minerApi, closer, err := lcli.GetStorageMinerAPI(cctx)
if err != nil {
return err
}
defer closer()
marketsApi, closer, err := lcli.GetMarketsAPI(cctx)
2020-08-04 18:57:40 +00:00
if err != nil {
return err
}
defer closer()
fullapi, acloser, err := lcli.GetFullNodeAPIV1(cctx)
2020-08-04 18:57:40 +00:00
if err != nil {
return err
}
defer acloser()
ctx := lcli.ReqContext(cctx)
2021-07-29 11:51:26 +00:00
subsystems, err := minerApi.RuntimeSubsystems(ctx)
if err != nil {
return err
}
fmt.Println("Enabled subsystems (from miner API):", subsystems)
subsystems, err = marketsApi.RuntimeSubsystems(ctx)
if err != nil {
return err
}
2021-07-29 11:51:26 +00:00
fmt.Println("Enabled subsystems (from markets API):", subsystems)
start, err := fullapi.StartTime(ctx)
if err != nil {
return err
}
fmt.Printf("StartTime: %s (started at %s)\n", time.Now().Sub(start).Truncate(time.Second), start.Truncate(time.Second))
2020-12-01 17:56:43 +00:00
fmt.Print("Chain: ")
2020-10-30 18:39:31 +00:00
err = lcli.SyncBasefeeCheck(ctx, fullapi)
2020-10-30 18:39:31 +00:00
if err != nil {
return err
}
fmt.Println()
2021-08-17 13:29:38 +00:00
alerts, err := minerApi.LogAlerts(ctx)
if err != nil {
fmt.Printf("ERROR: getting alerts: %s\n", err)
2021-08-17 13:29:38 +00:00
}
activeAlerts := make([]alerting.Alert, 0)
for _, alert := range alerts {
if alert.Active {
activeAlerts = append(activeAlerts, alert)
}
}
if len(activeAlerts) > 0 {
fmt.Printf("%s (check %s)\n", color.RedString("⚠ %d Active alerts", len(activeAlerts)), color.YellowString("lotus-miner log alerts"))
}
2021-07-29 11:51:26 +00:00
err = handleMiningInfo(ctx, cctx, fullapi, minerApi)
if err != nil {
return err
}
2020-08-04 18:57:40 +00:00
2021-07-29 11:51:26 +00:00
err = handleMarketsInfo(ctx, marketsApi)
if err != nil {
return err
}
2020-08-04 18:57:40 +00:00
return nil
}
2020-08-04 18:57:40 +00:00
func handleMiningInfo(ctx context.Context, cctx *cli.Context, fullapi v1api.FullNode, nodeApi api.StorageMiner) error {
maddr, err := getActorAddress(ctx, cctx)
if err != nil {
return err
}
2020-08-04 18:57:40 +00:00
mact, err := fullapi.StateGetActor(ctx, maddr, types.EmptyTSK)
if err != nil {
return err
}
2020-08-04 18:57:40 +00:00
tbs := blockstore.NewTieredBstore(blockstore.NewAPIBlockstore(fullapi), blockstore.NewMemory())
2021-01-05 09:53:27 +00:00
mas, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), mact)
if err != nil {
return err
}
// Sector size
mi, err := fullapi.StateMinerInfo(ctx, maddr, types.EmptyTSK)
2021-01-05 09:53:27 +00:00
if err != nil {
return err
}
ssize := types.SizeStr(types.NewInt(uint64(mi.SectorSize)))
fmt.Printf("Miner: %s (%s sectors)\n", color.BlueString("%s", maddr), ssize)
pow, err := fullapi.StateMinerPower(ctx, maddr, types.EmptyTSK)
if err != nil {
return err
}
fmt.Printf("Power: %s / %s (%0.4f%%)\n",
color.GreenString(types.DeciStr(pow.MinerPower.QualityAdjPower)),
types.DeciStr(pow.TotalPower.QualityAdjPower),
types.BigDivFloat(
types.BigMul(pow.MinerPower.QualityAdjPower, big.NewInt(100)),
pow.TotalPower.QualityAdjPower,
),
)
fmt.Printf("\tRaw: %s / %s (%0.4f%%)\n",
color.BlueString(types.SizeStr(pow.MinerPower.RawBytePower)),
types.SizeStr(pow.TotalPower.RawBytePower),
types.BigDivFloat(
types.BigMul(pow.MinerPower.RawBytePower, big.NewInt(100)),
pow.TotalPower.RawBytePower,
),
)
secCounts, err := fullapi.StateMinerSectorCount(ctx, maddr, types.EmptyTSK)
2021-01-05 09:53:27 +00:00
if err != nil {
return err
}
proving := secCounts.Active + secCounts.Faulty
nfaults := secCounts.Faulty
fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Live), types.NewInt(uint64(mi.SectorSize)))))
if nfaults == 0 {
fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(proving), types.NewInt(uint64(mi.SectorSize)))))
} else {
var faultyPercentage float64
if secCounts.Live != 0 {
faultyPercentage = float64(100*nfaults) / float64(secCounts.Live)
}
fmt.Printf("\tProving: %s (%s Faulty, %.2f%%)\n",
types.SizeStr(types.BigMul(types.NewInt(proving), types.NewInt(uint64(mi.SectorSize)))),
types.SizeStr(types.BigMul(types.NewInt(nfaults), types.NewInt(uint64(mi.SectorSize)))),
faultyPercentage)
}
2020-08-04 18:57:40 +00:00
if !pow.HasMinPower {
fmt.Print("Below minimum power threshold, no blocks will be won")
} else {
winRatio := new(corebig.Rat).SetFrac(
types.BigMul(pow.MinerPower.QualityAdjPower, types.NewInt(build.BlocksPerEpoch)).Int,
pow.TotalPower.QualityAdjPower.Int,
)
if winRatioFloat, _ := winRatio.Float64(); winRatioFloat > 0 {
2020-08-04 18:57:40 +00:00
// if the corresponding poisson distribution isn't infinitely small then
// throw it into the mix as well, accounting for multi-wins
winRationWithPoissonFloat := -math.Expm1(-winRatioFloat)
winRationWithPoisson := new(corebig.Rat).SetFloat64(winRationWithPoissonFloat)
if winRationWithPoisson != nil {
winRatio = winRationWithPoisson
winRatioFloat = winRationWithPoissonFloat
}
2020-08-04 18:57:40 +00:00
weekly, _ := new(corebig.Rat).Mul(
winRatio,
new(corebig.Rat).SetInt64(7*builtin.EpochsInDay),
).Float64()
avgDuration, _ := new(corebig.Rat).Mul(
new(corebig.Rat).SetInt64(builtin.EpochDurationSeconds),
new(corebig.Rat).Inv(winRatio),
).Float64()
fmt.Print("Projected average block win rate: ")
color.Blue(
"%.02f/week (every %s)",
weekly,
(time.Second * time.Duration(avgDuration)).Truncate(time.Second).String(),
)
// Geometric distribution of P(Y < k) calculated as described in https://en.wikipedia.org/wiki/Geometric_distribution#Probability_Outcomes_Examples
// https://www.wolframalpha.com/input/?i=t+%3E+0%3B+p+%3E+0%3B+p+%3C+1%3B+c+%3E+0%3B+c+%3C1%3B+1-%281-p%29%5E%28t%29%3Dc%3B+solve+t
// t == how many dice-rolls (epochs) before win
// p == winRate == ( minerPower / netPower )
// c == target probability of win ( 99.9% in this case )
fmt.Print("Projected block win with ")
color.Green(
"99.9%% probability every %s",
(time.Second * time.Duration(
builtin.EpochDurationSeconds*math.Log(1-0.999)/
math.Log(1-winRatioFloat),
)).Truncate(time.Second).String(),
)
fmt.Println("(projections DO NOT account for future network and miner growth)")
}
}
fmt.Println()
spendable := big.Zero()
2020-12-01 18:15:20 +00:00
// NOTE: there's no need to unlock anything here. Funds only
// vest on deadline boundaries, and they're unlocked by cron.
lockedFunds, err := mas.LockedFunds()
if err != nil {
return xerrors.Errorf("getting locked funds: %w", err)
}
availBalance, err := mas.AvailableBalance(mact.Balance)
if err != nil {
return xerrors.Errorf("getting available balance: %w", err)
}
if availBalance.GreaterThan(big.Zero()) {
spendable = big.Add(spendable, availBalance)
}
fmt.Printf("Miner Balance: %s\n", color.YellowString("%s", types.FIL(mact.Balance).Short()))
fmt.Printf(" PreCommit: %s\n", types.FIL(lockedFunds.PreCommitDeposits).Short())
fmt.Printf(" Pledge: %s\n", types.FIL(lockedFunds.InitialPledgeRequirement).Short())
fmt.Printf(" Vesting: %s\n", types.FIL(lockedFunds.VestingFunds).Short())
colorTokenAmount(" Available: %s\n", availBalance)
mb, err := fullapi.StateMarketBalance(ctx, maddr, types.EmptyTSK)
2021-01-05 09:53:27 +00:00
if err != nil {
return xerrors.Errorf("getting market balance: %w", err)
}
spendable = big.Add(spendable, big.Sub(mb.Escrow, mb.Locked))
fmt.Printf("Market Balance: %s\n", types.FIL(mb.Escrow).Short())
fmt.Printf(" Locked: %s\n", types.FIL(mb.Locked).Short())
colorTokenAmount(" Available: %s\n", big.Sub(mb.Escrow, mb.Locked))
wb, err := fullapi.WalletBalance(ctx, mi.Worker)
2021-01-05 09:53:27 +00:00
if err != nil {
return xerrors.Errorf("getting worker balance: %w", err)
}
spendable = big.Add(spendable, wb)
color.Cyan("Worker Balance: %s", types.FIL(wb).Short())
if len(mi.ControlAddresses) > 0 {
cbsum := big.Zero()
for _, ca := range mi.ControlAddresses {
b, err := fullapi.WalletBalance(ctx, ca)
if err != nil {
return xerrors.Errorf("getting control address balance: %w", err)
}
cbsum = big.Add(cbsum, b)
}
spendable = big.Add(spendable, cbsum)
fmt.Printf(" Control: %s\n", types.FIL(cbsum).Short())
}
colorTokenAmount("Total Spendable: %s\n", spendable)
if mi.Beneficiary != address.Undef {
fmt.Println()
fmt.Printf("Beneficiary:\t%s\n", mi.Beneficiary)
if mi.Beneficiary != mi.Owner {
fmt.Printf("Beneficiary Quota:\t%s\n", mi.BeneficiaryTerm.Quota)
fmt.Printf("Beneficiary Used Quota:\t%s\n", mi.BeneficiaryTerm.UsedQuota)
fmt.Printf("Beneficiary Expiration:\t%s\n", mi.BeneficiaryTerm.Expiration)
}
}
if mi.PendingBeneficiaryTerm != nil {
fmt.Printf("Pending Beneficiary Term:\n")
fmt.Printf("New Beneficiary:\t%s\n", mi.PendingBeneficiaryTerm.NewBeneficiary)
fmt.Printf("New Quota:\t%s\n", mi.PendingBeneficiaryTerm.NewQuota)
fmt.Printf("New Expiration:\t%s\n", mi.PendingBeneficiaryTerm.NewExpiration)
fmt.Printf("Approved By Beneficiary:\t%t\n", mi.PendingBeneficiaryTerm.ApprovedByBeneficiary)
fmt.Printf("Approved By Nominee:\t%t\n", mi.PendingBeneficiaryTerm.ApprovedByNominee)
}
fmt.Println()
if !cctx.Bool("hide-sectors-info") {
fmt.Println("Sectors:")
err = sectorsInfo(ctx, nodeApi)
if err != nil {
return err
}
}
{
fmt.Println()
ws, err := nodeApi.WorkerStats(ctx)
if err != nil {
return xerrors.Errorf("getting worker stats: %w", err)
}
2022-03-24 22:28:45 +00:00
workersByType := map[string]int{
sealtasks.WorkerSealing: 0,
sealtasks.WorkerWindowPoSt: 0,
sealtasks.WorkerWinningPoSt: 0,
}
wloop:
for _, st := range ws {
if !st.Enabled {
continue
}
for _, task := range st.Tasks {
2022-03-24 22:28:45 +00:00
if task.WorkerType() != sealtasks.WorkerSealing {
workersByType[task.WorkerType()]++
continue wloop
}
}
2022-03-24 22:28:45 +00:00
workersByType[sealtasks.WorkerSealing]++
}
2022-03-24 22:28:45 +00:00
fmt.Printf("Workers: Seal(%d) WdPoSt(%d) WinPoSt(%d)\n",
workersByType[sealtasks.WorkerSealing],
workersByType[sealtasks.WorkerWindowPoSt],
workersByType[sealtasks.WorkerWinningPoSt])
}
2021-01-05 09:53:27 +00:00
if cctx.IsSet("blocks") {
fmt.Println("Produced newest blocks:")
2021-08-04 07:49:35 +00:00
err = producedBlocks(ctx, cctx.Int("blocks"), maddr, fullapi)
2021-01-05 09:53:27 +00:00
if err != nil {
return err
}
}
return nil
}
func handleMarketsInfo(ctx context.Context, nodeApi api.StorageMiner) error {
deals, err := nodeApi.MarketListIncompleteDeals(ctx)
if err != nil {
return err
}
type dealStat struct {
count, verifCount int
bytes, verifBytes uint64
}
dsAdd := func(ds *dealStat, deal storagemarket.MinerDeal) {
ds.count++
ds.bytes += uint64(deal.Proposal.PieceSize)
if deal.Proposal.VerifiedDeal {
ds.verifCount++
ds.verifBytes += uint64(deal.Proposal.PieceSize)
}
}
showDealStates := map[storagemarket.StorageDealStatus]struct{}{
2021-09-10 10:21:33 +00:00
storagemarket.StorageDealActive: {},
storagemarket.StorageDealAcceptWait: {},
storagemarket.StorageDealReserveProviderFunds: {},
storagemarket.StorageDealProviderFunding: {},
storagemarket.StorageDealTransferring: {},
storagemarket.StorageDealValidating: {},
storagemarket.StorageDealStaged: {},
storagemarket.StorageDealAwaitingPreCommit: {},
storagemarket.StorageDealSealing: {},
storagemarket.StorageDealPublish: {},
storagemarket.StorageDealCheckForAcceptance: {},
storagemarket.StorageDealPublishing: {},
}
2020-08-04 18:57:40 +00:00
var total dealStat
perState := map[storagemarket.StorageDealStatus]*dealStat{}
for _, deal := range deals {
if _, ok := showDealStates[deal.State]; !ok {
continue
}
if perState[deal.State] == nil {
perState[deal.State] = new(dealStat)
}
dsAdd(&total, deal)
dsAdd(perState[deal.State], deal)
}
2020-12-01 18:22:57 +00:00
type wstr struct {
str string
status storagemarket.StorageDealStatus
}
sorted := make([]wstr, 0, len(perState))
for status, stat := range perState {
st := strings.TrimPrefix(storagemarket.DealStates[status], "StorageDeal")
sorted = append(sorted, wstr{
str: fmt.Sprintf(" %s:\t%d\t\t%s\t(Verified: %d\t%s)\n", st, stat.count, types.SizeStr(types.NewInt(stat.bytes)), stat.verifCount, types.SizeStr(types.NewInt(stat.verifBytes))),
status: status,
},
)
}
sort.Slice(sorted, func(i, j int) bool {
if sorted[i].status == storagemarket.StorageDealActive || sorted[j].status == storagemarket.StorageDealActive {
return sorted[i].status == storagemarket.StorageDealActive
}
return sorted[i].status > sorted[j].status
})
2021-07-29 13:36:04 +00:00
fmt.Println()
fmt.Printf("Storage Deals: %d, %s\n", total.count, types.SizeStr(types.NewInt(total.bytes)))
2020-08-04 18:57:40 +00:00
tw := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', 0)
for _, e := range sorted {
_, _ = tw.Write([]byte(e.str))
}
_ = tw.Flush()
fmt.Println()
retrievals, err := nodeApi.MarketListRetrievalDeals(ctx)
if err != nil {
return xerrors.Errorf("getting retrieval deal list: %w", err)
}
var retrComplete dealStat
for _, retrieval := range retrievals {
if retrieval.Status == retrievalmarket.DealStatusCompleted {
retrComplete.count++
retrComplete.bytes += retrieval.TotalSent
}
2020-08-04 18:57:40 +00:00
}
fmt.Printf("Retrieval Deals (complete): %d, %s\n", retrComplete.count, types.SizeStr(types.NewInt(retrComplete.bytes)))
fmt.Println()
2020-08-04 18:57:40 +00:00
return nil
2019-10-11 23:47:29 +00:00
}
2020-05-01 19:51:31 +00:00
type stateMeta struct {
i int
col color.Attribute
2020-05-01 12:06:19 +00:00
state sealing.SectorState
}
var stateOrder = map[sealing.SectorState]stateMeta{}
var stateList = []stateMeta{
{col: 39, state: "Total"},
{col: color.FgGreen, state: sealing.Proving},
2022-03-16 16:33:05 +00:00
{col: color.FgGreen, state: sealing.Available},
{col: color.FgGreen, state: sealing.UpdateActivating},
2020-05-01 12:06:19 +00:00
{col: color.FgMagenta, state: sealing.ReceiveSector},
{col: color.FgBlue, state: sealing.Empty},
{col: color.FgBlue, state: sealing.WaitDeals},
2021-01-18 13:26:03 +00:00
{col: color.FgBlue, state: sealing.AddPiece},
{col: color.FgBlue, state: sealing.SnapDealsWaitDeals},
{col: color.FgBlue, state: sealing.SnapDealsAddPiece},
2020-05-01 12:06:19 +00:00
{col: color.FgRed, state: sealing.UndefinedSectorState},
{col: color.FgYellow, state: sealing.Packing},
2020-11-26 09:53:31 +00:00
{col: color.FgYellow, state: sealing.GetTicket},
2020-05-01 12:06:19 +00:00
{col: color.FgYellow, state: sealing.PreCommit1},
{col: color.FgYellow, state: sealing.PreCommit2},
{col: color.FgYellow, state: sealing.PreCommitting},
2020-06-04 15:10:41 +00:00
{col: color.FgYellow, state: sealing.PreCommitWait},
2021-05-18 15:21:10 +00:00
{col: color.FgYellow, state: sealing.SubmitPreCommitBatch},
{col: color.FgYellow, state: sealing.PreCommitBatchWait},
2020-05-01 12:06:19 +00:00
{col: color.FgYellow, state: sealing.WaitSeed},
{col: color.FgYellow, state: sealing.Committing},
2021-06-11 09:41:28 +00:00
{col: color.FgYellow, state: sealing.CommitFinalize},
{col: color.FgYellow, state: sealing.SubmitCommit},
2020-05-01 12:06:19 +00:00
{col: color.FgYellow, state: sealing.CommitWait},
2021-03-10 15:16:44 +00:00
{col: color.FgYellow, state: sealing.SubmitCommitAggregate},
{col: color.FgYellow, state: sealing.CommitAggregateWait},
2020-05-01 12:06:19 +00:00
{col: color.FgYellow, state: sealing.FinalizeSector},
{col: color.FgYellow, state: sealing.SnapDealsPacking},
{col: color.FgYellow, state: sealing.UpdateReplica},
{col: color.FgYellow, state: sealing.ProveReplicaUpdate},
{col: color.FgYellow, state: sealing.SubmitReplicaUpdate},
{col: color.FgYellow, state: sealing.ReplicaUpdateWait},
{col: color.FgYellow, state: sealing.FinalizeReplicaUpdate},
{col: color.FgYellow, state: sealing.ReleaseSectorKey},
2020-05-01 12:06:19 +00:00
2021-01-14 11:44:27 +00:00
{col: color.FgCyan, state: sealing.Terminating},
{col: color.FgCyan, state: sealing.TerminateWait},
{col: color.FgCyan, state: sealing.TerminateFinality},
{col: color.FgCyan, state: sealing.TerminateFailed},
{col: color.FgCyan, state: sealing.Removing},
{col: color.FgCyan, state: sealing.Removed},
{col: color.FgCyan, state: sealing.AbortUpgrade},
2020-05-01 12:06:19 +00:00
{col: color.FgRed, state: sealing.FailedUnrecoverable},
{col: color.FgRed, state: sealing.AddPieceFailed},
2020-06-04 19:22:53 +00:00
{col: color.FgRed, state: sealing.SealPreCommit1Failed},
{col: color.FgRed, state: sealing.SealPreCommit2Failed},
2020-05-01 12:06:19 +00:00
{col: color.FgRed, state: sealing.PreCommitFailed},
{col: color.FgRed, state: sealing.ComputeProofFailed},
2022-09-09 10:54:48 +00:00
{col: color.FgRed, state: sealing.RemoteCommitFailed},
2020-05-01 12:06:19 +00:00
{col: color.FgRed, state: sealing.CommitFailed},
2021-06-11 09:41:28 +00:00
{col: color.FgRed, state: sealing.CommitFinalizeFailed},
2020-05-01 12:06:19 +00:00
{col: color.FgRed, state: sealing.PackingFailed},
2020-06-04 15:10:41 +00:00
{col: color.FgRed, state: sealing.FinalizeFailed},
2020-05-01 12:06:19 +00:00
{col: color.FgRed, state: sealing.Faulty},
{col: color.FgRed, state: sealing.FaultReported},
{col: color.FgRed, state: sealing.FaultedFinal},
{col: color.FgRed, state: sealing.RemoveFailed},
{col: color.FgRed, state: sealing.DealsExpired},
{col: color.FgRed, state: sealing.RecoverDealIDs},
{col: color.FgRed, state: sealing.SnapDealsAddPieceFailed},
{col: color.FgRed, state: sealing.SnapDealsDealsExpired},
{col: color.FgRed, state: sealing.ReplicaUpdateFailed},
{col: color.FgRed, state: sealing.ReleaseSectorKeyFailed},
2022-03-02 16:33:33 +00:00
{col: color.FgRed, state: sealing.FinalizeReplicaUpdateFailed},
2020-05-01 12:06:19 +00:00
}
func init() {
for i, state := range stateList {
stateOrder[state.state] = stateMeta{
2020-05-01 19:51:31 +00:00
i: i,
col: state.col,
2020-05-01 12:06:19 +00:00
}
}
}
2021-01-05 09:53:27 +00:00
func sectorsInfo(ctx context.Context, mapi api.StorageMiner) error {
summary, err := mapi.SectorsSummary(ctx)
if err != nil {
2020-05-01 12:06:19 +00:00
return err
}
2020-12-06 00:51:48 +00:00
buckets := make(map[sealing.SectorState]int)
var total int
for s, c := range summary {
buckets[sealing.SectorState(s)] = c
total += c
2020-05-01 12:06:19 +00:00
}
2020-12-06 00:51:48 +00:00
buckets["Total"] = total
2020-05-01 12:06:19 +00:00
var sorted []stateMeta
for state, i := range buckets {
sorted = append(sorted, stateMeta{i: i, state: state})
}
sort.Slice(sorted, func(i, j int) bool {
return stateOrder[sorted[i].state].i < stateOrder[sorted[j].state].i
})
for _, s := range sorted {
_, _ = color.New(stateOrder[s.state].col).Printf("\t%s: %d\n", s.state, s.i)
}
2020-05-01 12:06:19 +00:00
return nil
}
2021-01-14 08:39:39 +00:00
func colorTokenAmount(format string, amount abi.TokenAmount) {
if amount.GreaterThan(big.Zero()) {
2021-01-15 03:48:07 +00:00
color.Green(format, types.FIL(amount).Short())
2021-01-14 08:39:39 +00:00
} else if amount.Equals(big.Zero()) {
2021-01-15 03:48:07 +00:00
color.Yellow(format, types.FIL(amount).Short())
2021-01-14 08:39:39 +00:00
} else {
2021-01-15 03:48:07 +00:00
color.Red(format, types.FIL(amount).Short())
2021-01-14 08:39:39 +00:00
}
}
2021-01-05 09:53:27 +00:00
func producedBlocks(ctx context.Context, count int, maddr address.Address, napi v1api.FullNode) error {
2021-01-05 09:53:27 +00:00
var err error
2021-08-04 07:49:35 +00:00
head, err := napi.ChainHead(ctx)
if err != nil {
return err
}
tbs := blockstore.NewTieredBstore(blockstore.NewAPIBlockstore(napi), blockstore.NewMemory())
2021-08-27 11:36:40 +00:00
tty := isatty.IsTerminal(os.Stderr.Fd())
2021-01-05 09:53:27 +00:00
ts := head
fmt.Printf(" Epoch | Block ID | Reward\n")
for count > 0 {
tsk := ts.Key()
bhs := ts.Blocks()
for _, bh := range bhs {
2021-08-27 11:36:40 +00:00
if ctx.Err() != nil {
return ctx.Err()
}
2021-01-05 09:53:27 +00:00
if bh.Miner == maddr {
2021-08-27 11:36:40 +00:00
if tty {
_, _ = fmt.Fprint(os.Stderr, "\r\x1b[0K")
}
2021-01-05 09:53:27 +00:00
rewardActor, err := napi.StateGetActor(ctx, reward.Address, tsk)
if err != nil {
return err
}
rewardActorState, err := reward.Load(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), rewardActor)
2021-01-05 09:53:27 +00:00
if err != nil {
return err
}
blockReward, err := rewardActorState.ThisEpochReward()
if err != nil {
return err
}
2021-08-27 11:36:40 +00:00
minerReward := types.BigDiv(types.BigMul(types.NewInt(uint64(bh.ElectionProof.WinCount)),
blockReward), types.NewInt(uint64(builtin.ExpectedLeadersPerEpoch)))
fmt.Printf("%8d | %s | %s\n", ts.Height(), bh.Cid(), types.FIL(minerReward))
2021-01-05 09:53:27 +00:00
count--
2021-08-27 11:36:40 +00:00
} else if tty && bh.Height%120 == 0 {
_, _ = fmt.Fprintf(os.Stderr, "\r\x1b[0KChecking epoch %s", lcli.EpochTime(head.Height(), bh.Height))
2021-01-05 09:53:27 +00:00
}
}
tsk = ts.Parents()
ts, err = napi.ChainGetTipSet(ctx, tsk)
if err != nil {
return err
}
}
2021-08-27 11:36:40 +00:00
if tty {
_, _ = fmt.Fprint(os.Stderr, "\r\x1b[0K")
}
2021-01-05 09:53:27 +00:00
return nil
}