290 lines
9.6 KiB
Go
290 lines
9.6 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/build"
|
|
"github.com/filecoin-project/lotus/chain/actors"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/lib/sectorbuilder"
|
|
)
|
|
|
|
type providerHandlerFunc func(ctx context.Context, deal SectorInfo) *sectorUpdate
|
|
|
|
func (m *Miner) handleSectorUpdate(ctx context.Context, sector SectorInfo, cb providerHandlerFunc) {
|
|
go func() {
|
|
update := cb(ctx, sector)
|
|
|
|
if update == nil {
|
|
return // async
|
|
}
|
|
|
|
select {
|
|
case m.sectorUpdated <- *update:
|
|
case <-m.stop:
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (m *Miner) handlePacking(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
log.Infow("performing filling up rest of the sector...", "sector", sector.SectorID)
|
|
|
|
var allocated uint64
|
|
for _, piece := range sector.Pieces {
|
|
allocated += piece.Size
|
|
}
|
|
|
|
ubytes := sectorbuilder.UserBytesForSectorSize(m.sb.SectorSize())
|
|
|
|
if allocated > ubytes {
|
|
return sector.upd().fatal(xerrors.Errorf("too much data in sector: %d > %d", allocated, ubytes))
|
|
}
|
|
|
|
fillerSizes, err := fillersFromRem(ubytes - allocated)
|
|
if err != nil {
|
|
return sector.upd().fatal(err)
|
|
}
|
|
|
|
if len(fillerSizes) > 0 {
|
|
log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorID)
|
|
}
|
|
|
|
pieces, err := m.pledgeSector(ctx, sector.SectorID, sector.existingPieces(), fillerSizes...)
|
|
if err != nil {
|
|
return sector.upd().fatal(xerrors.Errorf("filling up the sector (%v): %w", fillerSizes, err))
|
|
}
|
|
|
|
return sector.upd().to(api.Unsealed).state(func(info *SectorInfo) {
|
|
info.Pieces = append(info.Pieces, pieces...)
|
|
})
|
|
}
|
|
|
|
func (m *Miner) handleUnsealed(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
log.Infow("performing sector replication...", "sector", sector.SectorID)
|
|
ticket, err := m.tktFn(ctx)
|
|
if err != nil {
|
|
return sector.upd().fatal(err)
|
|
}
|
|
|
|
rspco, err := m.sb.SealPreCommit(sector.SectorID, *ticket, sector.pieceInfos())
|
|
if err != nil {
|
|
return sector.upd().to(api.SealFailed).error(xerrors.Errorf("seal pre commit failed: %w", err))
|
|
}
|
|
|
|
return sector.upd().to(api.PreCommitting).state(func(info *SectorInfo) {
|
|
info.CommD = rspco.CommD[:]
|
|
info.CommR = rspco.CommR[:]
|
|
info.Ticket = SealTicket{
|
|
BlockHeight: ticket.BlockHeight,
|
|
TicketBytes: ticket.TicketBytes[:],
|
|
}
|
|
})
|
|
}
|
|
|
|
func (m *Miner) handlePreCommitting(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
params := &actors.SectorPreCommitInfo{
|
|
SectorNumber: sector.SectorID,
|
|
|
|
CommR: sector.CommR,
|
|
SealEpoch: sector.Ticket.BlockHeight,
|
|
DealIDs: sector.deals(),
|
|
}
|
|
enc, aerr := actors.SerializeParams(params)
|
|
if aerr != nil {
|
|
return sector.upd().to(api.PreCommitFailed).error(xerrors.Errorf("could not serialize commit sector parameters: %w", aerr))
|
|
}
|
|
|
|
msg := &types.Message{
|
|
To: m.maddr,
|
|
From: m.worker,
|
|
Method: actors.MAMethods.PreCommitSector,
|
|
Params: enc,
|
|
Value: types.NewInt(0), // TODO: need to ensure sufficient collateral
|
|
GasLimit: types.NewInt(1000000 /* i dont know help */),
|
|
GasPrice: types.NewInt(1),
|
|
}
|
|
|
|
log.Info("submitting precommit for sector: ", sector.SectorID)
|
|
smsg, err := m.api.MpoolPushMessage(ctx, msg)
|
|
if err != nil {
|
|
return sector.upd().to(api.PreCommitFailed).error(xerrors.Errorf("pushing message to mpool: %w", err))
|
|
}
|
|
|
|
return sector.upd().to(api.PreCommitted).state(func(info *SectorInfo) {
|
|
mcid := smsg.Cid()
|
|
info.PreCommitMessage = &mcid
|
|
})
|
|
}
|
|
|
|
func (m *Miner) handlePreCommitted(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
// would be ideal to just use the events.Called handler, but it wouldnt be able to handle individual message timeouts
|
|
log.Info("Sector precommitted: ", sector.SectorID)
|
|
mw, err := m.api.StateWaitMsg(ctx, *sector.PreCommitMessage)
|
|
if err != nil {
|
|
return sector.upd().to(api.PreCommitFailed).error(err)
|
|
}
|
|
|
|
if mw.Receipt.ExitCode != 0 {
|
|
log.Error("sector precommit failed: ", mw.Receipt.ExitCode)
|
|
err := xerrors.Errorf("sector precommit failed: %d", mw.Receipt.ExitCode)
|
|
return sector.upd().to(api.PreCommitFailed).error(err)
|
|
}
|
|
log.Info("precommit message landed on chain: ", sector.SectorID)
|
|
|
|
randHeight := mw.TipSet.Height() + build.InteractivePoRepDelay - 1 // -1 because of how the messages are applied
|
|
log.Infof("precommit for sector %d made it on chain, will start proof computation at height %d", sector.SectorID, randHeight)
|
|
|
|
updateNonce := sector.Nonce
|
|
|
|
err = m.events.ChainAt(func(ctx context.Context, ts *types.TipSet, curH uint64) error {
|
|
rand, err := m.api.ChainGetRandomness(ctx, ts.Key(), int64(randHeight))
|
|
if err != nil {
|
|
err = xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)
|
|
|
|
m.sectorUpdated <- *sector.upd().fatal(err)
|
|
return err
|
|
}
|
|
|
|
m.sectorUpdated <- *sector.upd().to(api.Committing).setNonce(updateNonce).state(func(info *SectorInfo) {
|
|
info.Seed = SealSeed{
|
|
BlockHeight: randHeight,
|
|
TicketBytes: rand,
|
|
}
|
|
})
|
|
|
|
updateNonce++
|
|
|
|
return nil
|
|
}, func(ctx context.Context, ts *types.TipSet) error {
|
|
log.Warn("revert in interactive commit sector step")
|
|
// TODO: need to cancel running process and restart...
|
|
return nil
|
|
}, build.InteractivePoRepConfidence, mw.TipSet.Height()+build.InteractivePoRepDelay)
|
|
if err != nil {
|
|
log.Warn("waitForPreCommitMessage ChainAt errored: ", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Miner) handleCommitting(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
log.Info("scheduling seal proof computation...")
|
|
|
|
proof, err := m.sb.SealCommit(sector.SectorID, sector.Ticket.SB(), sector.Seed.SB(), sector.pieceInfos(), sector.rspco())
|
|
if err != nil {
|
|
return sector.upd().to(api.SealCommitFailed).error(xerrors.Errorf("computing seal proof failed: %w", err))
|
|
}
|
|
|
|
// TODO: Consider splitting states and persist proof for faster recovery
|
|
|
|
params := &actors.SectorProveCommitInfo{
|
|
Proof: proof,
|
|
SectorID: sector.SectorID,
|
|
DealIDs: sector.deals(),
|
|
}
|
|
|
|
enc, aerr := actors.SerializeParams(params)
|
|
if aerr != nil {
|
|
return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("could not serialize commit sector parameters: %w", aerr))
|
|
}
|
|
|
|
msg := &types.Message{
|
|
To: m.maddr,
|
|
From: m.worker,
|
|
Method: actors.MAMethods.ProveCommitSector,
|
|
Params: enc,
|
|
Value: types.NewInt(0), // TODO: need to ensure sufficient collateral
|
|
GasLimit: types.NewInt(1000000 /* i dont know help */),
|
|
GasPrice: types.NewInt(1),
|
|
}
|
|
|
|
smsg, err := m.api.MpoolPushMessage(ctx, msg)
|
|
if err != nil {
|
|
return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("pushing message to mpool: %w", err))
|
|
}
|
|
|
|
// TODO: Separate state before this wait, so we persist message cid?
|
|
return sector.upd().to(api.CommitWait).state(func(info *SectorInfo) {
|
|
mcid := smsg.Cid()
|
|
info.CommitMessage = &mcid
|
|
info.Proof = proof
|
|
})
|
|
}
|
|
|
|
func (m *Miner) handleCommitWait(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
if sector.CommitMessage == nil {
|
|
log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorID)
|
|
return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("entered commit wait with no commit cid"))
|
|
}
|
|
|
|
mw, err := m.api.StateWaitMsg(ctx, *sector.CommitMessage)
|
|
if err != nil {
|
|
return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("failed to wait for porep inclusion: %w", err))
|
|
}
|
|
|
|
if mw.Receipt.ExitCode != 0 {
|
|
log.Errorf("UNHANDLED: submitting sector proof failed (exit=%d, msg=%s) (t:%x; s:%x(%d); p:%x)", mw.Receipt.ExitCode, sector.CommitMessage, sector.Ticket.TicketBytes, sector.Seed.TicketBytes, sector.Seed.BlockHeight, sector.Proof)
|
|
return sector.upd().fatal(xerrors.Errorf("UNHANDLED: submitting sector proof failed (exit: %d)", mw.Receipt.ExitCode))
|
|
}
|
|
|
|
return sector.upd().to(api.Proving).state(func(info *SectorInfo) {
|
|
})
|
|
}
|
|
|
|
func (m *Miner) handleFaulty(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
// TODO: check if the fault has already been reported, and that this sector is even valid
|
|
|
|
// TODO: coalesce faulty sector reporting
|
|
bf := types.NewBitField()
|
|
bf.Set(sector.SectorID)
|
|
|
|
fp := &actors.DeclareFaultsParams{bf}
|
|
_ = fp
|
|
enc, aerr := actors.SerializeParams(nil)
|
|
if aerr != nil {
|
|
return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("failed to serialize declare fault params: %w", aerr))
|
|
}
|
|
|
|
msg := &types.Message{
|
|
To: m.maddr,
|
|
From: m.worker,
|
|
Method: actors.MAMethods.DeclareFaults,
|
|
Params: enc,
|
|
Value: types.NewInt(0), // TODO: need to ensure sufficient collateral
|
|
GasLimit: types.NewInt(1000000 /* i dont know help */),
|
|
GasPrice: types.NewInt(1),
|
|
}
|
|
|
|
smsg, err := m.api.MpoolPushMessage(ctx, msg)
|
|
if err != nil {
|
|
return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("failed to push declare faults message to network: %w", err))
|
|
}
|
|
|
|
return sector.upd().to(api.FaultReported).state(func(info *SectorInfo) {
|
|
c := smsg.Cid()
|
|
info.FaultReportMsg = &c
|
|
})
|
|
}
|
|
|
|
func (m *Miner) handleFaultReported(ctx context.Context, sector SectorInfo) *sectorUpdate {
|
|
if sector.FaultReportMsg == nil {
|
|
return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("entered fault reported state without a FaultReportMsg cid"))
|
|
}
|
|
|
|
mw, err := m.api.StateWaitMsg(ctx, *sector.FaultReportMsg)
|
|
if err != nil {
|
|
return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("failed to wait for fault declaration: %w", err))
|
|
}
|
|
|
|
if mw.Receipt.ExitCode != 0 {
|
|
log.Errorf("UNHANDLED: declaring sector fault failed (exit=%d, msg=%s) (id: %d)", mw.Receipt.ExitCode, *sector.FaultReportMsg, sector.SectorID)
|
|
return sector.upd().fatal(xerrors.Errorf("UNHANDLED: submitting fault declaration failed (exit %d)", mw.Receipt.ExitCode))
|
|
}
|
|
|
|
return sector.upd().to(api.FaultedFinal).state(func(info *SectorInfo) {})
|
|
|
|
}
|