lotus/storage/sealing/fsm_events.go

134 lines
2.8 KiB
Go
Raw Normal View History

2020-01-15 20:53:14 +00:00
package sealing
import (
"github.com/ipfs/go-cid"
"github.com/filecoin-project/lotus/api"
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
}
// 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-01-16 02:54:57 +00:00
func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
log.Errorf("Fatal error on sector %d: %+v", state.SectorID, 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 api.SectorState
}
2020-01-16 02:54:57 +00:00
func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
state.State = evt.state
return true
}
// Normal path
2020-01-15 20:53:14 +00:00
type SectorStart struct {
id uint64
pieces []Piece
}
2020-01-16 02:54:57 +00:00
func (evt SectorStart) apply(state *SectorInfo) {
state.SectorID = evt.id
state.Pieces = evt.pieces
}
2020-01-15 20:53:14 +00:00
type SectorPacked struct{ pieces []Piece }
2020-01-16 02:54:57 +00:00
func (evt SectorPacked) apply(state *SectorInfo) {
state.Pieces = append(state.Pieces, evt.pieces...)
}
2020-01-15 20:53:14 +00:00
type SectorPackingFailed struct{ error }
func (evt SectorPackingFailed) apply(*SectorInfo) {}
2020-01-15 20:53:14 +00:00
type SectorSealed struct {
commR []byte
commD []byte
ticket SealTicket
}
2020-01-16 02:54:57 +00:00
func (evt SectorSealed) apply(state *SectorInfo) {
state.CommD = evt.commD
state.CommR = evt.commR
state.Ticket = evt.ticket
}
2020-01-15 20:53:14 +00:00
type SectorSealFailed struct{ error }
2020-01-16 02:54:57 +00:00
func (evt SectorSealFailed) apply(*SectorInfo) {}
2020-01-15 20:53:14 +00:00
type SectorPreCommitFailed struct{ error }
2020-01-16 02:54:57 +00:00
func (evt SectorPreCommitFailed) apply(*SectorInfo) {}
2020-01-15 20:53:14 +00:00
type SectorPreCommitted struct {
message cid.Cid
}
2020-01-16 02:54:57 +00:00
func (evt SectorPreCommitted) apply(state *SectorInfo) {
state.PreCommitMessage = &evt.message
}
2020-01-15 20:53:14 +00:00
type SectorSeedReady struct {
seed SealSeed
}
2020-01-16 02:54:57 +00:00
func (evt SectorSeedReady) apply(state *SectorInfo) {
state.Seed = evt.seed
}
2020-01-15 20:53:14 +00:00
2020-01-20 22:04:46 +00:00
type SectorComputeProofFailed struct{ error }
2020-01-20 08:23:56 +00:00
2020-01-15 20:53:14 +00:00
type SectorCommitFailed struct{ error }
2020-01-20 08:23:56 +00:00
func (evt SectorCommitFailed) apply(*SectorInfo) {}
2020-01-15 20:53:14 +00:00
type SectorCommitted struct {
message cid.Cid
proof []byte
}
2020-01-16 02:54:57 +00:00
func (evt SectorCommitted) apply(state *SectorInfo) {
state.Proof = evt.proof
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
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{}