lotus/extern/storage-sealing/sealing.go

279 lines
9.5 KiB
Go
Raw Normal View History

package sealing
import (
"context"
"errors"
2020-07-01 13:30:25 +00:00
"sync"
2021-01-18 20:59:34 +00:00
"time"
"github.com/ipfs/go-cid"
"github.com/ipfs/go-datastore"
"github.com/ipfs/go-datastore/namespace"
logging "github.com/ipfs/go-log/v2"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
2020-09-07 03:49:10 +00:00
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto"
2021-01-13 21:19:10 +00:00
"github.com/filecoin-project/go-state-types/dline"
2020-12-02 20:47:45 +00:00
"github.com/filecoin-project/go-state-types/network"
statemachine "github.com/filecoin-project/go-statemachine"
2020-12-02 20:47:45 +00:00
"github.com/filecoin-project/specs-storage/storage"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors/builtin/market"
2020-09-17 15:30:15 +00:00
"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
"github.com/filecoin-project/lotus/chain/types"
2020-08-17 13:39:33 +00:00
sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
2021-06-01 09:56:19 +00:00
"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
2021-06-08 13:43:43 +00:00
"github.com/filecoin-project/lotus/node/config"
)
const SectorStorePrefix = "/sectors"
2020-09-11 11:28:09 +00:00
var ErrTooManySectorsSealing = xerrors.New("too many sectors sealing")
var log = logging.Logger("sectors")
2020-07-15 14:51:02 +00:00
type SectorLocation struct {
2020-07-15 14:53:17 +00:00
Deadline uint64
2020-07-15 14:51:02 +00:00
Partition uint64
}
var ErrSectorAllocated = errors.New("sectorNumber is allocated, but PreCommit info wasn't found on chain")
//go:generate go run github.com/golang/mock/mockgen -destination=mocks/api.go -package=mocks . SealingAPI
type SealingAPI interface {
StateWaitMsg(context.Context, cid.Cid) (MsgLookup, error)
StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
2020-06-15 13:13:35 +00:00
StateComputeDataCommitment(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tok TipSetToken) (cid.Cid, error)
// Can return ErrSectorAllocated in case precommit info wasn't found, but the sector number is marked as allocated
2020-04-06 21:03:47 +00:00
StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*miner.SectorPreCommitOnChainInfo, error)
2020-05-28 00:10:50 +00:00
StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*miner.SectorOnChainInfo, error)
2020-07-15 14:51:02 +00:00
StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*SectorLocation, error)
StateLookupID(context.Context, address.Address, TipSetToken) (address.Address, error)
2020-04-06 20:23:37 +00:00
StateMinerSectorSize(context.Context, address.Address, TipSetToken) (abi.SectorSize, error)
StateMinerWorkerAddress(ctx context.Context, maddr address.Address, tok TipSetToken) (address.Address, error)
StateMinerPreCommitDepositForPower(context.Context, address.Address, miner.SectorPreCommitInfo, TipSetToken) (big.Int, error)
2020-06-26 15:58:29 +00:00
StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, TipSetToken) (big.Int, error)
StateMinerInfo(context.Context, address.Address, TipSetToken) (miner.MinerInfo, error)
StateMinerAvailableBalance(context.Context, address.Address, TipSetToken) (big.Int, error)
2020-10-13 19:35:29 +00:00
StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, TipSetToken) (bool, error)
StateMarketStorageDeal(context.Context, abi.DealID, TipSetToken) (*api.MarketDeal, error)
StateMarketStorageDealProposal(context.Context, abi.DealID, TipSetToken) (market.DealProposal, error)
2020-09-17 02:34:13 +00:00
StateNetworkVersion(ctx context.Context, tok TipSetToken) (network.Version, error)
2021-01-13 21:19:10 +00:00
StateMinerProvingDeadline(context.Context, address.Address, TipSetToken) (*dline.Info, error)
StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tok TipSetToken) ([]api.Partition, error)
2020-08-12 17:47:00 +00:00
SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, maxFee abi.TokenAmount, params []byte) (cid.Cid, error)
ChainHead(ctx context.Context) (TipSetToken, abi.ChainEpoch, error)
ChainBaseFee(context.Context, TipSetToken) (abi.TokenAmount, error)
ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tok TipSetToken) (abi.Randomness, error)
StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tok TipSetToken) (abi.Randomness, error)
2020-04-15 18:00:29 +00:00
ChainReadObj(context.Context, cid.Cid) ([]byte, error)
}
type SectorStateNotifee func(before, after SectorInfo)
2020-12-02 20:47:45 +00:00
type AddrSel func(ctx context.Context, mi miner.MinerInfo, use api.AddrUse, goodFunds, minFunds abi.TokenAmount) (address.Address, abi.TokenAmount, error)
type Sealing struct {
Api SealingAPI
DealInfo *CurrentDealInfoManager
2021-06-08 13:43:43 +00:00
feeCfg config.MinerFeeConfig
events Events
2021-06-15 19:04:11 +00:00
startupWait sync.WaitGroup
maddr address.Address
2020-03-23 11:40:02 +00:00
sealer sectorstorage.SectorManager
sectors *statemachine.StateGroup
2020-03-17 20:19:52 +00:00
sc SectorIDCounter
verif ffiwrapper.Verifier
2021-01-18 13:26:03 +00:00
pcp PreCommitPolicy
inputLk sync.Mutex
openSectors map[abi.SectorID]*openSector
sectorTimers map[abi.SectorID]*time.Timer
pendingPieces map[cid.Cid]*pendingPiece
assignedPieces map[abi.SectorID][]cid.Cid
creating *abi.SectorNumber // used to prevent a race where we could create a new sector more than once
2020-07-01 13:30:25 +00:00
upgradeLk sync.Mutex
toUpgrade map[abi.SectorNumber]struct{}
notifee SectorStateNotifee
2020-12-02 20:47:45 +00:00
addrSel AddrSel
stats SectorStats
2021-05-18 14:51:06 +00:00
terminator *TerminateBatcher
precommiter *PreCommitBatcher
commiter *CommitBatcher
2021-01-12 23:42:01 +00:00
2020-08-18 14:20:31 +00:00
getConfig GetSealingConfigFunc
2020-06-23 21:47:53 +00:00
}
2021-01-18 13:26:03 +00:00
type openSector struct {
used abi.UnpaddedPieceSize // change to bitfield/rle when AddPiece gains offset support to better fill sectors
maybeAccept func(cid.Cid) error // called with inputLk
}
2021-01-18 13:26:03 +00:00
type pendingPiece struct {
size abi.UnpaddedPieceSize
deal api.PieceDealInfo
2021-01-18 13:26:03 +00:00
data storage.Data
assigned bool // assigned to a sector?
accepted func(abi.SectorNumber, abi.UnpaddedPieceSize, error)
}
2021-06-16 09:43:06 +00:00
func New(mctx context.Context, api SealingAPI, fc config.MinerFeeConfig, events Events, maddr address.Address, ds datastore.Batching, sealer sectorstorage.SectorManager, sc SectorIDCounter, verif ffiwrapper.Verifier, prov ffiwrapper.Prover, pcp PreCommitPolicy, gc GetSealingConfigFunc, notifee SectorStateNotifee, as AddrSel) *Sealing {
s := &Sealing{
Api: api,
DealInfo: &CurrentDealInfoManager{api},
2020-08-12 17:47:00 +00:00
feeCfg: fc,
events: events,
maddr: maddr,
sealer: sealer,
sc: sc,
verif: verif,
pcp: pcp,
2020-07-01 14:33:59 +00:00
openSectors: map[abi.SectorID]*openSector{},
sectorTimers: map[abi.SectorID]*time.Timer{},
pendingPieces: map[cid.Cid]*pendingPiece{},
assignedPieces: map[abi.SectorID][]cid.Cid{},
toUpgrade: map[abi.SectorNumber]struct{}{},
notifee: notifee,
2020-12-02 20:47:45 +00:00
addrSel: as,
2021-06-16 09:43:06 +00:00
terminator: NewTerminationBatcher(mctx, maddr, api, as, fc, gc),
precommiter: NewPreCommitBatcher(mctx, maddr, api, as, fc, gc),
commiter: NewCommitBatcher(mctx, maddr, api, as, fc, gc, prov),
2021-01-12 23:42:01 +00:00
2020-08-18 14:20:31 +00:00
getConfig: gc,
stats: SectorStats{
bySector: map[abi.SectorID]SectorState{},
byState: map[SectorState]int64{},
},
}
2021-06-15 19:04:11 +00:00
s.startupWait.Add(1)
s.sectors = statemachine.New(namespace.Wrap(ds, datastore.NewKey(SectorStorePrefix)), s, SectorInfo{})
return s
}
func (m *Sealing) Run(ctx context.Context) error {
if err := m.restartSectors(ctx); err != nil {
log.Errorf("%+v", err)
return xerrors.Errorf("failed load sector states: %w", err)
}
return nil
}
func (m *Sealing) Stop(ctx context.Context) error {
2021-01-12 23:42:01 +00:00
if err := m.terminator.Stop(ctx); err != nil {
return err
}
if err := m.sectors.Stop(ctx); err != nil {
return err
}
return nil
}
2020-06-23 19:32:22 +00:00
func (m *Sealing) Remove(ctx context.Context, sid abi.SectorNumber) error {
2021-06-15 19:04:11 +00:00
m.startupWait.Wait()
2020-06-23 19:32:22 +00:00
return m.sectors.Send(uint64(sid), SectorRemove{})
}
2021-01-12 23:42:01 +00:00
func (m *Sealing) Terminate(ctx context.Context, sid abi.SectorNumber) error {
2021-06-15 19:04:11 +00:00
m.startupWait.Wait()
2021-01-12 23:42:01 +00:00
return m.sectors.Send(uint64(sid), SectorTerminate{})
}
2021-01-13 22:32:04 +00:00
func (m *Sealing) TerminateFlush(ctx context.Context) (*cid.Cid, error) {
return m.terminator.Flush(ctx)
}
2021-01-14 11:37:23 +00:00
func (m *Sealing) TerminatePending(ctx context.Context) ([]abi.SectorID, error) {
return m.terminator.Pending(ctx)
}
func (m *Sealing) SectorPreCommitFlush(ctx context.Context) ([]sealiface.PreCommitBatchRes, error) {
2021-05-18 14:51:06 +00:00
return m.precommiter.Flush(ctx)
}
func (m *Sealing) SectorPreCommitPending(ctx context.Context) ([]abi.SectorID, error) {
return m.precommiter.Pending(ctx)
}
2021-06-01 09:56:19 +00:00
func (m *Sealing) CommitFlush(ctx context.Context) ([]sealiface.CommitBatchRes, error) {
2021-03-10 15:16:44 +00:00
return m.commiter.Flush(ctx)
}
func (m *Sealing) CommitPending(ctx context.Context) ([]abi.SectorID, error) {
return m.commiter.Pending(ctx)
}
func (m *Sealing) currentSealProof(ctx context.Context) (abi.RegisteredSealProof, error) {
mi, err := m.Api.StateMinerInfo(ctx, m.maddr, nil)
if err != nil {
return 0, err
}
ver, err := m.Api.StateNetworkVersion(ctx, nil)
if err != nil {
return 0, err
}
return miner.PreferredSealProofTypeFromWindowPoStType(ver, mi.WindowPoStProofType)
}
func (m *Sealing) minerSector(spt abi.RegisteredSealProof, num abi.SectorNumber) storage.SectorRef {
return storage.SectorRef{
ID: m.minerSectorID(num),
ProofType: spt,
}
}
func (m *Sealing) minerSectorID(num abi.SectorNumber) abi.SectorID {
2020-03-17 20:19:52 +00:00
mid, err := address.IDFromAddress(m.maddr)
if err != nil {
panic(err)
}
return abi.SectorID{
Number: num,
2020-03-18 01:08:11 +00:00
Miner: abi.ActorID(mid),
2020-03-17 20:19:52 +00:00
}
}
func (m *Sealing) Address() address.Address {
return m.maddr
}
2020-07-20 16:43:19 +00:00
func getDealPerSectorLimit(size abi.SectorSize) (int, error) {
2020-07-20 16:43:19 +00:00
if size < 64<<30 {
return 256, nil
2020-07-20 16:43:19 +00:00
}
return 512, nil
2020-07-20 16:43:19 +00:00
}