lotus-miner: expose Config in StorageMiner; add SealingPipelineState …

…API endpoint

api/api_storage.go

@@ -112,6 +112,8 @@ type StorageMiner interface {
 	// SectorCommitPending returns a list of pending Commit sectors to be sent in the next aggregate message
 	SectorCommitPending(ctx context.Context) ([]abi.SectorID, error) //perm:admin
 
+	SealingPipelineState(ctx context.Context) (*SealingPipelineState, error) //perm:admin
+
 	// WorkerConnect tells the node to connect to workers RPC
 	WorkerConnect(context.Context, string) error                              //perm:admin retry:true
 	WorkerStats(context.Context) (map[uuid.UUID]storiface.WorkerStats, error) //perm:admin

api/types.go

@@ -195,3 +195,10 @@ type RetrievalInfo struct {
 	TransferChannelID *datatransfer.ChannelID
 	DataTransfer      *DataTransferChannel
 }
+
+type SealingPipelineState struct {
+	TaskJobsCount             map[string]int
+	MaxWaitDealsSectors       uint64
+	MaxSealingSectors         uint64
+	MaxSealingSectorsForDeals uint64
+}

cmd/lotus-miner/sealing.go

@@ -10,6 +10,7 @@ import (
 	"text/tabwriter"
 	"time"
 
+	"github.com/davecgh/go-spew/spew"
 	"github.com/fatih/color"
 	"github.com/google/uuid"
 	"github.com/urfave/cli/v2"
@@ -29,6 +30,7 @@ var sealingCmd = &cli.Command{
 		sealingWorkersCmd,
 		sealingSchedDiagCmd,
 		sealingAbortCmd,
+		sealingStateCmd,
 	},
 }
 
@@ -148,6 +150,34 @@ var sealingWorkersCmd = &cli.Command{
 	},
 }
 
+var sealingStateCmd = &cli.Command{
+	Name:  "state",
+	Usage: "state of sealing pipeline",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		if cctx.IsSet("color") {
+			color.NoColor = !cctx.Bool("color")
+		}
+
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+
+		res, err := api.SealingPipelineState(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting worker jobs: %w", err)
+		}
+
+		spew.Dump(res)
+
+		return nil
+	},
+}
+
 var sealingJobsCmd = &cli.Command{
 	Name:  "jobs",
 	Usage: "list running jobs",

documentation/en/api-v0-methods-miner.md

@@ -106,6 +106,7 @@
   * [RuntimeSubsystems](#RuntimeSubsystems)
 * [Sealing](#Sealing)
   * [SealingAbort](#SealingAbort)
+  * [SealingPipelineState](#SealingPipelineState)
   * [SealingSchedDiag](#SealingSchedDiag)
 * [Sector](#Sector)
   * [SectorAddPieceToAny](#SectorAddPieceToAny)
@@ -1710,6 +1711,25 @@ Inputs:
 
 Response: `{}`
 
+### SealingPipelineState
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "TasksStats": {
+    "name": 42
+  },
+  "MaxWaitDealsSectors": 42,
+  "MaxSealingSectors": 42,
+  "MaxSealingSectorsForDeals": 42
+}
+```
+
 ### SealingSchedDiag
 SealingSchedDiag dumps internal sealing scheduler state
 

go.mod

@@ -16,6 +16,7 @@ require (
 	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e
 	github.com/cockroachdb/pebble v0.0.0-20201001221639-879f3bfeef07
 	github.com/coreos/go-systemd/v22 v22.3.2
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e
 	github.com/dgraph-io/badger/v2 v2.2007.2
 	github.com/docker/go-units v0.4.0

node/builder_miner.go

@@ -77,6 +77,7 @@ func ConfigStorageMiner(c interface{}) Option {
 
 		Override(CheckFDLimit, modules.CheckFdLimit(build.MinerFDLimit)), // recommend at least 100k FD limit to miners
 
+		Override(new(*config.StorageMiner), cfg),
 		Override(new(api.MinerSubsystems), modules.ExtractEnabledMinerSubsystems(cfg.Subsystems)),
 		Override(new(stores.LocalStorage), From(new(repo.LockedRepo))),
 		Override(new(*stores.Local), modules.LocalStorage),

node/impl/storminer.go

@@ -47,6 +47,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/markets/storageadapter"
 	"github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node/config"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/storage"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
@@ -60,6 +61,8 @@ type StorageMinerAPI struct {
 
 	EnabledSubsystems api.MinerSubsystems
 
+	Config *config.StorageMiner
+
 	Full        api.FullNode
 	LocalStore  *stores.Local
 	RemoteStore *stores.Remote
@@ -123,6 +126,28 @@ func (sm *StorageMinerAPI) ServeRemote(perm bool) func(w http.ResponseWriter, r
 	}
 }
 
+func (sm *StorageMinerAPI) SealingPipelineState(ctx context.Context) (*api.SealingPipelineState, error) {
+	jobs, err := sm.WorkerJobs(ctx)
+	if err != nil {
+		return nil, xerrors.Errorf("getting worker jobs: %w", err)
+	}
+
+	jobsCount := make(map[string]int)
+
+	for _, wj := range jobs {
+		for _, j := range wj {
+			jobsCount[j.Task.Short()] = jobsCount[j.Task.Short()] + 1
+		}
+	}
+
+	return &api.SealingPipelineState{
+		TaskJobsCount:             jobsCount,
+		MaxWaitDealsSectors:       sm.Config.Sealing.MaxWaitDealsSectors,
+		MaxSealingSectors:         sm.Config.Sealing.MaxSealingSectors,
+		MaxSealingSectorsForDeals: sm.Config.Sealing.MaxSealingSectorsForDeals,
+	}, nil
+}
+
 func (sm *StorageMinerAPI) WorkerStats(context.Context) (map[uuid.UUID]storiface.WorkerStats, error) {
 	return sm.StorageMgr.WorkerStats(), nil
 }