2020-01-15 20:53:14 +00:00
|
|
|
package sealing
|
|
|
|
|
|
|
|
import (
|
2021-01-18 20:59:34 +00:00
|
|
|
"time"
|
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
"github.com/ipfs/go-cid"
|
2020-03-22 20:44:27 +00:00
|
|
|
"golang.org/x/xerrors"
|
2020-06-26 15:58:29 +00:00
|
|
|
|
2020-09-07 03:49:10 +00:00
|
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
|
|
"github.com/filecoin-project/go-state-types/big"
|
2022-09-06 15:49:29 +00:00
|
|
|
"github.com/filecoin-project/go-state-types/builtin/v9/miner"
|
2022-06-16 09:12:33 +00:00
|
|
|
|
2022-08-26 00:37:36 +00:00
|
|
|
"github.com/filecoin-project/lotus/api"
|
2022-06-16 09:12:33 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/types"
|
2022-06-17 11:31:05 +00:00
|
|
|
"github.com/filecoin-project/lotus/storage/sealer/storiface"
|
2020-01-15 20:53:14 +00:00
|
|
|
)
|
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
type mutator interface {
|
|
|
|
apply(state *SectorInfo)
|
|
|
|
}
|
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
// globalMutator is an event which can apply in every state
|
|
|
|
type globalMutator interface {
|
|
|
|
// applyGlobal applies the event to the state. If if returns true,
|
|
|
|
// event processing should be interrupted
|
|
|
|
applyGlobal(state *SectorInfo) bool
|
|
|
|
}
|
|
|
|
|
2020-07-06 17:04:11 +00:00
|
|
|
type Ignorable interface {
|
|
|
|
Ignore()
|
|
|
|
}
|
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
// Global events
|
|
|
|
|
|
|
|
type SectorRestart struct{}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
func (evt SectorRestart) applyGlobal(*SectorInfo) bool { return false }
|
|
|
|
|
|
|
|
type SectorFatalError struct{ error }
|
2020-03-22 21:39:27 +00:00
|
|
|
|
|
|
|
func (evt SectorFatalError) FormatError(xerrors.Printer) (next error) { return evt.error }
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
|
2020-04-06 22:31:33 +00:00
|
|
|
log.Errorf("Fatal error on sector %d: %+v", state.SectorNumber, evt.error)
|
2020-01-16 02:53:59 +00:00
|
|
|
// TODO: Do we want to mark the state as unrecoverable?
|
|
|
|
// I feel like this should be a softer error, where the user would
|
|
|
|
// be able to send a retry event of some kind
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorForceState struct {
|
2020-04-06 18:07:26 +00:00
|
|
|
State SectorState
|
2020-01-16 02:53:59 +00:00
|
|
|
}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
|
2020-03-22 20:44:27 +00:00
|
|
|
state.State = evt.State
|
2020-01-16 02:53:59 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Normal path
|
|
|
|
|
2020-01-15 20:53:14 +00:00
|
|
|
type SectorStart struct {
|
2020-03-22 20:44:27 +00:00
|
|
|
ID abi.SectorNumber
|
2020-06-15 13:13:35 +00:00
|
|
|
SectorType abi.RegisteredSealProof
|
2020-01-15 20:53:14 +00:00
|
|
|
}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
func (evt SectorStart) apply(state *SectorInfo) {
|
2020-04-06 22:31:33 +00:00
|
|
|
state.SectorNumber = evt.ID
|
2020-03-22 20:44:27 +00:00
|
|
|
state.SectorType = evt.SectorType
|
2020-01-16 01:25:49 +00:00
|
|
|
}
|
|
|
|
|
2020-06-23 19:32:22 +00:00
|
|
|
type SectorStartCC struct {
|
|
|
|
ID abi.SectorNumber
|
|
|
|
SectorType abi.RegisteredSealProof
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorStartCC) apply(state *SectorInfo) {
|
|
|
|
state.SectorNumber = evt.ID
|
|
|
|
state.SectorType = evt.SectorType
|
|
|
|
}
|
|
|
|
|
2021-01-20 15:00:00 +00:00
|
|
|
type SectorAddPiece struct{}
|
2020-06-23 19:59:57 +00:00
|
|
|
|
|
|
|
func (evt SectorAddPiece) apply(state *SectorInfo) {
|
2021-01-20 13:49:31 +00:00
|
|
|
if state.CreationTime == 0 {
|
|
|
|
state.CreationTime = time.Now().Unix()
|
2021-01-18 20:59:34 +00:00
|
|
|
}
|
2021-01-18 13:26:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type SectorPieceAdded struct {
|
2022-08-26 00:37:36 +00:00
|
|
|
NewPieces []api.SectorPiece
|
2021-01-18 13:26:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorPieceAdded) apply(state *SectorInfo) {
|
|
|
|
state.Pieces = append(state.Pieces, evt.NewPieces...)
|
2020-06-23 19:59:57 +00:00
|
|
|
}
|
|
|
|
|
2021-01-20 17:42:22 +00:00
|
|
|
type SectorAddPieceFailed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorAddPieceFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorAddPieceFailed) apply(si *SectorInfo) {}
|
|
|
|
|
2021-10-04 18:00:07 +00:00
|
|
|
type SectorRetryWaitDeals struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryWaitDeals) apply(si *SectorInfo) {}
|
|
|
|
|
2020-06-23 19:59:57 +00:00
|
|
|
type SectorStartPacking struct{}
|
|
|
|
|
|
|
|
func (evt SectorStartPacking) apply(*SectorInfo) {}
|
|
|
|
|
2020-07-06 17:04:11 +00:00
|
|
|
func (evt SectorStartPacking) Ignore() {}
|
|
|
|
|
2020-04-07 21:44:33 +00:00
|
|
|
type SectorPacked struct{ FillerPieces []abi.PieceInfo }
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
func (evt SectorPacked) apply(state *SectorInfo) {
|
2020-04-07 21:44:33 +00:00
|
|
|
for idx := range evt.FillerPieces {
|
2022-08-26 00:37:36 +00:00
|
|
|
state.Pieces = append(state.Pieces, api.SectorPiece{
|
2020-04-07 21:44:33 +00:00
|
|
|
Piece: evt.FillerPieces[idx],
|
|
|
|
DealInfo: nil, // filler pieces don't have deals associated with them
|
|
|
|
})
|
|
|
|
}
|
2020-01-16 01:25:49 +00:00
|
|
|
}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
2020-09-29 07:57:36 +00:00
|
|
|
type SectorTicket struct {
|
|
|
|
TicketValue abi.SealRandomness
|
|
|
|
TicketEpoch abi.ChainEpoch
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorTicket) apply(state *SectorInfo) {
|
|
|
|
state.TicketEpoch = evt.TicketEpoch
|
|
|
|
state.TicketValue = evt.TicketValue
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorOldTicket struct{}
|
|
|
|
|
|
|
|
func (evt SectorOldTicket) apply(*SectorInfo) {}
|
|
|
|
|
2020-04-03 16:54:01 +00:00
|
|
|
type SectorPreCommit1 struct {
|
2022-06-17 11:31:05 +00:00
|
|
|
PreCommit1Out storiface.PreCommit1Out
|
2020-04-03 16:54:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorPreCommit1) apply(state *SectorInfo) {
|
|
|
|
state.PreCommit1Out = evt.PreCommit1Out
|
2020-06-04 15:29:31 +00:00
|
|
|
state.PreCommit2Fails = 0
|
2020-04-03 16:54:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type SectorPreCommit2 struct {
|
2020-03-22 20:44:27 +00:00
|
|
|
Sealed cid.Cid
|
|
|
|
Unsealed cid.Cid
|
2020-01-15 20:53:14 +00:00
|
|
|
}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-04-03 16:54:01 +00:00
|
|
|
func (evt SectorPreCommit2) apply(state *SectorInfo) {
|
2020-03-22 20:44:27 +00:00
|
|
|
commd := evt.Unsealed
|
2020-02-27 00:42:39 +00:00
|
|
|
state.CommD = &commd
|
2020-03-22 20:44:27 +00:00
|
|
|
commr := evt.Sealed
|
2020-02-27 00:42:39 +00:00
|
|
|
state.CommR = &commr
|
2020-01-16 01:25:49 +00:00
|
|
|
}
|
|
|
|
|
2021-05-18 15:21:10 +00:00
|
|
|
type SectorPreCommitBatch struct{}
|
|
|
|
|
|
|
|
func (evt SectorPreCommitBatch) apply(*SectorInfo) {}
|
|
|
|
|
2021-05-18 15:37:52 +00:00
|
|
|
type SectorPreCommitBatchSent struct {
|
|
|
|
Message cid.Cid
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorPreCommitBatchSent) apply(state *SectorInfo) {
|
|
|
|
state.PreCommitMessage = &evt.Message
|
|
|
|
}
|
|
|
|
|
2020-05-18 22:49:21 +00:00
|
|
|
type SectorPreCommitLanded struct {
|
2022-06-16 09:12:33 +00:00
|
|
|
TipSet types.TipSetKey
|
2020-05-18 22:49:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorPreCommitLanded) apply(si *SectorInfo) {
|
|
|
|
si.PreCommitTipSet = evt.TipSet
|
|
|
|
}
|
|
|
|
|
2020-06-04 15:29:31 +00:00
|
|
|
type SectorSealPreCommit1Failed struct{ error }
|
2020-03-22 21:39:27 +00:00
|
|
|
|
2020-06-04 15:29:31 +00:00
|
|
|
func (evt SectorSealPreCommit1Failed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorSealPreCommit1Failed) apply(si *SectorInfo) {
|
2020-04-04 01:50:05 +00:00
|
|
|
si.InvalidProofs = 0 // reset counter
|
2020-06-04 15:29:31 +00:00
|
|
|
si.PreCommit2Fails = 0
|
2023-09-21 15:37:02 +00:00
|
|
|
|
|
|
|
si.PreCommit1Fails++
|
2020-06-04 15:29:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type SectorSealPreCommit2Failed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorSealPreCommit2Failed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorSealPreCommit2Failed) apply(si *SectorInfo) {
|
|
|
|
si.InvalidProofs = 0 // reset counter
|
|
|
|
si.PreCommit2Fails++
|
2020-04-04 01:50:05 +00:00
|
|
|
}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
2020-04-03 16:54:01 +00:00
|
|
|
type SectorChainPreCommitFailed struct{ error }
|
2020-03-22 21:39:27 +00:00
|
|
|
|
2020-04-03 16:54:01 +00:00
|
|
|
func (evt SectorChainPreCommitFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorChainPreCommitFailed) apply(*SectorInfo) {}
|
2020-01-16 01:25:49 +00:00
|
|
|
|
2020-01-15 20:53:14 +00:00
|
|
|
type SectorPreCommitted struct {
|
2020-07-01 14:34:05 +00:00
|
|
|
Message cid.Cid
|
2020-07-01 14:33:59 +00:00
|
|
|
PreCommitDeposit big.Int
|
2020-07-01 14:34:05 +00:00
|
|
|
PreCommitInfo miner.SectorPreCommitInfo
|
2020-01-15 20:53:14 +00:00
|
|
|
}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
func (evt SectorPreCommitted) apply(state *SectorInfo) {
|
2020-03-22 20:44:27 +00:00
|
|
|
state.PreCommitMessage = &evt.Message
|
2020-07-01 14:33:59 +00:00
|
|
|
state.PreCommitDeposit = evt.PreCommitDeposit
|
2020-01-16 01:25:49 +00:00
|
|
|
}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
|
|
|
type SectorSeedReady struct {
|
2020-04-06 18:07:26 +00:00
|
|
|
SeedValue abi.InteractiveSealRandomness
|
|
|
|
SeedEpoch abi.ChainEpoch
|
2020-01-15 20:53:14 +00:00
|
|
|
}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
func (evt SectorSeedReady) apply(state *SectorInfo) {
|
2020-04-06 18:07:26 +00:00
|
|
|
state.SeedEpoch = evt.SeedEpoch
|
|
|
|
state.SeedValue = evt.SeedValue
|
2020-01-16 01:25:49 +00:00
|
|
|
}
|
2022-09-09 08:32:27 +00:00
|
|
|
|
|
|
|
type SectorRemoteCommit1Failed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorRemoteCommit1Failed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorRemoteCommit1Failed) apply(*SectorInfo) {}
|
2022-09-09 10:54:48 +00:00
|
|
|
|
|
|
|
type SectorRemoteCommit2Failed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorRemoteCommit2Failed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorRemoteCommit2Failed) apply(*SectorInfo) {}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
2020-01-20 22:04:46 +00:00
|
|
|
type SectorComputeProofFailed struct{ error }
|
2020-03-22 21:39:27 +00:00
|
|
|
|
|
|
|
func (evt SectorComputeProofFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorComputeProofFailed) apply(*SectorInfo) {}
|
2020-01-20 08:23:56 +00:00
|
|
|
|
2020-01-15 20:53:14 +00:00
|
|
|
type SectorCommitFailed struct{ error }
|
2020-03-22 21:39:27 +00:00
|
|
|
|
|
|
|
func (evt SectorCommitFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorCommitFailed) apply(*SectorInfo) {}
|
2020-01-20 08:23:56 +00:00
|
|
|
|
2020-08-27 12:02:00 +00:00
|
|
|
type SectorRetrySubmitCommit struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetrySubmitCommit) apply(*SectorInfo) {}
|
|
|
|
|
2020-08-27 11:51:13 +00:00
|
|
|
type SectorDealsExpired struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorDealsExpired) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorDealsExpired) apply(*SectorInfo) {}
|
|
|
|
|
2020-10-13 19:35:29 +00:00
|
|
|
type SectorTicketExpired struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorTicketExpired) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorTicketExpired) apply(*SectorInfo) {}
|
|
|
|
|
2020-01-15 20:53:14 +00:00
|
|
|
type SectorCommitted struct {
|
2020-08-27 10:57:08 +00:00
|
|
|
Proof []byte
|
2020-01-15 20:53:14 +00:00
|
|
|
}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
func (evt SectorCommitted) apply(state *SectorInfo) {
|
2020-03-22 20:44:27 +00:00
|
|
|
state.Proof = evt.Proof
|
2020-08-27 10:57:08 +00:00
|
|
|
}
|
|
|
|
|
2021-06-11 09:41:28 +00:00
|
|
|
// like SectorCommitted, but finalizes before sending the proof to the chain
|
|
|
|
type SectorProofReady struct {
|
|
|
|
Proof []byte
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorProofReady) apply(state *SectorInfo) {
|
|
|
|
state.Proof = evt.Proof
|
|
|
|
}
|
|
|
|
|
2021-03-10 15:16:44 +00:00
|
|
|
type SectorSubmitCommitAggregate struct{}
|
|
|
|
|
|
|
|
func (evt SectorSubmitCommitAggregate) apply(*SectorInfo) {}
|
|
|
|
|
2020-08-27 10:57:08 +00:00
|
|
|
type SectorCommitSubmitted struct {
|
|
|
|
Message cid.Cid
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorCommitSubmitted) apply(state *SectorInfo) {
|
2020-03-22 20:44:27 +00:00
|
|
|
state.CommitMessage = &evt.Message
|
2020-01-16 01:25:49 +00:00
|
|
|
}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
2021-03-10 15:16:44 +00:00
|
|
|
type SectorCommitAggregateSent struct {
|
|
|
|
Message cid.Cid
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorCommitAggregateSent) apply(state *SectorInfo) {
|
|
|
|
state.CommitMessage = &evt.Message
|
|
|
|
}
|
|
|
|
|
2020-01-15 20:53:14 +00:00
|
|
|
type SectorProving struct{}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 01:25:49 +00:00
|
|
|
func (evt SectorProving) apply(*SectorInfo) {}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
2020-01-29 21:25:06 +00:00
|
|
|
type SectorFinalized struct{}
|
|
|
|
|
|
|
|
func (evt SectorFinalized) apply(*SectorInfo) {}
|
|
|
|
|
2022-03-16 18:29:47 +00:00
|
|
|
type SectorFinalizedAvailable struct{}
|
|
|
|
|
|
|
|
func (evt SectorFinalizedAvailable) apply(*SectorInfo) {}
|
|
|
|
|
2020-06-03 21:42:13 +00:00
|
|
|
type SectorRetryFinalize struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryFinalize) apply(*SectorInfo) {}
|
|
|
|
|
2020-01-29 21:25:06 +00:00
|
|
|
type SectorFinalizeFailed struct{ error }
|
2020-03-22 21:39:27 +00:00
|
|
|
|
|
|
|
func (evt SectorFinalizeFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorFinalizeFailed) apply(*SectorInfo) {}
|
2020-01-29 21:25:06 +00:00
|
|
|
|
2021-12-08 17:11:19 +00:00
|
|
|
// Snap deals // CC update path
|
|
|
|
|
2022-03-16 16:33:05 +00:00
|
|
|
type SectorMarkForUpdate struct{}
|
|
|
|
|
|
|
|
func (evt SectorMarkForUpdate) apply(state *SectorInfo) {}
|
|
|
|
|
2021-12-08 17:11:19 +00:00
|
|
|
type SectorStartCCUpdate struct{}
|
|
|
|
|
|
|
|
func (evt SectorStartCCUpdate) apply(state *SectorInfo) {
|
|
|
|
state.CCUpdate = true
|
|
|
|
// Clear filler piece but remember in case of abort
|
|
|
|
state.CCPieces = state.Pieces
|
|
|
|
state.Pieces = nil
|
2022-11-14 17:10:53 +00:00
|
|
|
|
|
|
|
// Clear CreationTime in case this sector was accepting piece data previously
|
|
|
|
state.CreationTime = 0
|
2021-12-08 17:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type SectorReplicaUpdate struct {
|
2022-06-17 11:31:05 +00:00
|
|
|
Out storiface.ReplicaUpdateOut
|
2021-12-08 17:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorReplicaUpdate) apply(state *SectorInfo) {
|
|
|
|
state.UpdateSealed = &evt.Out.NewSealed
|
|
|
|
state.UpdateUnsealed = &evt.Out.NewUnsealed
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorProveReplicaUpdate struct {
|
2022-06-17 11:31:05 +00:00
|
|
|
Proof storiface.ReplicaUpdateProof
|
2021-12-08 17:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorProveReplicaUpdate) apply(state *SectorInfo) {
|
|
|
|
state.ReplicaUpdateProof = evt.Proof
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorReplicaUpdateSubmitted struct {
|
|
|
|
Message cid.Cid
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorReplicaUpdateSubmitted) apply(state *SectorInfo) {
|
|
|
|
state.ReplicaUpdateMessage = &evt.Message
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorReplicaUpdateLanded struct{}
|
|
|
|
|
|
|
|
func (evt SectorReplicaUpdateLanded) apply(state *SectorInfo) {}
|
|
|
|
|
2022-02-09 11:41:39 +00:00
|
|
|
type SectorUpdateActive struct{}
|
|
|
|
|
|
|
|
func (evt SectorUpdateActive) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorKeyReleased struct{}
|
|
|
|
|
|
|
|
func (evt SectorKeyReleased) apply(state *SectorInfo) {}
|
|
|
|
|
2020-01-23 15:38:01 +00:00
|
|
|
// Failed state recovery
|
|
|
|
|
2020-06-04 15:29:31 +00:00
|
|
|
type SectorRetrySealPreCommit1 struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetrySealPreCommit1) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorRetrySealPreCommit2 struct{}
|
2020-01-23 15:38:01 +00:00
|
|
|
|
2020-06-04 15:29:31 +00:00
|
|
|
func (evt SectorRetrySealPreCommit2) apply(state *SectorInfo) {}
|
2020-01-23 15:38:01 +00:00
|
|
|
|
2020-01-23 17:34:04 +00:00
|
|
|
type SectorRetryPreCommit struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryPreCommit) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorRetryWaitSeed struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryWaitSeed) apply(state *SectorInfo) {}
|
|
|
|
|
2020-06-17 15:19:36 +00:00
|
|
|
type SectorRetryPreCommitWait struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryPreCommitWait) apply(state *SectorInfo) {}
|
|
|
|
|
2020-04-03 17:45:48 +00:00
|
|
|
type SectorRetryComputeProof struct{}
|
|
|
|
|
2020-06-02 20:30:40 +00:00
|
|
|
func (evt SectorRetryComputeProof) apply(state *SectorInfo) {
|
|
|
|
state.InvalidProofs++
|
|
|
|
}
|
2020-04-03 17:45:48 +00:00
|
|
|
|
2020-04-04 01:50:05 +00:00
|
|
|
type SectorRetryInvalidProof struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryInvalidProof) apply(state *SectorInfo) {
|
|
|
|
state.InvalidProofs++
|
|
|
|
}
|
|
|
|
|
2020-08-18 16:02:13 +00:00
|
|
|
type SectorRetryCommitWait struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryCommitWait) apply(state *SectorInfo) {}
|
|
|
|
|
2020-08-27 21:14:46 +00:00
|
|
|
type SectorInvalidDealIDs struct {
|
2020-08-27 19:04:43 +00:00
|
|
|
Return ReturnState
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorInvalidDealIDs) apply(state *SectorInfo) {
|
|
|
|
state.Return = evt.Return
|
|
|
|
}
|
|
|
|
|
2020-08-27 21:14:46 +00:00
|
|
|
type SectorUpdateDealIDs struct {
|
2020-08-27 19:04:43 +00:00
|
|
|
Updates map[int]abi.DealID
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorUpdateDealIDs) apply(state *SectorInfo) {
|
|
|
|
for i, id := range evt.Updates {
|
|
|
|
state.Pieces[i].DealInfo.DealID = id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-08 17:11:19 +00:00
|
|
|
// Snap Deals failure and recovery
|
|
|
|
|
|
|
|
type SectorRetryReplicaUpdate struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryReplicaUpdate) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorRetryProveReplicaUpdate struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetryProveReplicaUpdate) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorUpdateReplicaFailed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorUpdateReplicaFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorUpdateReplicaFailed) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorProveReplicaUpdateFailed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorProveReplicaUpdateFailed) FormatError(xerrors.Printer) (next error) {
|
|
|
|
return evt.error
|
|
|
|
}
|
|
|
|
func (evt SectorProveReplicaUpdateFailed) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorAbortUpgrade struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorAbortUpgrade) apply(state *SectorInfo) {}
|
|
|
|
func (evt SectorAbortUpgrade) FormatError(xerrors.Printer) (next error) {
|
|
|
|
return evt.error
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorRevertUpgradeToProving struct{}
|
|
|
|
|
|
|
|
func (evt SectorRevertUpgradeToProving) apply(state *SectorInfo) {
|
|
|
|
// cleanup sector state so that it is back in proving
|
|
|
|
state.CCUpdate = false
|
|
|
|
state.UpdateSealed = nil
|
|
|
|
state.UpdateUnsealed = nil
|
|
|
|
state.ReplicaUpdateProof = nil
|
|
|
|
state.ReplicaUpdateMessage = nil
|
|
|
|
state.Pieces = state.CCPieces
|
|
|
|
state.CCPieces = nil
|
2022-11-14 17:25:47 +00:00
|
|
|
state.CreationTime = 0
|
2021-12-08 17:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type SectorRetrySubmitReplicaUpdateWait struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetrySubmitReplicaUpdateWait) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorRetrySubmitReplicaUpdate struct{}
|
|
|
|
|
|
|
|
func (evt SectorRetrySubmitReplicaUpdate) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorSubmitReplicaUpdateFailed struct{}
|
|
|
|
|
|
|
|
func (evt SectorSubmitReplicaUpdateFailed) apply(state *SectorInfo) {}
|
|
|
|
|
2022-11-07 14:56:53 +00:00
|
|
|
type SectorDeadlineImmutable struct{}
|
|
|
|
|
|
|
|
func (evt SectorDeadlineImmutable) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorDeadlineMutable struct{}
|
|
|
|
|
|
|
|
func (evt SectorDeadlineMutable) apply(state *SectorInfo) {}
|
|
|
|
|
2022-02-09 11:41:39 +00:00
|
|
|
type SectorReleaseKeyFailed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorReleaseKeyFailed) FormatError(xerrors.Printer) (next error) {
|
|
|
|
return evt.error
|
|
|
|
}
|
|
|
|
func (evt SectorReleaseKeyFailed) apply(state *SectorInfo) {}
|
|
|
|
|
2020-01-23 15:38:01 +00:00
|
|
|
// Faults
|
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
type SectorFaulty struct{}
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
func (evt SectorFaulty) apply(state *SectorInfo) {}
|
2020-01-15 20:53:14 +00:00
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
type SectorFaultReported struct{ reportMsg cid.Cid }
|
2020-01-16 02:54:57 +00:00
|
|
|
|
2020-01-16 02:53:59 +00:00
|
|
|
func (evt SectorFaultReported) apply(state *SectorInfo) {
|
|
|
|
state.FaultReportMsg = &evt.reportMsg
|
2020-01-15 20:53:14 +00:00
|
|
|
}
|
2020-01-16 02:53:59 +00:00
|
|
|
|
|
|
|
type SectorFaultedFinal struct{}
|
2020-06-22 16:42:38 +00:00
|
|
|
|
2021-01-12 23:42:01 +00:00
|
|
|
// Terminating
|
|
|
|
|
|
|
|
type SectorTerminate struct{}
|
|
|
|
|
|
|
|
func (evt SectorTerminate) applyGlobal(state *SectorInfo) bool {
|
|
|
|
state.State = Terminating
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2021-01-14 16:14:26 +00:00
|
|
|
type SectorTerminating struct{ Message *cid.Cid }
|
2021-01-12 23:42:01 +00:00
|
|
|
|
|
|
|
func (evt SectorTerminating) apply(state *SectorInfo) {
|
2021-01-14 16:14:26 +00:00
|
|
|
state.TerminateMessage = evt.Message
|
2021-01-12 23:42:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type SectorTerminated struct{ TerminatedAt abi.ChainEpoch }
|
|
|
|
|
|
|
|
func (evt SectorTerminated) apply(state *SectorInfo) {
|
|
|
|
state.TerminatedAt = evt.TerminatedAt
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorTerminateFailed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorTerminateFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorTerminateFailed) apply(*SectorInfo) {}
|
|
|
|
|
2020-06-22 16:42:38 +00:00
|
|
|
// External events
|
|
|
|
|
|
|
|
type SectorRemove struct{}
|
|
|
|
|
2020-08-27 10:39:20 +00:00
|
|
|
func (evt SectorRemove) applyGlobal(state *SectorInfo) bool {
|
2022-09-09 12:38:23 +00:00
|
|
|
// because this event is global we need to send the notification here instead through an fsm callback
|
|
|
|
maybeNotifyRemoteDone(false, "Removing")(state)
|
|
|
|
|
2020-08-27 10:39:20 +00:00
|
|
|
state.State = Removing
|
|
|
|
return true
|
|
|
|
}
|
2020-06-22 16:42:38 +00:00
|
|
|
|
|
|
|
type SectorRemoved struct{}
|
|
|
|
|
|
|
|
func (evt SectorRemoved) apply(state *SectorInfo) {}
|
|
|
|
|
|
|
|
type SectorRemoveFailed struct{ error }
|
|
|
|
|
|
|
|
func (evt SectorRemoveFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
|
|
|
|
func (evt SectorRemoveFailed) apply(*SectorInfo) {}
|
2022-08-31 10:43:40 +00:00
|
|
|
|
|
|
|
type SectorReceive struct {
|
|
|
|
State SectorInfo
|
|
|
|
}
|
|
|
|
|
|
|
|
func (evt SectorReceive) apply(state *SectorInfo) {
|
|
|
|
*state = evt.State
|
|
|
|
}
|
|
|
|
|
|
|
|
type SectorReceived struct{}
|
|
|
|
|
|
|
|
func (evt SectorReceived) apply(state *SectorInfo) {}
|