lotus/extern/storage-sealing/fsm_events.go

528 lines
13 KiB
Go
Raw Normal View History

2020-01-15 20:53:14 +00:00
package sealing
import (
2021-01-18 20:59:34 +00:00
"time"
"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"
2020-06-26 15:58:29 +00:00
"github.com/filecoin-project/specs-storage/storage"
2021-01-18 20:59:34 +00:00
"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
2020-01-15 20:53:14 +00:00
)
type mutator interface {
apply(state *SectorInfo)
}
// 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
}
type Ignorable interface {
Ignore()
}
// Global events
type SectorRestart struct{}
2020-01-16 02:54:57 +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
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)
// 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 {
State SectorState
}
2020-01-16 02:54:57 +00:00
func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
2020-03-22 20:44:27 +00:00
state.State = evt.State
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
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-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
}
type SectorAddPiece struct{}
func (evt SectorAddPiece) apply(state *SectorInfo) {
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 {
NewPieces []Piece
}
func (evt SectorPieceAdded) apply(state *SectorInfo) {
state.Pieces = append(state.Pieces, evt.NewPieces...)
}
type SectorAddPieceFailed struct{ error }
func (evt SectorAddPieceFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
func (evt SectorAddPieceFailed) apply(si *SectorInfo) {}
type SectorRetryWaitDeals struct{}
func (evt SectorRetryWaitDeals) apply(si *SectorInfo) {}
type SectorStartPacking struct{}
func (evt SectorStartPacking) apply(*SectorInfo) {}
func (evt SectorStartPacking) Ignore() {}
type SectorPacked struct{ FillerPieces []abi.PieceInfo }
2020-01-16 02:54:57 +00:00
func (evt SectorPacked) apply(state *SectorInfo) {
for idx := range evt.FillerPieces {
state.Pieces = append(state.Pieces, Piece{
Piece: evt.FillerPieces[idx],
DealInfo: nil, // filler pieces don't have deals associated with them
})
}
}
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 {
PreCommit1Out storage.PreCommit1Out
}
func (evt SectorPreCommit1) apply(state *SectorInfo) {
state.PreCommit1Out = evt.PreCommit1Out
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
}
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 {
TipSet TipSetToken
}
func (evt SectorPreCommitLanded) apply(si *SectorInfo) {
si.PreCommitTipSet = evt.TipSet
}
type SectorSealPreCommit1Failed struct{ error }
2020-03-22 21:39:27 +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
si.PreCommit2Fails = 0
}
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-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
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-06-26 15:58:29 +00:00
state.PreCommitInfo = &evt.PreCommitInfo
}
2020-01-15 20:53:14 +00:00
type SectorSeedReady struct {
SeedValue abi.InteractiveSealRandomness
SeedEpoch abi.ChainEpoch
2020-01-15 20:53:14 +00:00
}
2020-01-16 02:54:57 +00:00
func (evt SectorSeedReady) apply(state *SectorInfo) {
state.SeedEpoch = evt.SeedEpoch
state.SeedValue = evt.SeedValue
}
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
type SectorRetrySubmitCommit struct{}
func (evt SectorRetrySubmitCommit) apply(*SectorInfo) {}
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 {
Proof []byte
2020-01-15 20:53:14 +00:00
}
2020-01-16 02:54:57 +00:00
func (evt SectorCommitted) apply(state *SectorInfo) {
2020-03-22 20:44:27 +00:00
state.Proof = evt.Proof
}
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) {}
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-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
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) {}
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
// Snap deals // CC update path
2022-03-16 16:33:05 +00:00
type SectorMarkForUpdate struct{}
func (evt SectorMarkForUpdate) apply(state *SectorInfo) {}
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
}
type SectorReplicaUpdate struct {
Out storage.ReplicaUpdateOut
}
func (evt SectorReplicaUpdate) apply(state *SectorInfo) {
state.UpdateSealed = &evt.Out.NewSealed
state.UpdateUnsealed = &evt.Out.NewUnsealed
}
type SectorProveReplicaUpdate struct {
Proof storage.ReplicaUpdateProof
}
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) {}
type SectorUpdateActive struct{}
func (evt SectorUpdateActive) apply(state *SectorInfo) {}
type SectorKeyReleased struct{}
func (evt SectorKeyReleased) apply(state *SectorInfo) {}
// Failed state recovery
type SectorRetrySealPreCommit1 struct{}
func (evt SectorRetrySealPreCommit1) apply(state *SectorInfo) {}
type SectorRetrySealPreCommit2 struct{}
func (evt SectorRetrySealPreCommit2) apply(state *SectorInfo) {}
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) {}
type SectorRetryComputeProof struct{}
func (evt SectorRetryComputeProof) apply(state *SectorInfo) {
state.InvalidProofs++
}
2020-04-04 01:50:05 +00:00
type SectorRetryInvalidProof struct{}
func (evt SectorRetryInvalidProof) apply(state *SectorInfo) {
state.InvalidProofs++
}
type SectorRetryCommitWait struct{}
func (evt SectorRetryCommitWait) apply(state *SectorInfo) {}
2020-08-27 21:14:46 +00:00
type SectorInvalidDealIDs struct {
Return ReturnState
}
func (evt SectorInvalidDealIDs) apply(state *SectorInfo) {
state.Return = evt.Return
}
2020-08-27 21:14:46 +00:00
type SectorUpdateDealIDs struct {
Updates map[int]abi.DealID
}
func (evt SectorUpdateDealIDs) apply(state *SectorInfo) {
for i, id := range evt.Updates {
state.Pieces[i].DealInfo.DealID = id
}
}
// 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
}
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) {}
type SectorReleaseKeyFailed struct{ error }
func (evt SectorReleaseKeyFailed) FormatError(xerrors.Printer) (next error) {
return evt.error
}
func (evt SectorReleaseKeyFailed) apply(state *SectorInfo) {}
// Faults
type SectorFaulty struct{}
2020-01-16 02:54:57 +00:00
func (evt SectorFaulty) apply(state *SectorInfo) {}
2020-01-15 20:53:14 +00:00
type SectorFaultReported struct{ reportMsg cid.Cid }
2020-01-16 02:54:57 +00:00
func (evt SectorFaultReported) apply(state *SectorInfo) {
state.FaultReportMsg = &evt.reportMsg
2020-01-15 20:53:14 +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
}
type SectorTerminating struct{ Message *cid.Cid }
2021-01-12 23:42:01 +00:00
func (evt SectorTerminating) apply(state *SectorInfo) {
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{}
func (evt SectorRemove) applyGlobal(state *SectorInfo) bool {
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) {}