package main import ( "bufio" "encoding/json" "errors" "fmt" "os" "sort" "strconv" "strings" "time" "github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/docker/go-units" "github.com/fatih/color" cbor "github.com/ipfs/go-ipld-cbor" "github.com/urfave/cli/v2" "golang.org/x/xerrors" "github.com/filecoin-project/go-bitfield" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/network" miner5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/miner" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/blockstore" "github.com/filecoin-project/lotus/chain/actors" "github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/builtin/miner" "github.com/filecoin-project/lotus/chain/actors/policy" "github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/lib/tablewriter" lcli "github.com/filecoin-project/lotus/cli" sealing "github.com/filecoin-project/lotus/extern/storage-sealing" ) var sectorsCmd = &cli.Command{ Name: "sectors", Usage: "interact with sector store", Subcommands: []*cli.Command{ sectorsStatusCmd, sectorsListCmd, sectorsRefsCmd, sectorsUpdateCmd, sectorsPledgeCmd, sectorsCheckExpireCmd, sectorsExpiredCmd, sectorsRenewCmd, sectorsExtendCmd, sectorsTerminateCmd, sectorsRemoveCmd, sectorsSnapUpCmd, sectorsMarkForUpgradeCmd, sectorsStartSealCmd, sectorsSealDelayCmd, sectorsCapacityCollateralCmd, sectorsBatching, sectorsRefreshPieceMatchingCmd, }, } var sectorsPledgeCmd = &cli.Command{ Name: "pledge", Usage: "store random data in a sector", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) id, err := nodeApi.PledgeSector(ctx) if err != nil { return err } fmt.Println("Created CC sector: ", id.Number) return nil }, } var sectorsStatusCmd = &cli.Command{ Name: "status", Usage: "Get the seal status of a sector by its number", ArgsUsage: "", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "log", Usage: "display event log", Aliases: []string{"l"}, }, &cli.BoolFlag{ Name: "on-chain-info", Usage: "show sector on chain info", Aliases: []string{"c"}, }, &cli.BoolFlag{ Name: "partition-info", Usage: "show partition related info", Aliases: []string{"p"}, }, &cli.BoolFlag{ Name: "proof", Usage: "print snark proof bytes as hex", }, }, Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if !cctx.Args().Present() { return fmt.Errorf("must specify sector number to get status of") } id, err := strconv.ParseUint(cctx.Args().First(), 10, 64) if err != nil { return err } onChainInfo := cctx.Bool("on-chain-info") status, err := nodeApi.SectorsStatus(ctx, abi.SectorNumber(id), onChainInfo) if err != nil { return err } fmt.Printf("SectorID:\t%d\n", status.SectorID) fmt.Printf("Status:\t\t%s\n", status.State) fmt.Printf("CIDcommD:\t%s\n", status.CommD) fmt.Printf("CIDcommR:\t%s\n", status.CommR) fmt.Printf("Ticket:\t\t%x\n", status.Ticket.Value) fmt.Printf("TicketH:\t%d\n", status.Ticket.Epoch) fmt.Printf("Seed:\t\t%x\n", status.Seed.Value) fmt.Printf("SeedH:\t\t%d\n", status.Seed.Epoch) fmt.Printf("Precommit:\t%s\n", status.PreCommitMsg) fmt.Printf("Commit:\t\t%s\n", status.CommitMsg) if cctx.Bool("proof") { fmt.Printf("Proof:\t\t%x\n", status.Proof) } fmt.Printf("Deals:\t\t%v\n", status.Deals) fmt.Printf("Retries:\t%d\n", status.Retries) if status.LastErr != "" { fmt.Printf("Last Error:\t\t%s\n", status.LastErr) } if onChainInfo { fmt.Printf("\nSector On Chain Info\n") fmt.Printf("SealProof:\t\t%x\n", status.SealProof) fmt.Printf("Activation:\t\t%v\n", status.Activation) fmt.Printf("Expiration:\t\t%v\n", status.Expiration) fmt.Printf("DealWeight:\t\t%v\n", status.DealWeight) fmt.Printf("VerifiedDealWeight:\t\t%v\n", status.VerifiedDealWeight) fmt.Printf("InitialPledge:\t\t%v\n", status.InitialPledge) fmt.Printf("\nExpiration Info\n") fmt.Printf("OnTime:\t\t%v\n", status.OnTime) fmt.Printf("Early:\t\t%v\n", status.Early) } if cctx.Bool("partition-info") { fullApi, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() maddr, err := getActorAddress(ctx, cctx) if err != nil { return err } mact, err := fullApi.StateGetActor(ctx, maddr, types.EmptyTSK) if err != nil { return err } tbs := blockstore.NewTieredBstore(blockstore.NewAPIBlockstore(fullApi), blockstore.NewMemory()) mas, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), mact) if err != nil { return err } errFound := errors.New("found") if err := mas.ForEachDeadline(func(dlIdx uint64, dl miner.Deadline) error { return dl.ForEachPartition(func(partIdx uint64, part miner.Partition) error { pas, err := part.AllSectors() if err != nil { return err } set, err := pas.IsSet(id) if err != nil { return err } if set { fmt.Printf("\nDeadline:\t%d\n", dlIdx) fmt.Printf("Partition:\t%d\n", partIdx) checkIn := func(name string, bg func() (bitfield.BitField, error)) error { bf, err := bg() if err != nil { return err } set, err := bf.IsSet(id) if err != nil { return err } setstr := "no" if set { setstr = "yes" } fmt.Printf("%s: \t%s\n", name, setstr) return nil } if err := checkIn("Unproven", part.UnprovenSectors); err != nil { return err } if err := checkIn("Live", part.LiveSectors); err != nil { return err } if err := checkIn("Active", part.ActiveSectors); err != nil { return err } if err := checkIn("Faulty", part.FaultySectors); err != nil { return err } if err := checkIn("Recovering", part.RecoveringSectors); err != nil { return err } return errFound } return nil }) }); err != errFound { if err != nil { return err } fmt.Println("\nNot found in any partition") } } if cctx.Bool("log") { fmt.Printf("--------\nEvent Log:\n") for i, l := range status.Log { fmt.Printf("%d.\t%s:\t[%s]\t%s\n", i, time.Unix(int64(l.Timestamp), 0), l.Kind, l.Message) if l.Trace != "" { fmt.Printf("\t%s\n", l.Trace) } } } return nil }, } var sectorsListCmd = &cli.Command{ Name: "list", Usage: "List sectors", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "show-removed", Usage: "show removed sectors", Aliases: []string{"r"}, }, &cli.BoolFlag{ Name: "color", Usage: "use color in display output", DefaultText: "depends on output being a TTY", Aliases: []string{"c"}, }, &cli.BoolFlag{ Name: "fast", Usage: "don't show on-chain info for better performance", Aliases: []string{"f"}, }, &cli.BoolFlag{ Name: "events", Usage: "display number of events the sector has received", Aliases: []string{"e"}, }, &cli.BoolFlag{ Name: "seal-time", Usage: "display how long it took for the sector to be sealed", }, &cli.StringFlag{ Name: "states", Usage: "filter sectors by a comma-separated list of states", }, &cli.BoolFlag{ Name: "unproven", Usage: "only show sectors which aren't in the 'Proving' state", Aliases: []string{"u"}, }, }, Action: func(cctx *cli.Context) error { if cctx.IsSet("color") { color.NoColor = !cctx.Bool("color") } nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() fullApi, closer2, err := lcli.GetFullNodeAPI(cctx) // TODO: consider storing full node address in config if err != nil { return err } defer closer2() ctx := lcli.ReqContext(cctx) var list []abi.SectorNumber showRemoved := cctx.Bool("show-removed") var states []api.SectorState if cctx.IsSet("states") && cctx.IsSet("unproven") { return xerrors.Errorf("only one of --states or --unproven can be specified at once") } if cctx.IsSet("states") { showRemoved = true sList := strings.Split(cctx.String("states"), ",") states = make([]api.SectorState, len(sList)) for i := range sList { states[i] = api.SectorState(sList[i]) } } if cctx.Bool("unproven") { for state := range sealing.ExistSectorStateList { if state == sealing.Proving { continue } states = append(states, api.SectorState(state)) } } if len(states) == 0 { list, err = nodeApi.SectorsList(ctx) } else { list, err = nodeApi.SectorsListInStates(ctx, states) } if err != nil { return err } maddr, err := nodeApi.ActorAddress(ctx) if err != nil { return err } head, err := fullApi.ChainHead(ctx) if err != nil { return err } activeSet, err := fullApi.StateMinerActiveSectors(ctx, maddr, head.Key()) if err != nil { return err } activeIDs := make(map[abi.SectorNumber]struct{}, len(activeSet)) for _, info := range activeSet { activeIDs[info.SectorNumber] = struct{}{} } sset, err := fullApi.StateMinerSectors(ctx, maddr, nil, head.Key()) if err != nil { return err } commitedIDs := make(map[abi.SectorNumber]struct{}, len(sset)) for _, info := range sset { commitedIDs[info.SectorNumber] = struct{}{} } sort.Slice(list, func(i, j int) bool { return list[i] < list[j] }) tw := tablewriter.New( tablewriter.Col("ID"), tablewriter.Col("State"), tablewriter.Col("OnChain"), tablewriter.Col("Active"), tablewriter.Col("Expiration"), tablewriter.Col("SealTime"), tablewriter.Col("Events"), tablewriter.Col("Deals"), tablewriter.Col("DealWeight"), tablewriter.Col("VerifiedPower"), tablewriter.NewLineCol("Error"), tablewriter.NewLineCol("RecoveryTimeout")) fast := cctx.Bool("fast") for _, s := range list { st, err := nodeApi.SectorsStatus(ctx, s, !fast) if err != nil { tw.Write(map[string]interface{}{ "ID": s, "Error": err, }) continue } if !showRemoved && st.State == api.SectorState(sealing.Removed) { continue } _, inSSet := commitedIDs[s] _, inASet := activeIDs[s] const verifiedPowerGainMul = 9 dw, vp := .0, .0 estimate := st.Expiration-st.Activation <= 0 if !estimate { rdw := big.Add(st.DealWeight, st.VerifiedDealWeight) dw = float64(big.Div(rdw, big.NewInt(int64(st.Expiration-st.Activation))).Uint64()) vp = float64(big.Div(big.Mul(st.VerifiedDealWeight, big.NewInt(verifiedPowerGainMul)), big.NewInt(int64(st.Expiration-st.Activation))).Uint64()) } else { for _, piece := range st.Pieces { if piece.DealInfo != nil { dw += float64(piece.Piece.Size) if piece.DealInfo.DealProposal != nil && piece.DealInfo.DealProposal.VerifiedDeal { vp += float64(piece.Piece.Size) * verifiedPowerGainMul } } } } var deals int for _, deal := range st.Deals { if deal != 0 { deals++ } } exp := st.Expiration if st.OnTime > 0 && st.OnTime < exp { exp = st.OnTime // Can be different when the sector was CC upgraded } m := map[string]interface{}{ "ID": s, "State": color.New(stateOrder[sealing.SectorState(st.State)].col).Sprint(st.State), "OnChain": yesno(inSSet), "Active": yesno(inASet), } if deals > 0 { m["Deals"] = color.GreenString("%d", deals) } else { m["Deals"] = color.BlueString("CC") if st.ToUpgrade { m["Deals"] = color.CyanString("CC(upgrade)") } } if !fast { if !inSSet { m["Expiration"] = "n/a" } else { m["Expiration"] = lcli.EpochTime(head.Height(), exp) if st.Early > 0 { m["RecoveryTimeout"] = color.YellowString(lcli.EpochTime(head.Height(), st.Early)) } } } if !fast && deals > 0 { estWrap := func(s string) string { if !estimate { return s } return fmt.Sprintf("[%s]", s) } m["DealWeight"] = estWrap(units.BytesSize(dw)) if vp > 0 { m["VerifiedPower"] = estWrap(color.GreenString(units.BytesSize(vp))) } } if cctx.Bool("events") { var events int for _, sectorLog := range st.Log { if !strings.HasPrefix(sectorLog.Kind, "event") { continue } if sectorLog.Kind == "event;sealing.SectorRestart" { continue } events++ } pieces := len(st.Deals) switch { case events < 12+pieces: m["Events"] = color.GreenString("%d", events) case events < 20+pieces: m["Events"] = color.YellowString("%d", events) default: m["Events"] = color.RedString("%d", events) } } if cctx.Bool("seal-time") && len(st.Log) > 1 { start := time.Unix(int64(st.Log[0].Timestamp), 0) for _, sectorLog := range st.Log { if sectorLog.Kind == "event;sealing.SectorProving" { // todo: figure out a good way to not hardcode end := time.Unix(int64(sectorLog.Timestamp), 0) dur := end.Sub(start) switch { case dur < 12*time.Hour: m["SealTime"] = color.GreenString("%s", dur) case dur < 24*time.Hour: m["SealTime"] = color.YellowString("%s", dur) default: m["SealTime"] = color.RedString("%s", dur) } break } } } tw.Write(m) } return tw.Flush(os.Stdout) }, } var sectorsRefsCmd = &cli.Command{ Name: "refs", Usage: "List References to sectors", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetMarketsAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) refs, err := nodeApi.SectorsRefs(ctx) if err != nil { return err } for name, refs := range refs { fmt.Printf("Block %s:\n", name) for _, ref := range refs { fmt.Printf("\t%d+%d %d bytes\n", ref.SectorID, ref.Offset, ref.Size) } } return nil }, } var sectorsCheckExpireCmd = &cli.Command{ Name: "check-expire", Usage: "Inspect expiring sectors", Flags: []cli.Flag{ &cli.Int64Flag{ Name: "cutoff", Usage: "skip sectors whose current expiration is more than epochs from now, defaults to 60 days", Value: 172800, }, }, Action: func(cctx *cli.Context) error { fullApi, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) maddr, err := getActorAddress(ctx, cctx) if err != nil { return err } head, err := fullApi.ChainHead(ctx) if err != nil { return err } currEpoch := head.Height() nv, err := fullApi.StateNetworkVersion(ctx, types.EmptyTSK) if err != nil { return err } sectors, err := fullApi.StateMinerActiveSectors(ctx, maddr, types.EmptyTSK) if err != nil { return err } n := 0 for _, s := range sectors { if s.Expiration-currEpoch <= abi.ChainEpoch(cctx.Int64("cutoff")) { sectors[n] = s n++ } } sectors = sectors[:n] sort.Slice(sectors, func(i, j int) bool { if sectors[i].Expiration == sectors[j].Expiration { return sectors[i].SectorNumber < sectors[j].SectorNumber } return sectors[i].Expiration < sectors[j].Expiration }) tw := tablewriter.New( tablewriter.Col("ID"), tablewriter.Col("SealProof"), tablewriter.Col("InitialPledge"), tablewriter.Col("Activation"), tablewriter.Col("Expiration"), tablewriter.Col("MaxExpiration"), tablewriter.Col("MaxExtendNow")) for _, sector := range sectors { MaxExpiration := sector.Activation + policy.GetSectorMaxLifetime(sector.SealProof, nv) MaxExtendNow := currEpoch + policy.GetMaxSectorExpirationExtension() if MaxExtendNow > MaxExpiration { MaxExtendNow = MaxExpiration } tw.Write(map[string]interface{}{ "ID": sector.SectorNumber, "SealProof": sector.SealProof, "InitialPledge": types.FIL(sector.InitialPledge).Short(), "Activation": lcli.EpochTime(currEpoch, sector.Activation), "Expiration": lcli.EpochTime(currEpoch, sector.Expiration), "MaxExpiration": lcli.EpochTime(currEpoch, MaxExpiration), "MaxExtendNow": lcli.EpochTime(currEpoch, MaxExtendNow), }) } return tw.Flush(os.Stdout) }, } type PseudoExpirationExtension struct { Deadline uint64 Partition uint64 Sectors string NewExpiration abi.ChainEpoch } type PseudoExtendSectorExpirationParams struct { Extensions []PseudoExpirationExtension } func NewPseudoExtendParams(p *miner5.ExtendSectorExpirationParams) (*PseudoExtendSectorExpirationParams, error) { res := PseudoExtendSectorExpirationParams{} for _, ext := range p.Extensions { scount, err := ext.Sectors.Count() if err != nil { return nil, err } sectors, err := ext.Sectors.All(scount) if err != nil { return nil, err } res.Extensions = append(res.Extensions, PseudoExpirationExtension{ Deadline: ext.Deadline, Partition: ext.Partition, Sectors: ArrayToString(sectors), NewExpiration: ext.NewExpiration, }) } return &res, nil } // ArrayToString Example: {1,3,4,5,8,9} -> "1,3-5,8-9" func ArrayToString(array []uint64) string { sort.Slice(array, func(i, j int) bool { return array[i] < array[j] }) var sarray []string s := "" for i, elm := range array { if i == 0 { s = strconv.FormatUint(elm, 10) continue } if elm == array[i-1] { continue // filter out duplicates } else if elm == array[i-1]+1 { s = strings.Split(s, "-")[0] + "-" + strconv.FormatUint(elm, 10) } else { sarray = append(sarray, s) s = strconv.FormatUint(elm, 10) } } if s != "" { sarray = append(sarray, s) } return strings.Join(sarray, ",") } func getSectorsFromFile(filePath string) ([]uint64, error) { file, err := os.Open(filePath) if err != nil { return nil, err } scanner := bufio.NewScanner(file) sectors := make([]uint64, 0) for scanner.Scan() { line := scanner.Text() id, err := strconv.ParseUint(line, 10, 64) if err != nil { return nil, xerrors.Errorf("could not parse %s as sector id: %s", line, err) } sectors = append(sectors, id) } if err = file.Close(); err != nil { return nil, err } return sectors, nil } var sectorsRenewCmd = &cli.Command{ Name: "renew", Usage: "Renew expiring sectors while not exceeding each sector's max life", Flags: []cli.Flag{ &cli.Int64Flag{ Name: "from", Usage: "only consider sectors whose current expiration epoch is in the range of [from, to], defaults to: now + 120 (1 hour)", }, &cli.Int64Flag{ Name: "to", Usage: "only consider sectors whose current expiration epoch is in the range of [from, to], defaults to: now + 92160 (32 days)", }, &cli.StringFlag{ Name: "sector-file", Usage: "provide a file containing one sector number in each line, ignoring above selecting criteria", }, &cli.StringFlag{ Name: "exclude", Usage: "optionally provide a file containing excluding sectors", }, &cli.Int64Flag{ Name: "extension", Usage: "try to extend selected sectors by this number of epochs, defaults to 540 days", Value: 1555200, }, &cli.Int64Flag{ Name: "new-expiration", Usage: "try to extend selected sectors to this epoch, ignoring extension", }, &cli.Int64Flag{ Name: "tolerance", Usage: "don't try to extend sectors by fewer than this number of epochs, defaults to 7 days", Value: 20160, }, &cli.StringFlag{ Name: "max-fee", Usage: "use up to this amount of FIL for one message. pass this flag to avoid message congestion.", Value: "0", }, &cli.BoolFlag{ Name: "really-do-it", Usage: "pass this flag to really renew sectors, otherwise will only print out json representation of parameters", }, }, Action: func(cctx *cli.Context) error { mf, err := types.ParseFIL(cctx.String("max-fee")) if err != nil { return err } spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(mf)} fullApi, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) maddr, err := getActorAddress(ctx, cctx) if err != nil { return err } head, err := fullApi.ChainHead(ctx) if err != nil { return err } currEpoch := head.Height() nv, err := fullApi.StateNetworkVersion(ctx, types.EmptyTSK) if err != nil { return err } activeSet, err := fullApi.StateMinerActiveSectors(ctx, maddr, types.EmptyTSK) if err != nil { return err } activeSectorsInfo := make(map[abi.SectorNumber]*miner.SectorOnChainInfo, len(activeSet)) for _, info := range activeSet { activeSectorsInfo[info.SectorNumber] = info } mact, err := fullApi.StateGetActor(ctx, maddr, types.EmptyTSK) if err != nil { return err } tbs := blockstore.NewTieredBstore(blockstore.NewAPIBlockstore(fullApi), blockstore.NewMemory()) mas, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), mact) if err != nil { return err } activeSectorsLocation := make(map[abi.SectorNumber]*miner.SectorLocation, len(activeSet)) if err := mas.ForEachDeadline(func(dlIdx uint64, dl miner.Deadline) error { return dl.ForEachPartition(func(partIdx uint64, part miner.Partition) error { pas, err := part.ActiveSectors() if err != nil { return err } return pas.ForEach(func(i uint64) error { activeSectorsLocation[abi.SectorNumber(i)] = &miner.SectorLocation{ Deadline: dlIdx, Partition: partIdx, } return nil }) }) }); err != nil { return err } excludeSet := make(map[uint64]struct{}) if cctx.IsSet("exclude") { excludeSectors, err := getSectorsFromFile(cctx.String("exclude")) if err != nil { return err } for _, id := range excludeSectors { excludeSet[id] = struct{}{} } } var sis []*miner.SectorOnChainInfo if cctx.IsSet("sector-file") { sectors, err := getSectorsFromFile(cctx.String("sector-file")) if err != nil { return err } for _, id := range sectors { if _, exclude := excludeSet[id]; exclude { continue } si, found := activeSectorsInfo[abi.SectorNumber(id)] if !found { return xerrors.Errorf("sector %d is not active", id) } sis = append(sis, si) } } else { from := currEpoch + 120 to := currEpoch + 92160 if cctx.IsSet("from") { from = abi.ChainEpoch(cctx.Int64("from")) } if cctx.IsSet("to") { to = abi.ChainEpoch(cctx.Int64("to")) } for _, si := range activeSet { if si.Expiration >= from && si.Expiration <= to { if _, exclude := excludeSet[uint64(si.SectorNumber)]; !exclude { sis = append(sis, si) } } } } extensions := map[miner.SectorLocation]map[abi.ChainEpoch][]uint64{} withinTolerance := func(a, b abi.ChainEpoch) bool { diff := a - b if diff < 0 { diff = -diff } return diff <= abi.ChainEpoch(cctx.Int64("tolerance")) } for _, si := range sis { extension := abi.ChainEpoch(cctx.Int64("extension")) newExp := si.Expiration + extension if cctx.IsSet("new-expiration") { newExp = abi.ChainEpoch(cctx.Int64("new-expiration")) } maxExtendNow := currEpoch + policy.GetMaxSectorExpirationExtension() if newExp > maxExtendNow { newExp = maxExtendNow } maxExp := si.Activation + policy.GetSectorMaxLifetime(si.SealProof, nv) if newExp > maxExp { newExp = maxExp } if newExp <= si.Expiration || withinTolerance(newExp, si.Expiration) { continue } l, found := activeSectorsLocation[si.SectorNumber] if !found { return xerrors.Errorf("location for sector %d not found", si.SectorNumber) } es, found := extensions[*l] if !found { ne := make(map[abi.ChainEpoch][]uint64) ne[newExp] = []uint64{uint64(si.SectorNumber)} extensions[*l] = ne } else { added := false for exp := range es { if withinTolerance(newExp, exp) { es[exp] = append(es[exp], uint64(si.SectorNumber)) added = true break } } if !added { es[newExp] = []uint64{uint64(si.SectorNumber)} } } } var params []miner5.ExtendSectorExpirationParams p := miner5.ExtendSectorExpirationParams{} scount := 0 for l, exts := range extensions { for newExp, numbers := range exts { scount += len(numbers) addrSectors, err := policy.GetAddressedSectorsMax(nv) if err != nil { return err } declMax, err := policy.GetDeclarationsMax(nv) if err != nil { return err } if scount > addrSectors || len(p.Extensions) == declMax { params = append(params, p) p = miner5.ExtendSectorExpirationParams{} scount = len(numbers) } p.Extensions = append(p.Extensions, miner5.ExpirationExtension{ Deadline: l.Deadline, Partition: l.Partition, Sectors: bitfield.NewFromSet(numbers), NewExpiration: newExp, }) } } // if we have any sectors, then one last append is needed here if scount != 0 { params = append(params, p) } if len(params) == 0 { fmt.Println("nothing to extend") return nil } mi, err := fullApi.StateMinerInfo(ctx, maddr, types.EmptyTSK) if err != nil { return xerrors.Errorf("getting miner info: %w", err) } stotal := 0 for i := range params { scount := 0 for _, ext := range params[i].Extensions { count, err := ext.Sectors.Count() if err != nil { return err } scount += int(count) } fmt.Printf("Renewing %d sectors: ", scount) stotal += scount if !cctx.Bool("really-do-it") { pp, err := NewPseudoExtendParams(¶ms[i]) if err != nil { return err } data, err := json.MarshalIndent(pp, "", " ") if err != nil { return err } fmt.Println() fmt.Println(string(data)) continue } sp, aerr := actors.SerializeParams(¶ms[i]) if aerr != nil { return xerrors.Errorf("serializing params: %w", err) } smsg, err := fullApi.MpoolPushMessage(ctx, &types.Message{ From: mi.Worker, To: maddr, Method: miner.Methods.ExtendSectorExpiration, Value: big.Zero(), Params: sp, }, spec) if err != nil { return xerrors.Errorf("mpool push message: %w", err) } fmt.Println(smsg.Cid()) } fmt.Printf("%d sectors renewed\n", stotal) return nil }, } var sectorsExtendCmd = &cli.Command{ Name: "extend", Usage: "Extend sector expiration", ArgsUsage: "", Flags: []cli.Flag{ &cli.Int64Flag{ Name: "new-expiration", Usage: "new expiration epoch", Required: false, }, &cli.BoolFlag{ Name: "v1-sectors", Usage: "renews all v1 sectors up to the maximum possible lifetime", Required: false, }, &cli.Int64Flag{ Name: "tolerance", Value: 20160, Usage: "when extending v1 sectors, don't try to extend sectors by fewer than this number of epochs", Required: false, }, &cli.Int64Flag{ Name: "expiration-ignore", Value: 120, Usage: "when extending v1 sectors, skip sectors whose current expiration is less than epochs from now", Required: false, }, &cli.Int64Flag{ Name: "expiration-cutoff", Usage: "when extending v1 sectors, skip sectors whose current expiration is more than epochs from now (infinity if unspecified)", Required: false, }, &cli.StringFlag{}, }, Action: func(cctx *cli.Context) error { api, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) maddr, err := getActorAddress(ctx, cctx) if err != nil { return err } var params []miner5.ExtendSectorExpirationParams if cctx.Bool("v1-sectors") { head, err := api.ChainHead(ctx) if err != nil { return err } nv, err := api.StateNetworkVersion(ctx, types.EmptyTSK) if err != nil { return err } extensions := map[miner.SectorLocation]map[abi.ChainEpoch][]uint64{} // are given durations within tolerance epochs withinTolerance := func(a, b abi.ChainEpoch) bool { diff := a - b if diff < 0 { diff = b - a } return diff <= abi.ChainEpoch(cctx.Int64("tolerance")) } sis, err := api.StateMinerActiveSectors(ctx, maddr, types.EmptyTSK) if err != nil { return xerrors.Errorf("getting miner sector infos: %w", err) } for _, si := range sis { if si.SealProof >= abi.RegisteredSealProof_StackedDrg2KiBV1_1 { continue } if si.Expiration < (head.Height() + abi.ChainEpoch(cctx.Int64("expiration-ignore"))) { continue } if cctx.IsSet("expiration-cutoff") { if si.Expiration > (head.Height() + abi.ChainEpoch(cctx.Int64("expiration-cutoff"))) { continue } } ml := policy.GetSectorMaxLifetime(si.SealProof, nv) // if the sector's missing less than "tolerance" of its maximum possible lifetime, don't bother extending it if withinTolerance(si.Expiration-si.Activation, ml) { continue } // Set the new expiration to 48 hours less than the theoretical maximum lifetime newExp := ml - (miner5.WPoStProvingPeriod * 2) + si.Activation if withinTolerance(si.Expiration, newExp) || si.Expiration >= newExp { continue } p, err := api.StateSectorPartition(ctx, maddr, si.SectorNumber, types.EmptyTSK) if err != nil { return xerrors.Errorf("getting sector location for sector %d: %w", si.SectorNumber, err) } if p == nil { return xerrors.Errorf("sector %d not found in any partition", si.SectorNumber) } es, found := extensions[*p] if !found { ne := make(map[abi.ChainEpoch][]uint64) ne[newExp] = []uint64{uint64(si.SectorNumber)} extensions[*p] = ne } else { added := false for exp := range es { if withinTolerance(exp, newExp) && newExp >= exp && exp > si.Expiration { es[exp] = append(es[exp], uint64(si.SectorNumber)) added = true break } } if !added { es[newExp] = []uint64{uint64(si.SectorNumber)} } } } p := miner5.ExtendSectorExpirationParams{} scount := 0 for l, exts := range extensions { for newExp, numbers := range exts { scount += len(numbers) addressedMax, err := policy.GetAddressedSectorsMax(nv) if err != nil { return xerrors.Errorf("failed to get addressed sectors max") } declMax, err := policy.GetDeclarationsMax(nv) if err != nil { return xerrors.Errorf("failed to get declarations max") } if scount > addressedMax || len(p.Extensions) == declMax { params = append(params, p) p = miner5.ExtendSectorExpirationParams{} scount = len(numbers) } p.Extensions = append(p.Extensions, miner5.ExpirationExtension{ Deadline: l.Deadline, Partition: l.Partition, Sectors: bitfield.NewFromSet(numbers), NewExpiration: newExp, }) } } // if we have any sectors, then one last append is needed here if scount != 0 { params = append(params, p) } } else { if !cctx.Args().Present() || !cctx.IsSet("new-expiration") { return xerrors.Errorf("must pass at least one sector number and new expiration") } sectors := map[miner.SectorLocation][]uint64{} for i, s := range cctx.Args().Slice() { id, err := strconv.ParseUint(s, 10, 64) if err != nil { return xerrors.Errorf("could not parse sector %d: %w", i, err) } p, err := api.StateSectorPartition(ctx, maddr, abi.SectorNumber(id), types.EmptyTSK) if err != nil { return xerrors.Errorf("getting sector location for sector %d: %w", id, err) } if p == nil { return xerrors.Errorf("sector %d not found in any partition", id) } sectors[*p] = append(sectors[*p], id) } p := miner5.ExtendSectorExpirationParams{} for l, numbers := range sectors { // TODO: Dedup with above loop p.Extensions = append(p.Extensions, miner5.ExpirationExtension{ Deadline: l.Deadline, Partition: l.Partition, Sectors: bitfield.NewFromSet(numbers), NewExpiration: abi.ChainEpoch(cctx.Int64("new-expiration")), }) } params = append(params, p) } if len(params) == 0 { fmt.Println("nothing to extend") return nil } mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK) if err != nil { return xerrors.Errorf("getting miner info: %w", err) } for i := range params { sp, aerr := actors.SerializeParams(¶ms[i]) if aerr != nil { return xerrors.Errorf("serializing params: %w", err) } smsg, err := api.MpoolPushMessage(ctx, &types.Message{ From: mi.Worker, To: maddr, Method: miner.Methods.ExtendSectorExpiration, Value: big.Zero(), Params: sp, }, nil) if err != nil { return xerrors.Errorf("mpool push message: %w", err) } fmt.Println(smsg.Cid()) } return nil }, } var sectorsTerminateCmd = &cli.Command{ Name: "terminate", Usage: "Terminate sector on-chain then remove (WARNING: This means losing power and collateral for the removed sector)", ArgsUsage: "", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "really-do-it", Usage: "pass this flag if you know what you are doing", }, }, Subcommands: []*cli.Command{ sectorsTerminateFlushCmd, sectorsTerminatePendingCmd, }, Action: func(cctx *cli.Context) error { if !cctx.Bool("really-do-it") { return xerrors.Errorf("pass --really-do-it to confirm this action") } nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Args().Len() != 1 { return xerrors.Errorf("must pass sector number") } id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } return nodeApi.SectorTerminate(ctx, abi.SectorNumber(id)) }, } var sectorsTerminateFlushCmd = &cli.Command{ Name: "flush", Usage: "Send a terminate message if there are sectors queued for termination", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) mcid, err := nodeApi.SectorTerminateFlush(ctx) if err != nil { return err } if mcid == nil { return xerrors.New("no sectors were queued for termination") } fmt.Println(mcid) return nil }, } var sectorsTerminatePendingCmd = &cli.Command{ Name: "pending", Usage: "List sector numbers of sectors pending termination", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() api, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) pending, err := nodeApi.SectorTerminatePending(ctx) if err != nil { return err } maddr, err := nodeApi.ActorAddress(ctx) if err != nil { return err } dl, err := api.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK) if err != nil { return xerrors.Errorf("getting proving deadline info failed: %w", err) } for _, id := range pending { loc, err := api.StateSectorPartition(ctx, maddr, id.Number, types.EmptyTSK) if err != nil { return xerrors.Errorf("finding sector partition: %w", err) } fmt.Print(id.Number) if loc.Deadline == (dl.Index+1)%miner.WPoStPeriodDeadlines || // not in next (in case the terminate message takes a while to get on chain) loc.Deadline == dl.Index || // not in current (loc.Deadline+1)%miner.WPoStPeriodDeadlines == dl.Index { // not in previous fmt.Print(" (in proving window)") } fmt.Println() } return nil }, } var sectorsRemoveCmd = &cli.Command{ Name: "remove", Usage: "Forcefully remove a sector (WARNING: This means losing power and collateral for the removed sector (use 'terminate' for lower penalty))", ArgsUsage: "", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "really-do-it", Usage: "pass this flag if you know what you are doing", }, }, Action: func(cctx *cli.Context) error { if !cctx.Bool("really-do-it") { return xerrors.Errorf("this is a command for advanced users, only use it if you are sure of what you are doing") } nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Args().Len() != 1 { return xerrors.Errorf("must pass sector number") } id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } return nodeApi.SectorRemove(ctx, abi.SectorNumber(id)) }, } var sectorsSnapUpCmd = &cli.Command{ Name: "snap-up", Usage: "Mark a committed capacity sector to be filled with deals", ArgsUsage: "", Action: func(cctx *cli.Context) error { if cctx.Args().Len() != 1 { return lcli.ShowHelp(cctx, xerrors.Errorf("must pass sector number")) } nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() api, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) nv, err := api.StateNetworkVersion(ctx, types.EmptyTSK) if err != nil { return xerrors.Errorf("failed to get network version: %w", err) } if nv < network.Version15 { return xerrors.Errorf("snap deals upgrades enabled in network v15") } id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } return nodeApi.SectorMarkForUpgrade(ctx, abi.SectorNumber(id), true) }, } var sectorsMarkForUpgradeCmd = &cli.Command{ Name: "mark-for-upgrade", Usage: "Mark a committed capacity sector for replacement by a sector with deals", ArgsUsage: "", Action: func(cctx *cli.Context) error { if cctx.Args().Len() != 1 { return lcli.ShowHelp(cctx, xerrors.Errorf("must pass sector number")) } nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() api, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) nv, err := api.StateNetworkVersion(ctx, types.EmptyTSK) if err != nil { return xerrors.Errorf("failed to get network version: %w", err) } if nv >= network.Version15 { return xerrors.Errorf("classic cc upgrades disabled v15 and beyond, use `snap-up`") } // disable mark for upgrade two days before the ntwk v15 upgrade // TODO: remove the following block in v1.15.1 head, err := api.ChainHead(ctx) if err != nil { return xerrors.Errorf("failed to get chain head: %w", err) } twoDays := abi.ChainEpoch(2 * builtin.EpochsInDay) if head.Height() > (build.UpgradeOhSnapHeight - twoDays) { return xerrors.Errorf("OhSnap is coming soon, " + "please use `snap-up` to upgrade your cc sectors after the network v15 upgrade!") } id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } return nodeApi.SectorMarkForUpgrade(ctx, abi.SectorNumber(id), false) }, } var sectorsStartSealCmd = &cli.Command{ Name: "seal", Usage: "Manually start sealing a sector (filling any unused space with junk)", ArgsUsage: "", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Args().Len() != 1 { return xerrors.Errorf("must pass sector number") } id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } return nodeApi.SectorStartSealing(ctx, abi.SectorNumber(id)) }, } var sectorsSealDelayCmd = &cli.Command{ Name: "set-seal-delay", Usage: "Set the time, in minutes, that a new sector waits for deals before sealing starts", ArgsUsage: "", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Args().Len() != 1 { return xerrors.Errorf("must pass duration in minutes") } hs, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } delay := hs * uint64(time.Minute) return nodeApi.SectorSetSealDelay(ctx, time.Duration(delay)) }, } var sectorsCapacityCollateralCmd = &cli.Command{ Name: "get-cc-collateral", Usage: "Get the collateral required to pledge a committed capacity sector", Flags: []cli.Flag{ &cli.Uint64Flag{ Name: "expiration", Usage: "the epoch when the sector will expire", }, }, Action: func(cctx *cli.Context) error { nApi, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err } defer nCloser() ctx := lcli.ReqContext(cctx) maddr, err := getActorAddress(ctx, cctx) if err != nil { return err } mi, err := nApi.StateMinerInfo(ctx, maddr, types.EmptyTSK) if err != nil { return err } nv, err := nApi.StateNetworkVersion(ctx, types.EmptyTSK) if err != nil { return err } spt, err := miner.PreferredSealProofTypeFromWindowPoStType(nv, mi.WindowPoStProofType) if err != nil { return err } pci := miner.SectorPreCommitInfo{ SealProof: spt, Expiration: abi.ChainEpoch(cctx.Uint64("expiration")), } if pci.Expiration == 0 { h, err := nApi.ChainHead(ctx) if err != nil { return err } pci.Expiration = policy.GetMaxSectorExpirationExtension() + h.Height() } pc, err := nApi.StateMinerInitialPledgeCollateral(ctx, maddr, pci, types.EmptyTSK) if err != nil { return err } pcd, err := nApi.StateMinerPreCommitDepositForPower(ctx, maddr, pci, types.EmptyTSK) if err != nil { return err } fmt.Printf("Estimated collateral: %s\n", types.FIL(big.Max(pc, pcd))) return nil }, } var sectorsUpdateCmd = &cli.Command{ Name: "update-state", Usage: "ADVANCED: manually update the state of a sector, this may aid in error recovery", ArgsUsage: " ", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "really-do-it", Usage: "pass this flag if you know what you are doing", }, }, Action: func(cctx *cli.Context) error { if !cctx.Bool("really-do-it") { return xerrors.Errorf("this is a command for advanced users, only use it if you are sure of what you are doing") } nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Args().Len() < 2 { return xerrors.Errorf("must pass sector number and new state") } id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64) if err != nil { return xerrors.Errorf("could not parse sector number: %w", err) } _, err = nodeApi.SectorsStatus(ctx, abi.SectorNumber(id), false) if err != nil { return xerrors.Errorf("sector %d not found, could not change state", id) } newState := cctx.Args().Get(1) if _, ok := sealing.ExistSectorStateList[sealing.SectorState(newState)]; !ok { fmt.Printf(" \"%s\" is not a valid state. Possible states for sectors are: \n", newState) for state := range sealing.ExistSectorStateList { fmt.Printf("%s\n", string(state)) } return nil } return nodeApi.SectorsUpdate(ctx, abi.SectorNumber(id), api.SectorState(cctx.Args().Get(1))) }, } var sectorsExpiredCmd = &cli.Command{ Name: "expired", Usage: "Get or cleanup expired sectors", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "show-removed", Usage: "show removed sectors", }, &cli.BoolFlag{ Name: "remove-expired", Usage: "remove expired sectors", }, &cli.Int64Flag{ Name: "confirm-remove-count", Hidden: true, }, &cli.Int64Flag{ Name: "expired-epoch", Usage: "epoch at which to check sector expirations", DefaultText: "WinningPoSt lookback epoch", }, }, Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() fullApi, nCloser, err := lcli.GetFullNodeAPI(cctx) if err != nil { return xerrors.Errorf("getting fullnode api: %w", err) } defer nCloser() ctx := lcli.ReqContext(cctx) head, err := fullApi.ChainHead(ctx) if err != nil { return xerrors.Errorf("getting chain head: %w", err) } lbEpoch := abi.ChainEpoch(cctx.Int64("expired-epoch")) if !cctx.IsSet("expired-epoch") { nv, err := fullApi.StateNetworkVersion(ctx, head.Key()) if err != nil { return xerrors.Errorf("getting network version: %w", err) } lbEpoch = head.Height() - policy.GetWinningPoStSectorSetLookback(nv) if lbEpoch < 0 { return xerrors.Errorf("too early to terminate sectors") } } if cctx.IsSet("confirm-remove-count") && !cctx.IsSet("expired-epoch") { return xerrors.Errorf("--expired-epoch must be specified with --confirm-remove-count") } lbts, err := fullApi.ChainGetTipSetByHeight(ctx, lbEpoch, head.Key()) if err != nil { return xerrors.Errorf("getting lookback tipset: %w", err) } maddr, err := nodeApi.ActorAddress(ctx) if err != nil { return xerrors.Errorf("getting actor address: %w", err) } // toCheck is a working bitfield which will only contain terminated sectors toCheck := bitfield.New() { sectors, err := nodeApi.SectorsList(ctx) if err != nil { return xerrors.Errorf("getting sector list: %w", err) } for _, sector := range sectors { toCheck.Set(uint64(sector)) } } mact, err := fullApi.StateGetActor(ctx, maddr, lbts.Key()) if err != nil { return err } tbs := blockstore.NewTieredBstore(blockstore.NewAPIBlockstore(fullApi), blockstore.NewMemory()) mas, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), mact) if err != nil { return err } alloc, err := mas.GetAllocatedSectors() if err != nil { return xerrors.Errorf("getting allocated sectors: %w", err) } // only allocated sectors can be expired, toCheck, err = bitfield.IntersectBitField(toCheck, *alloc) if err != nil { return xerrors.Errorf("intersecting bitfields: %w", err) } if err := mas.ForEachDeadline(func(dlIdx uint64, dl miner.Deadline) error { return dl.ForEachPartition(func(partIdx uint64, part miner.Partition) error { live, err := part.LiveSectors() if err != nil { return err } toCheck, err = bitfield.SubtractBitField(toCheck, live) if err != nil { return err } unproven, err := part.UnprovenSectors() if err != nil { return err } toCheck, err = bitfield.SubtractBitField(toCheck, unproven) return err }) }); err != nil { return err } err = mas.ForEachPrecommittedSector(func(pci miner.SectorPreCommitOnChainInfo) error { toCheck.Unset(uint64(pci.Info.SectorNumber)) return nil }) if err != nil { return err } if cctx.Bool("remove-expired") { color.Red("Removing sectors:\n") } // toCheck now only contains sectors which either failed to precommit or are expired/terminated fmt.Printf("Sector\tState\tExpiration\n") var toRemove []abi.SectorNumber err = toCheck.ForEach(func(u uint64) error { s := abi.SectorNumber(u) st, err := nodeApi.SectorsStatus(ctx, s, true) if err != nil { fmt.Printf("%d:\tError getting status: %s\n", u, err) return nil } rmMsg := "" if st.State == api.SectorState(sealing.Removed) { if cctx.IsSet("confirm-remove-count") || !cctx.Bool("show-removed") { return nil } } else { // not removed toRemove = append(toRemove, s) } fmt.Printf("%d%s\t%s\t%s\n", s, rmMsg, st.State, lcli.EpochTime(head.Height(), st.Expiration)) return nil }) if err != nil { return err } if cctx.Bool("remove-expired") { if !cctx.IsSet("confirm-remove-count") { fmt.Println() fmt.Println(color.YellowString("All"), color.GreenString("%d", len(toRemove)), color.YellowString("sectors listed above will be removed\n")) fmt.Println(color.YellowString("To confirm removal of the above sectors, including\n all related sealed and unsealed data, run:\n")) fmt.Println(color.RedString("lotus-miner sectors expired --remove-expired --confirm-remove-count=%d --expired-epoch=%d\n", len(toRemove), lbts.Height())) fmt.Println(color.YellowString("WARNING: This operation is irreversible")) return nil } fmt.Println() if int64(len(toRemove)) != cctx.Int64("confirm-remove-count") { return xerrors.Errorf("value of confirm-remove-count doesn't match the number of sectors which can be removed (%d)", len(toRemove)) } for _, number := range toRemove { fmt.Printf("Removing sector\t%s:\t", color.YellowString("%d", number)) err := nodeApi.SectorRemove(ctx, number) if err != nil { color.Red("ERROR: %s\n", err.Error()) } else { color.Green("OK\n") } } } return nil }, } var sectorsBatching = &cli.Command{ Name: "batching", Usage: "manage batch sector operations", Subcommands: []*cli.Command{ sectorsBatchingPendingCommit, sectorsBatchingPendingPreCommit, }, } var sectorsBatchingPendingCommit = &cli.Command{ Name: "commit", Usage: "list sectors waiting in commit batch queue", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "publish-now", Usage: "send a batch now", }, }, Action: func(cctx *cli.Context) error { api, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Bool("publish-now") { res, err := api.SectorCommitFlush(ctx) if err != nil { return xerrors.Errorf("flush: %w", err) } if res == nil { return xerrors.Errorf("no sectors to publish") } for i, re := range res { fmt.Printf("Batch %d:\n", i) if re.Error != "" { fmt.Printf("\tError: %s\n", re.Error) } else { fmt.Printf("\tMessage: %s\n", re.Msg) } fmt.Printf("\tSectors:\n") for _, sector := range re.Sectors { if e, found := re.FailedSectors[sector]; found { fmt.Printf("\t\t%d\tERROR %s\n", sector, e) } else { fmt.Printf("\t\t%d\tOK\n", sector) } } } return nil } pending, err := api.SectorCommitPending(ctx) if err != nil { return xerrors.Errorf("getting pending deals: %w", err) } if len(pending) > 0 { for _, sector := range pending { fmt.Println(sector.Number) } return nil } fmt.Println("No sectors queued to be committed") return nil }, } var sectorsBatchingPendingPreCommit = &cli.Command{ Name: "precommit", Usage: "list sectors waiting in precommit batch queue", Flags: []cli.Flag{ &cli.BoolFlag{ Name: "publish-now", Usage: "send a batch now", }, }, Action: func(cctx *cli.Context) error { api, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if cctx.Bool("publish-now") { res, err := api.SectorPreCommitFlush(ctx) if err != nil { return xerrors.Errorf("flush: %w", err) } if res == nil { return xerrors.Errorf("no sectors to publish") } for i, re := range res { fmt.Printf("Batch %d:\n", i) if re.Error != "" { fmt.Printf("\tError: %s\n", re.Error) } else { fmt.Printf("\tMessage: %s\n", re.Msg) } fmt.Printf("\tSectors:\n") for _, sector := range re.Sectors { fmt.Printf("\t\t%d\tOK\n", sector) } } return nil } pending, err := api.SectorPreCommitPending(ctx) if err != nil { return xerrors.Errorf("getting pending deals: %w", err) } if len(pending) > 0 { for _, sector := range pending { fmt.Println(sector.Number) } return nil } fmt.Println("No sectors queued to be committed") return nil }, } var sectorsRefreshPieceMatchingCmd = &cli.Command{ Name: "match-pending-pieces", Usage: "force a refreshed match of pending pieces to open sectors without manually waiting for more deals", Action: func(cctx *cli.Context) error { nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) if err != nil { return err } defer closer() ctx := lcli.ReqContext(cctx) if err := nodeApi.SectorMatchPendingPiecesToOpenSectors(ctx); err != nil { return err } return nil }, } func yesno(b bool) string { if b { return color.GreenString("YES") } return color.RedString("NO") }