sealing pipeline: Drop StateMinerActiveSectors

storage/adapter_storage_miner.go

@@ -9,7 +9,6 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	minertypes "github.com/filecoin-project/go-state-types/builtin/v8/miner"
@@ -41,12 +40,10 @@ func NewSealingAPIAdapter(api fullNodeFilteredAPI) SealingAPIAdapter {
 }
 
 func (s SealingAPIAdapter) StateMinerPreCommitDepositForPower(ctx context.Context, a address.Address, pci minertypes.SectorPreCommitInfo, tsk types.TipSetKey) (big.Int, error) {
-
 	return s.delegate.StateMinerPreCommitDepositForPower(ctx, a, pci, tsk)
 }
 
 func (s SealingAPIAdapter) StateMinerInitialPledgeCollateral(ctx context.Context, a address.Address, pci minertypes.SectorPreCommitInfo, tsk types.TipSetKey) (big.Int, error) {
-
 	return s.delegate.StateMinerInitialPledgeCollateral(ctx, a, pci, tsk)
 }
 
@@ -66,20 +63,44 @@ func (s SealingAPIAdapter) StateMinerSectorAllocated(ctx context.Context, maddr
 	return s.delegate.StateMinerSectorAllocated(ctx, maddr, sid, tsk)
 }
 
-func (s SealingAPIAdapter) StateMinerActiveSectors(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+func (s SealingAPIAdapter) StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
-	act, err := s.delegate.StateGetActor(ctx, maddr, tsk)
+	return s.delegate.StateSectorGetInfo(ctx, maddr, sectorNumber, tsk)
-	if err != nil {
+}
-		return bitfield.BitField{}, xerrors.Errorf("getting miner actor: temp error: %+v", err)
-	}
 
-	stor := store.ActorStore(ctx, blockstore.NewAPIBlockstore(s.delegate))
+func (s SealingAPIAdapter) StateMinerPartitions(ctx context.Context, maddr address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) {
+	return s.delegate.StateMinerPartitions(ctx, maddr, dlIdx, tsk)
+}
 
-	state, err := miner.Load(stor, act)
+func (s SealingAPIAdapter) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	if err != nil {
+	return s.delegate.StateLookupID(ctx, addr, tsk)
-		return bitfield.BitField{}, xerrors.Errorf("loading miner state: %+v", err)
+}
-	}
 
-	return miner.AllPartSectors(state, miner.Partition.ActiveSectors)
+func (s SealingAPIAdapter) StateMarketStorageDeal(ctx context.Context, dealID abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) {
+	return s.delegate.StateMarketStorageDeal(ctx, dealID, tsk)
+}
+
+func (s SealingAPIAdapter) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error) {
+	return s.delegate.StateNetworkVersion(ctx, tsk)
+}
+
+func (s SealingAPIAdapter) StateMinerProvingDeadline(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
+	return s.delegate.StateMinerProvingDeadline(ctx, maddr, tsk)
+}
+
+func (s SealingAPIAdapter) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error) {
+	return s.delegate.ChainGetMessage(ctx, mc)
+}
+
+func (s SealingAPIAdapter) StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) {
+	return s.delegate.StateGetRandomnessFromBeacon(ctx, personalization, randEpoch, entropy, tsk)
+}
+
+func (s SealingAPIAdapter) StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) {
+	return s.delegate.StateGetRandomnessFromTickets(ctx, personalization, randEpoch, entropy, tsk)
+}
+
+func (s SealingAPIAdapter) ChainReadObj(ctx context.Context, ocid cid.Cid) ([]byte, error) {
+	return s.delegate.ChainReadObj(ctx, ocid)
 }
 
 func (s SealingAPIAdapter) StateWaitMsg(ctx context.Context, mcid cid.Cid) (pipeline.MsgLookup, error) {
@@ -217,11 +238,6 @@ func (s SealingAPIAdapter) StateSectorPreCommitInfo(ctx context.Context, maddr a
 	return pci, nil
 }
 
-func (s SealingAPIAdapter) StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
-
-	return s.delegate.StateSectorGetInfo(ctx, maddr, sectorNumber, tsk)
-}
-
 func (s SealingAPIAdapter) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tsk types.TipSetKey) (*pipeline.SectorLocation, error) {
 
 	l, err := s.delegate.StateSectorPartition(ctx, maddr, sectorNumber, tsk)
@@ -238,18 +254,6 @@ func (s SealingAPIAdapter) StateSectorPartition(ctx context.Context, maddr addre
 	return nil, nil // not found
 }
 
-func (s SealingAPIAdapter) StateMinerPartitions(ctx context.Context, maddr address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) {
-	return s.delegate.StateMinerPartitions(ctx, maddr, dlIdx, tsk)
-}
-
-func (s SealingAPIAdapter) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	return s.delegate.StateLookupID(ctx, addr, tsk)
-}
-
-func (s SealingAPIAdapter) StateMarketStorageDeal(ctx context.Context, dealID abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) {
-	return s.delegate.StateMarketStorageDeal(ctx, dealID, tsk)
-}
-
 func (s SealingAPIAdapter) StateMarketStorageDealProposal(ctx context.Context, dealID abi.DealID, tsk types.TipSetKey) (market.DealProposal, error) {
 	deal, err := s.delegate.StateMarketStorageDeal(ctx, dealID, tsk)
 	if err != nil {
@@ -259,31 +263,6 @@ func (s SealingAPIAdapter) StateMarketStorageDealProposal(ctx context.Context, d
 	return deal.Proposal, nil
 }
 
-func (s SealingAPIAdapter) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error) {
-	return s.delegate.StateNetworkVersion(ctx, tsk)
-}
-
-func (s SealingAPIAdapter) StateMinerProvingDeadline(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
-	return s.delegate.StateMinerProvingDeadline(ctx, maddr, tsk)
-}
-
-func (s SealingAPIAdapter) SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, maxFee abi.TokenAmount, params []byte) (cid.Cid, error) {
-	msg := types.Message{
-		To:     to,
-		From:   from,
-		Value:  value,
-		Method: method,
-		Params: params,
-	}
-
-	smsg, err := s.delegate.MpoolPushMessage(ctx, &msg, &api.MessageSendSpec{MaxFee: maxFee})
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	return smsg.Cid(), nil
-}
-
 func (s SealingAPIAdapter) ChainHead(ctx context.Context) (types.TipSetKey, abi.ChainEpoch, error) {
 	head, err := s.delegate.ChainHead(ctx)
 	if err != nil {
@@ -302,18 +281,19 @@ func (s SealingAPIAdapter) ChainBaseFee(ctx context.Context, tsk types.TipSetKey
 	return ts.Blocks()[0].ParentBaseFee, nil
 }
 
-func (s SealingAPIAdapter) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error) {
+func (s SealingAPIAdapter) SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, maxFee abi.TokenAmount, params []byte) (cid.Cid, error) {
-	return s.delegate.ChainGetMessage(ctx, mc)
+	msg := types.Message{
-}
+		To:     to,
+		From:   from,
+		Value:  value,
+		Method: method,
+		Params: params,
+	}
 
-func (s SealingAPIAdapter) StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) {
+	smsg, err := s.delegate.MpoolPushMessage(ctx, &msg, &api.MessageSendSpec{MaxFee: maxFee})
-	return s.delegate.StateGetRandomnessFromBeacon(ctx, personalization, randEpoch, entropy, tsk)
+	if err != nil {
-}
+		return cid.Undef, err
+	}
 
-func (s SealingAPIAdapter) StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) {
+	return smsg.Cid(), nil
-	return s.delegate.StateGetRandomnessFromTickets(ctx, personalization, randEpoch, entropy, tsk)
-}
-
-func (s SealingAPIAdapter) ChainReadObj(ctx context.Context, ocid cid.Cid) ([]byte, error) {
-	return s.delegate.ChainReadObj(ctx, ocid)
 }

storage/pipeline/mocks/api.go

@@ -9,7 +9,6 @@ import (
 	reflect "reflect"
 
 	address "github.com/filecoin-project/go-address"
-	bitfield "github.com/filecoin-project/go-bitfield"
 	abi "github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
 	market "github.com/filecoin-project/go-state-types/builtin/v8/market"
@@ -213,21 +212,6 @@ func (mr *MockSealingAPIMockRecorder) StateMarketStorageDealProposal(arg0, arg1,
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateMarketStorageDealProposal", reflect.TypeOf((*MockSealingAPI)(nil).StateMarketStorageDealProposal), arg0, arg1, arg2)
 }
 
-// StateMinerActiveSectors mocks base method.
-func (m *MockSealingAPI) StateMinerActiveSectors(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (bitfield.BitField, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateMinerActiveSectors", arg0, arg1, arg2)
-	ret0, _ := ret[0].(bitfield.BitField)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateMinerActiveSectors indicates an expected call of StateMinerActiveSectors.
-func (mr *MockSealingAPIMockRecorder) StateMinerActiveSectors(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateMinerActiveSectors", reflect.TypeOf((*MockSealingAPI)(nil).StateMinerActiveSectors), arg0, arg1, arg2)
-}
-
 // StateMinerAvailableBalance mocks base method.
 func (m *MockSealingAPI) StateMinerAvailableBalance(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (big.Int, error) {
 	m.ctrl.T.Helper()
@@ -243,6 +227,21 @@ func (mr *MockSealingAPIMockRecorder) StateMinerAvailableBalance(arg0, arg1, arg
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateMinerAvailableBalance", reflect.TypeOf((*MockSealingAPI)(nil).StateMinerAvailableBalance), arg0, arg1, arg2)
 }
 
+// StateMinerDeadlines mocks base method.
+func (m *MockSealingAPI) StateMinerDeadlines(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) ([]api.Deadline, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StateMinerDeadlines", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]api.Deadline)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StateMinerDeadlines indicates an expected call of StateMinerDeadlines.
+func (mr *MockSealingAPIMockRecorder) StateMinerDeadlines(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateMinerDeadlines", reflect.TypeOf((*MockSealingAPI)(nil).StateMinerDeadlines), arg0, arg1, arg2)
+}
+
 // StateMinerInfo mocks base method.
 func (m *MockSealingAPI) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (api.MinerInfo, error) {
 	m.ctrl.T.Helper()

storage/pipeline/sealing.go

@@ -13,7 +13,6 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"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/builtin/v8/miner"
@@ -63,11 +62,11 @@ type SealingAPI interface {
 	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (big.Int, error)
 	StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error)
-	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error)
 	StateMarketStorageDealProposal(context.Context, abi.DealID, types.TipSetKey) (market.DealProposal, error)
 	StateNetworkVersion(ctx context.Context, tok types.TipSetKey) (network.Version, error)
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error)
 	StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tok types.TipSetKey) ([]api.Partition, error)
 	SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, maxFee abi.TokenAmount, params []byte) (cid.Cid, error)
 	ChainHead(ctx context.Context) (types.TipSetKey, abi.ChainEpoch, error)

storage/pipeline/upgrade_queue.go

@@ -51,10 +51,27 @@ func (m *Sealing) MarkForSnapUpgrade(ctx context.Context, id abi.SectorNumber) e
 }
 
 func (m *Sealing) sectorActive(ctx context.Context, tok types.TipSetKey, sector abi.SectorNumber) (bool, error) {
-	active, err := m.Api.StateMinerActiveSectors(ctx, m.maddr, tok)
+	dls, err := m.Api.StateMinerDeadlines(ctx, m.maddr, tok)
 	if err != nil {
-		return false, xerrors.Errorf("failed to check active sectors: %w", err)
+		return false, xerrors.Errorf("getting proving deadlines: %w", err)
 	}
 
-	return active.IsSet(uint64(sector))
+	for dl := range dls {
+		parts, err := m.Api.StateMinerPartitions(ctx, m.maddr, uint64(dl), tok)
+		if err != nil {
+			return false, xerrors.Errorf("getting partitions for deadline %d: %w", dl, err)
+		}
+
+		for p, part := range parts {
+			set, err := part.ActiveSectors.IsSet(uint64(sector))
+			if err != nil {
+				return false, xerrors.Errorf("checking if sector %d is in deadline %d partition %d: %w", sector, dl, p, err)
+			}
+			if set {
+				return true, nil
+			}
+		}
+	}
+
+	return false, nil
 }