From 43f4db2308b4c07fa22e1f06b197db34cb97b57e Mon Sep 17 00:00:00 2001 From: laser Date: Mon, 6 Apr 2020 15:31:33 -0700 Subject: [PATCH] SectorID -> SectorNumber --- cmd/lotus-storage-miner/init.go | 4 ++-- node/impl/storminer.go | 2 +- storage/sealing/cbor_gen.go | 18 +++++++-------- storage/sealing/checks.go | 12 +++++----- storage/sealing/fsm.go | 12 +++++----- storage/sealing/fsm_events.go | 4 ++-- storage/sealing/states.go | 38 ++++++++++++++++---------------- storage/sealing/states_failed.go | 12 +++++----- storage/sealing/types.go | 6 ++--- storage/sealing/types_test.go | 8 +++---- 10 files changed, 58 insertions(+), 58 deletions(-) diff --git a/cmd/lotus-storage-miner/init.go b/cmd/lotus-storage-miner/init.go index 52df47ff0..5064089f3 100644 --- a/cmd/lotus-storage-miner/init.go +++ b/cmd/lotus-storage-miner/init.go @@ -286,8 +286,8 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string, commR := sector.CommR info := &sealing.SectorInfo{ - State: sealing.Proving, - SectorID: sector.SectorID, + State: sealing.Proving, + SectorNumber: sector.SectorID, Pieces: []sealing.Piece{ { DealID: &dealID, diff --git a/node/impl/storminer.go b/node/impl/storminer.go index d60b8e6d5..ff85df472 100644 --- a/node/impl/storminer.go +++ b/node/impl/storminer.go @@ -122,7 +122,7 @@ func (sm *StorageMinerAPI) SectorsList(context.Context) ([]abi.SectorNumber, err out := make([]abi.SectorNumber, len(sectors)) for i, sector := range sectors { - out[i] = sector.SectorID + out[i] = sector.SectorNumber } return out, nil } diff --git a/storage/sealing/cbor_gen.go b/storage/sealing/cbor_gen.go index 96d3bb483..08ba98546 100644 --- a/storage/sealing/cbor_gen.go +++ b/storage/sealing/cbor_gen.go @@ -204,19 +204,19 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return err } - // t.SectorID (abi.SectorNumber) (uint64) - if len("SectorID") > cbg.MaxLength { - return xerrors.Errorf("Value in field \"SectorID\" was too long") + // t.SectorNumber (abi.SectorNumber) (uint64) + if len("SectorNumber") > cbg.MaxLength { + return xerrors.Errorf("Value in field \"SectorNumber\" was too long") } - if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SectorID")))); err != nil { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SectorNumber")))); err != nil { return err } - if _, err := w.Write([]byte("SectorID")); err != nil { + if _, err := w.Write([]byte("SectorNumber")); err != nil { return err } - if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { return err } @@ -636,8 +636,8 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.State = SectorState(sval) } - // t.SectorID (abi.SectorNumber) (uint64) - case "SectorID": + // t.SectorNumber (abi.SectorNumber) (uint64) + case "SectorNumber": { @@ -648,7 +648,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { if maj != cbg.MajUnsignedInt { return fmt.Errorf("wrong type for uint64 field") } - t.SectorID = abi.SectorNumber(extra) + t.SectorNumber = abi.SectorNumber(extra) } // t.Nonce (uint64) (uint64) diff --git a/storage/sealing/checks.go b/storage/sealing/checks.go index 1538cc8d5..3c18f9f34 100644 --- a/storage/sealing/checks.go +++ b/storage/sealing/checks.go @@ -52,15 +52,15 @@ func checkPieces(ctx context.Context, si SectorInfo, api SealingAPI) error { } if proposal.PieceCID != piece.CommP { - return &ErrInvalidDeals{xerrors.Errorf("piece %d (or %d) of sector %d refers deal %d with wrong CommP: %x != %x", i, len(si.Pieces), si.SectorID, piece.DealID, piece.CommP, proposal.PieceCID)} + return &ErrInvalidDeals{xerrors.Errorf("piece %d (or %d) of sector %d refers deal %d with wrong CommP: %x != %x", i, len(si.Pieces), si.SectorNumber, piece.DealID, piece.CommP, proposal.PieceCID)} } if piece.Size != proposal.PieceSize.Unpadded() { - return &ErrInvalidDeals{xerrors.Errorf("piece %d (or %d) of sector %d refers deal %d with different size: %d != %d", i, len(si.Pieces), si.SectorID, piece.DealID, piece.Size, proposal.PieceSize)} + return &ErrInvalidDeals{xerrors.Errorf("piece %d (or %d) of sector %d refers deal %d with different size: %d != %d", i, len(si.Pieces), si.SectorNumber, piece.DealID, piece.Size, proposal.PieceSize)} } if height >= proposal.StartEpoch { - return &ErrExpiredDeals{xerrors.Errorf("piece %d (or %d) of sector %d refers expired deal %d - should start at %d, head %d", i, len(si.Pieces), si.SectorID, piece.DealID, proposal.StartEpoch, height)} + return &ErrExpiredDeals{xerrors.Errorf("piece %d (or %d) of sector %d refers expired deal %d - should start at %d, head %d", i, len(si.Pieces), si.SectorNumber, piece.DealID, proposal.StartEpoch, height)} } } @@ -101,7 +101,7 @@ func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte) return &ErrBadSeed{xerrors.Errorf("seed epoch was not set")} } - pci, err := m.api.StateSectorPreCommitInfo(ctx, m.maddr, si.SectorID, tok) + pci, err := m.api.StateSectorPreCommitInfo(ctx, m.maddr, si.SectorNumber, tok) if err != nil { return xerrors.Errorf("getting precommit info: %w", err) } @@ -133,13 +133,13 @@ func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte) } ok, err := m.verif.VerifySeal(abi.SealVerifyInfo{ - SectorID: m.minerSector(si.SectorID), + SectorID: m.minerSector(si.SectorNumber), OnChain: abi.OnChainSealVerifyInfo{ SealedCID: pci.Info.SealedCID, InteractiveEpoch: si.SeedEpoch, RegisteredProof: spt, Proof: proof, - SectorNumber: si.SectorID, + SectorNumber: si.SectorNumber, SealRandEpoch: si.TicketEpoch, }, Randomness: si.TicketValue, diff --git a/storage/sealing/fsm.go b/storage/sealing/fsm.go index e03ab7bd8..91fbaf172 100644 --- a/storage/sealing/fsm.go +++ b/storage/sealing/fsm.go @@ -23,7 +23,7 @@ func (m *Sealing) Plan(events []statemachine.Event, user interface{}) (interface return func(ctx statemachine.Context, si SectorInfo) error { err := next(ctx, si) if err != nil { - log.Errorf("unhandled sector error (%d): %+v", si.SectorID, err) + log.Errorf("unhandled sector error (%d): %+v", si.SectorNumber, err) return nil } @@ -187,7 +187,7 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta return m.handleFinalizeSector, nil case Proving: // TODO: track sector health / expiration - log.Infof("Proving sector %d", state.SectorID) + log.Infof("Proving sector %d", state.SectorNumber) // Handled failure modes case SealFailed: @@ -209,7 +209,7 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta case UndefinedSectorState: log.Error("sector update with undefined state!") case FailedUnrecoverable: - log.Errorf("sector %d failed unrecoverably", state.SectorID) + log.Errorf("sector %d failed unrecoverably", state.SectorNumber) default: log.Errorf("unexpected sector update state: %d", state.State) } @@ -256,8 +256,8 @@ func (m *Sealing) restartSectors(ctx context.Context) error { } for _, sector := range trackedSectors { - if err := m.sectors.Send(uint64(sector.SectorID), SectorRestart{}); err != nil { - log.Errorf("restarting sector %d: %+v", sector.SectorID, err) + if err := m.sectors.Send(uint64(sector.SectorNumber), SectorRestart{}); err != nil { + log.Errorf("restarting sector %d: %+v", sector.SectorNumber, err) } } @@ -305,7 +305,7 @@ func planOne(ts ...func() (mut mutator, next SectorState)) func(events []statema } if err, iserr := events[0].User.(error); iserr { - log.Warnf("sector %d got error event %T: %+v", state.SectorID, events[0].User, err) + log.Warnf("sector %d got error event %T: %+v", state.SectorNumber, events[0].User, err) } events[0].User.(mutator).apply(state) diff --git a/storage/sealing/fsm_events.go b/storage/sealing/fsm_events.go index 2dee984d5..7316d16a1 100644 --- a/storage/sealing/fsm_events.go +++ b/storage/sealing/fsm_events.go @@ -29,7 +29,7 @@ type SectorFatalError struct{ error } func (evt SectorFatalError) FormatError(xerrors.Printer) (next error) { return evt.error } func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool { - log.Errorf("Fatal error on sector %d: %+v", state.SectorID, evt.error) + 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 @@ -54,7 +54,7 @@ type SectorStart struct { } func (evt SectorStart) apply(state *SectorInfo) { - state.SectorID = evt.ID + state.SectorNumber = evt.ID state.Pieces = evt.Pieces state.SectorType = evt.SectorType } diff --git a/storage/sealing/states.go b/storage/sealing/states.go index a2c56e072..39d277e2a 100644 --- a/storage/sealing/states.go +++ b/storage/sealing/states.go @@ -16,7 +16,7 @@ import ( ) func (m *Sealing) handlePacking(ctx statemachine.Context, sector SectorInfo) error { - log.Infow("performing filling up rest of the sector...", "sector", sector.SectorID) + log.Infow("performing filling up rest of the sector...", "sector", sector.SectorNumber) var allocated abi.UnpaddedPieceSize for _, piece := range sector.Pieces { @@ -35,10 +35,10 @@ func (m *Sealing) handlePacking(ctx statemachine.Context, sector SectorInfo) err } if len(fillerSizes) > 0 { - log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorID) + log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorNumber) } - pieces, err := m.pledgeSector(ctx.Context(), m.minerSector(sector.SectorID), sector.existingPieces(), fillerSizes...) + pieces, err := m.pledgeSector(ctx.Context(), m.minerSector(sector.SectorNumber), sector.existingPieces(), fillerSizes...) if err != nil { return xerrors.Errorf("filling up the sector (%v): %w", fillerSizes, err) } @@ -61,13 +61,13 @@ func (m *Sealing) handlePreCommit1(ctx statemachine.Context, sector SectorInfo) } } - log.Infow("performing sector replication...", "sector", sector.SectorID) + log.Infow("performing sector replication...", "sector", sector.SectorNumber) ticketValue, ticketEpoch, err := m.tktFn(ctx.Context()) if err != nil { return ctx.Send(SectorSealPreCommitFailed{xerrors.Errorf("getting ticket failed: %w", err)}) } - pc1o, err := m.sealer.SealPreCommit1(ctx.Context(), m.minerSector(sector.SectorID), ticketValue, sector.pieceInfos()) + pc1o, err := m.sealer.SealPreCommit1(ctx.Context(), m.minerSector(sector.SectorNumber), ticketValue, sector.pieceInfos()) if err != nil { return ctx.Send(SectorSealPreCommitFailed{xerrors.Errorf("seal pre commit(1) failed: %w", err)}) } @@ -80,7 +80,7 @@ func (m *Sealing) handlePreCommit1(ctx statemachine.Context, sector SectorInfo) } func (m *Sealing) handlePreCommit2(ctx statemachine.Context, sector SectorInfo) error { - cids, err := m.sealer.SealPreCommit2(ctx.Context(), m.minerSector(sector.SectorID), sector.PreCommit1Out) + cids, err := m.sealer.SealPreCommit2(ctx.Context(), m.minerSector(sector.SectorNumber), sector.PreCommit1Out) if err != nil { return ctx.Send(SectorSealPreCommitFailed{xerrors.Errorf("seal pre commit(2) failed: %w", err)}) } @@ -108,7 +108,7 @@ func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInf params := &miner.SectorPreCommitInfo{ Expiration: 10000000, // TODO: implement - SectorNumber: sector.SectorID, + SectorNumber: sector.SectorNumber, RegisteredProof: sector.SectorType, SealedCID: *sector.CommR, @@ -121,7 +121,7 @@ func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInf return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("could not serialize pre-commit sector parameters: %w", err)}) } - log.Info("submitting precommit for sector: ", sector.SectorID) + log.Info("submitting precommit for sector: ", sector.SectorNumber) mcid, err := m.api.SendMsg(ctx.Context(), m.worker, m.maddr, builtin.MethodsMiner.PreCommitSector, big.NewInt(0), big.NewInt(1), 1000000, enc.Bytes()) if err != nil { return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("pushing message to mpool: %w", err)}) @@ -132,7 +132,7 @@ func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInf func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) error { // 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) + log.Info("Sector precommitted: ", sector.SectorNumber) mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.PreCommitMessage) if err != nil { return ctx.Send(SectorChainPreCommitFailed{err}) @@ -143,9 +143,9 @@ func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) er err := xerrors.Errorf("sector precommit failed: %d", mw.Receipt.ExitCode) return ctx.Send(SectorChainPreCommitFailed{err}) } - log.Info("precommit message landed on chain: ", sector.SectorID) + log.Info("precommit message landed on chain: ", sector.SectorNumber) - pci, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorID, mw.TipSetTok) + pci, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorNumber, mw.TipSetTok) if err != nil { return xerrors.Errorf("getting precommit info: %w", err) } @@ -179,18 +179,18 @@ func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) er func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo) error { log.Info("scheduling seal proof computation...") - log.Infof("KOMIT %d %x(%d); %x(%d); %v; r:%x; d:%x", sector.SectorID, sector.TicketValue, sector.TicketEpoch, sector.SeedValue, sector.SeedEpoch, sector.pieceInfos(), sector.CommR, sector.CommD) + log.Infof("KOMIT %d %x(%d); %x(%d); %v; r:%x; d:%x", sector.SectorNumber, sector.TicketValue, sector.TicketEpoch, sector.SeedValue, sector.SeedEpoch, sector.pieceInfos(), sector.CommR, sector.CommD) cids := storage.SectorCids{ Unsealed: *sector.CommD, Sealed: *sector.CommR, } - c2in, err := m.sealer.SealCommit1(ctx.Context(), m.minerSector(sector.SectorID), sector.TicketValue, sector.SeedValue, sector.pieceInfos(), cids) + c2in, err := m.sealer.SealCommit1(ctx.Context(), m.minerSector(sector.SectorNumber), sector.TicketValue, sector.SeedValue, sector.pieceInfos(), cids) if err != nil { return ctx.Send(SectorComputeProofFailed{xerrors.Errorf("computing seal proof failed: %w", err)}) } - proof, err := m.sealer.SealCommit2(ctx.Context(), m.minerSector(sector.SectorID), c2in) + proof, err := m.sealer.SealCommit2(ctx.Context(), m.minerSector(sector.SectorNumber), c2in) if err != nil { return ctx.Send(SectorComputeProofFailed{xerrors.Errorf("computing seal proof failed: %w", err)}) } @@ -202,7 +202,7 @@ func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo) // TODO: Consider splitting states and persist proof for faster recovery params := &miner.ProveCommitSectorParams{ - SectorNumber: sector.SectorID, + SectorNumber: sector.SectorNumber, Proof: proof, } @@ -225,7 +225,7 @@ func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo) func (m *Sealing) handleCommitWait(ctx statemachine.Context, sector SectorInfo) error { if sector.CommitMessage == nil { - log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorID) + log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorNumber) return ctx.Send(SectorCommitFailed{xerrors.Errorf("entered commit wait with no commit cid")}) } @@ -244,7 +244,7 @@ func (m *Sealing) handleCommitWait(ctx statemachine.Context, sector SectorInfo) func (m *Sealing) handleFinalizeSector(ctx statemachine.Context, sector SectorInfo) error { // TODO: Maybe wait for some finality - if err := m.sealer.FinalizeSector(ctx.Context(), m.minerSector(sector.SectorID)); err != nil { + if err := m.sealer.FinalizeSector(ctx.Context(), m.minerSector(sector.SectorNumber)); err != nil { return ctx.Send(SectorFinalizeFailed{xerrors.Errorf("finalize sector: %w", err)}) } @@ -256,7 +256,7 @@ func (m *Sealing) handleFaulty(ctx statemachine.Context, sector SectorInfo) erro // TODO: coalesce faulty sector reporting bf := abi.NewBitField() - bf.Set(uint64(sector.SectorID)) + bf.Set(uint64(sector.SectorNumber)) params := &miner.DeclareTemporaryFaultsParams{ SectorNumbers: bf, @@ -287,7 +287,7 @@ func (m *Sealing) handleFaultReported(ctx statemachine.Context, sector SectorInf } 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) + log.Errorf("UNHANDLED: declaring sector fault failed (exit=%d, msg=%s) (id: %d)", mw.Receipt.ExitCode, *sector.FaultReportMsg, sector.SectorNumber) return xerrors.Errorf("UNHANDLED: submitting fault declaration failed (exit %d)", mw.Receipt.ExitCode) } diff --git a/storage/sealing/states_failed.go b/storage/sealing/states_failed.go index ac4306f95..700a04af2 100644 --- a/storage/sealing/states_failed.go +++ b/storage/sealing/states_failed.go @@ -16,7 +16,7 @@ func failedCooldown(ctx statemachine.Context, sector SectorInfo) error { retryStart := time.Unix(int64(sector.Log[len(sector.Log)-1].Timestamp), 0).Add(minRetryTime) if len(sector.Log) > 0 && !time.Now().After(retryStart) { - log.Infof("%s(%d), waiting %s before retrying", sector.State, sector.SectorID, time.Until(retryStart)) + log.Infof("%s(%d), waiting %s before retrying", sector.State, sector.SectorNumber, time.Until(retryStart)) select { case <-time.After(time.Until(retryStart)): case <-ctx.Context().Done(): @@ -30,13 +30,13 @@ func failedCooldown(ctx statemachine.Context, sector SectorInfo) error { func (m *Sealing) checkPreCommitted(ctx statemachine.Context, sector SectorInfo) (*miner.SectorPreCommitOnChainInfo, bool) { tok, _, err := m.api.ChainHead(ctx.Context()) if err != nil { - log.Errorf("handleSealFailed(%d): temp error: %+v", sector.SectorID, err) + log.Errorf("handleSealFailed(%d): temp error: %+v", sector.SectorNumber, err) return nil, true } - info, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorID, tok) + info, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorNumber, tok) if err != nil { - log.Errorf("handleSealFailed(%d): temp error: %+v", sector.SectorID, err) + log.Errorf("handleSealFailed(%d): temp error: %+v", sector.SectorNumber, err) return nil, true } @@ -73,12 +73,12 @@ func (m *Sealing) handlePreCommitFailed(ctx statemachine.Context, sector SectorI if pci, is := m.checkPreCommitted(ctx, sector); is && pci != nil { if sector.PreCommitMessage != nil { - log.Warn("sector %d is precommitted on chain, but we don't have precommit message", sector.SectorID) + log.Warn("sector %d is precommitted on chain, but we don't have precommit message", sector.SectorNumber) return nil // TODO: SeedWait needs this currently } if pci.Info.SealedCID != *sector.CommR { - log.Warn("sector %d is precommitted on chain, with different CommR: %x != %x", sector.SectorID, pci.Info.SealedCID, sector.CommR) + log.Warn("sector %d is precommitted on chain, with different CommR: %x != %x", sector.SectorNumber, pci.Info.SealedCID, sector.CommR) return nil // TODO: remove when the actor allows re-precommit } diff --git a/storage/sealing/types.go b/storage/sealing/types.go index d452cb507..3094a3e85 100644 --- a/storage/sealing/types.go +++ b/storage/sealing/types.go @@ -29,9 +29,9 @@ type Log struct { } type SectorInfo struct { - State SectorState - SectorID abi.SectorNumber // TODO: this field's name should be changed to SectorNumber - Nonce uint64 // TODO: remove + State SectorState + SectorNumber abi.SectorNumber // TODO: this field's name should be changed to SectorNumber + Nonce uint64 // TODO: remove SectorType abi.RegisteredProof diff --git a/storage/sealing/types_test.go b/storage/sealing/types_test.go index 7270c49a7..7dc8ddcca 100644 --- a/storage/sealing/types_test.go +++ b/storage/sealing/types_test.go @@ -17,9 +17,9 @@ func TestSectorInfoSelialization(t *testing.T) { dummyCid := builtin.AccountActorCodeID si := &SectorInfo{ - State: "stateful", - SectorID: 234, - Nonce: 345, + State: "stateful", + SectorNumber: 234, + Nonce: 345, Pieces: []Piece{{ DealID: &d, Size: 5, @@ -50,7 +50,7 @@ func TestSectorInfoSelialization(t *testing.T) { assert.Equal(t, si.State, si2.State) assert.Equal(t, si.Nonce, si2.Nonce) - assert.Equal(t, si.SectorID, si2.SectorID) + assert.Equal(t, si.SectorNumber, si2.SectorNumber) assert.Equal(t, si.Pieces, si2.Pieces) assert.Equal(t, si.CommD, si2.CommD)