lotus/storage/sbmock/sbmock.go

370 lines
9.5 KiB
Go
Raw Normal View History

package sbmock
import (
"bytes"
2020-01-09 18:28:14 +00:00
"context"
2020-01-09 19:23:42 +00:00
"fmt"
"io"
"io/ioutil"
2020-01-13 20:47:27 +00:00
"math/big"
"math/rand"
"sync"
2020-01-13 20:47:27 +00:00
ffi "github.com/filecoin-project/filecoin-ffi"
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-sectorbuilder"
2020-01-31 01:18:48 +00:00
"github.com/filecoin-project/go-sectorbuilder/fs"
"github.com/filecoin-project/specs-actors/actors/abi"
"golang.org/x/xerrors"
)
type SBMock struct {
sectors map[abi.SectorNumber]*sectorState
sectorSize abi.SectorSize
nextSectorID abi.SectorNumber
rateLimit chan struct{}
lk sync.Mutex
}
2020-01-14 02:04:33 +00:00
type mockVerif struct{}
2020-01-13 20:47:27 +00:00
func NewMockSectorBuilder(threads int, ssize abi.SectorSize) *SBMock {
return &SBMock{
sectors: make(map[abi.SectorNumber]*sectorState),
sectorSize: ssize,
2020-01-13 20:47:27 +00:00
nextSectorID: 5,
rateLimit: make(chan struct{}, threads),
}
}
2020-01-09 19:23:42 +00:00
const (
statePacking = iota
statePreCommit
stateCommit
)
type sectorState struct {
pieces [][]byte
2020-01-09 19:23:42 +00:00
failed bool
state int
lk sync.Mutex
}
func (sb *SBMock) RateLimit() func() {
sb.rateLimit <- struct{}{}
// TODO: probably want to copy over rate limit code
return func() {
<-sb.rateLimit
}
}
func (sb *SBMock) AddPiece(ctx context.Context, size abi.UnpaddedPieceSize, sectorId abi.SectorNumber, r io.Reader, existingPieces []abi.UnpaddedPieceSize) (sectorbuilder.PublicPieceInfo, error) {
sb.lk.Lock()
ss, ok := sb.sectors[sectorId]
if !ok {
2020-01-09 19:23:42 +00:00
ss = &sectorState{
state: statePacking,
}
sb.sectors[sectorId] = ss
}
2020-01-09 19:23:42 +00:00
sb.lk.Unlock()
ss.lk.Lock()
defer ss.lk.Unlock()
b, err := ioutil.ReadAll(r)
if err != nil {
return sectorbuilder.PublicPieceInfo{}, err
}
ss.pieces = append(ss.pieces, b)
return sectorbuilder.PublicPieceInfo{
2020-02-11 01:23:03 +00:00
Size: size,
2020-01-13 20:47:27 +00:00
CommP: commD(b),
}, nil
}
func (sb *SBMock) SectorSize() abi.SectorSize {
return sb.sectorSize
}
2020-02-11 01:23:03 +00:00
func (sb *SBMock) AcquireSectorNumber() (abi.SectorNumber, error) {
sb.lk.Lock()
2020-01-09 19:23:42 +00:00
defer sb.lk.Unlock()
id := sb.nextSectorID
sb.nextSectorID++
return id, nil
}
func (sb *SBMock) Scrub(sectorbuilder.SortedPublicSectorInfo) []*sectorbuilder.Fault {
sb.lk.Lock()
mcopy := make(map[abi.SectorNumber]*sectorState)
for k, v := range sb.sectors {
mcopy[k] = v
}
sb.lk.Unlock()
var out []*sectorbuilder.Fault
for sid, ss := range mcopy {
ss.lk.Lock()
if ss.failed {
out = append(out, &sectorbuilder.Fault{
2020-02-11 01:23:03 +00:00
SectorNum: sid,
Err: fmt.Errorf("mock sector failed"),
})
}
ss.lk.Unlock()
}
return out
}
func (sb *SBMock) GenerateFallbackPoSt(sectorbuilder.SortedPublicSectorInfo, [sectorbuilder.CommLen]byte, []abi.SectorNumber) ([]sectorbuilder.EPostCandidate, []byte, error) {
panic("NYI")
}
func (sb *SBMock) SealPreCommit(ctx context.Context, sid abi.SectorNumber, ticket sectorbuilder.SealTicket, pieces []sectorbuilder.PublicPieceInfo) (sectorbuilder.RawSealPreCommitOutput, error) {
2020-01-09 19:23:42 +00:00
sb.lk.Lock()
ss, ok := sb.sectors[sid]
sb.lk.Unlock()
if !ok {
return sectorbuilder.RawSealPreCommitOutput{}, xerrors.Errorf("no sector with id %d in sectorbuilder", sid)
}
2020-01-09 19:23:42 +00:00
ss.lk.Lock()
defer ss.lk.Unlock()
2020-02-21 19:28:01 +00:00
ussize := abi.PaddedPieceSize(sb.sectorSize).Unpadded()
// TODO: verify pieces in sinfo.pieces match passed in pieces
var sum abi.UnpaddedPieceSize
for _, p := range pieces {
2020-02-21 19:28:01 +00:00
sum += p.Size
}
if sum != ussize {
return sectorbuilder.RawSealPreCommitOutput{}, xerrors.Errorf("aggregated piece sizes don't match up: %d != %d", sum, ussize)
}
2020-01-09 19:23:42 +00:00
if ss.state != statePacking {
return sectorbuilder.RawSealPreCommitOutput{}, xerrors.Errorf("cannot call pre-seal on sector not in 'packing' state")
}
opFinishWait(ctx)
2020-01-09 19:23:42 +00:00
ss.state = statePreCommit
2020-01-13 20:47:27 +00:00
pis := make([]ffi.PublicPieceInfo, len(ss.pieces))
for i, piece := range ss.pieces {
pis[i] = ffi.PublicPieceInfo{
2020-02-11 01:23:03 +00:00
Size: abi.UnpaddedPieceSize(len(piece)),
2020-01-13 20:47:27 +00:00
CommP: commD(piece),
}
}
commd, err := MockVerifier.GenerateDataCommitment(abi.PaddedPieceSize(sb.sectorSize), pis)
2020-01-13 20:47:27 +00:00
if err != nil {
return sectorbuilder.RawSealPreCommitOutput{}, err
}
return sectorbuilder.RawSealPreCommitOutput{
2020-01-13 20:47:27 +00:00
CommD: commd,
CommR: commDR(commd[:]),
}, nil
}
func (sb *SBMock) SealCommit(ctx context.Context, sid abi.SectorNumber, ticket sectorbuilder.SealTicket, seed sectorbuilder.SealSeed, pieces []sectorbuilder.PublicPieceInfo, precommit sectorbuilder.RawSealPreCommitOutput) ([]byte, error) {
2020-01-09 19:23:42 +00:00
sb.lk.Lock()
ss, ok := sb.sectors[sid]
sb.lk.Unlock()
if !ok {
return nil, xerrors.Errorf("no such sector %d", sid)
}
ss.lk.Lock()
defer ss.lk.Unlock()
if ss.failed {
return nil, xerrors.Errorf("[mock] cannot commit failed sector %d", sid)
}
if ss.state != statePreCommit {
return nil, xerrors.Errorf("cannot commit sector that has not been precommitted")
}
opFinishWait(ctx)
2020-01-09 19:23:42 +00:00
2020-01-13 20:47:27 +00:00
var out [32]byte
for i := range out {
2020-01-14 02:04:33 +00:00
out[i] = precommit.CommD[i] + precommit.CommR[31-i] - ticket.TicketBytes[i]*seed.TicketBytes[i]
2020-01-13 20:47:27 +00:00
}
return out[:], nil
}
2020-01-09 18:28:14 +00:00
func (sb *SBMock) GetPath(string, string) (string, error) {
panic("nyi")
}
func (sb *SBMock) CanCommit(sectorID abi.SectorNumber) (bool, error) {
2020-01-23 14:33:28 +00:00
return true, nil
}
2020-01-09 18:28:14 +00:00
func (sb *SBMock) WorkerStats() sectorbuilder.WorkerStats {
panic("nyi")
}
func (sb *SBMock) AddWorker(context.Context, sectorbuilder.WorkerCfg) (<-chan sectorbuilder.WorkerTask, error) {
panic("nyi")
}
func (sb *SBMock) TaskDone(context.Context, uint64, sectorbuilder.SealRes) error {
panic("nyi")
}
2020-01-09 19:23:42 +00:00
// Test Instrumentation Methods
func (sb *SBMock) FailSector(sid abi.SectorNumber) error {
2020-01-09 19:23:42 +00:00
sb.lk.Lock()
defer sb.lk.Unlock()
ss, ok := sb.sectors[sid]
if !ok {
return fmt.Errorf("no such sector in sectorbuilder")
}
ss.failed = true
return nil
}
func opFinishWait(ctx context.Context) {
val, ok := ctx.Value("opfinish").(chan struct{})
if !ok {
return
}
<-val
2020-01-09 19:23:42 +00:00
}
func AddOpFinish(ctx context.Context) (context.Context, func()) {
done := make(chan struct{})
return context.WithValue(ctx, "opfinish", done), func() {
close(done)
}
}
2020-01-13 20:47:27 +00:00
func (sb *SBMock) ComputeElectionPoSt(sectorInfo sectorbuilder.SortedPublicSectorInfo, challengeSeed []byte, winners []sectorbuilder.EPostCandidate) ([]byte, error) {
panic("implement me")
}
func (sb *SBMock) GenerateEPostCandidates(sectorInfo sectorbuilder.SortedPublicSectorInfo, challengeSeed [sectorbuilder.CommLen]byte, faults []abi.SectorNumber) ([]sectorbuilder.EPostCandidate, error) {
2020-01-13 20:47:27 +00:00
if len(faults) > 0 {
panic("todo")
}
n := sectorbuilder.ElectionPostChallengeCount(uint64(len(sectorInfo.Values())), uint64(len(faults)))
if n > uint64(len(sectorInfo.Values())) {
n = uint64(len(sectorInfo.Values()))
}
2020-01-14 01:24:04 +00:00
out := make([]sectorbuilder.EPostCandidate, n)
2020-01-13 20:47:27 +00:00
seed := big.NewInt(0).SetBytes(challengeSeed[:])
start := seed.Mod(seed, big.NewInt(int64(len(sectorInfo.Values())))).Int64()
2020-01-14 01:24:04 +00:00
for i := range out {
2020-01-13 20:47:27 +00:00
out[i] = sectorbuilder.EPostCandidate{
2020-02-11 01:23:03 +00:00
SectorNum: abi.SectorNumber((int(start) + i) % len(sectorInfo.Values())),
2020-01-13 20:47:27 +00:00
PartialTicket: challengeSeed,
Ticket: commDR(challengeSeed[:]),
SectorChallengeIndex: 0,
}
}
return out, nil
}
2020-02-11 01:23:03 +00:00
func (sb *SBMock) ReadPieceFromSealedSector(ctx context.Context, sectorID abi.SectorNumber, offset sectorbuilder.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket []byte, commD []byte) (io.ReadCloser, error) {
2020-01-14 01:24:04 +00:00
if len(sb.sectors[sectorID].pieces) > 1 {
panic("implme")
}
return ioutil.NopCloser(io.LimitReader(bytes.NewReader(sb.sectors[sectorID].pieces[0][offset:]), int64(size))), nil
2020-01-13 20:47:27 +00:00
}
func (sb *SBMock) StageFakeData() (abi.SectorNumber, []sectorbuilder.PublicPieceInfo, error) {
2020-02-21 19:28:01 +00:00
usize := abi.PaddedPieceSize(sb.sectorSize).Unpadded()
2020-02-11 01:23:03 +00:00
sid, err := sb.AcquireSectorNumber()
if err != nil {
return 0, nil, err
}
buf := make([]byte, usize)
rand.Read(buf)
2020-01-31 01:18:48 +00:00
pi, err := sb.AddPiece(context.TODO(), usize, sid, bytes.NewReader(buf), nil)
if err != nil {
return 0, nil, err
}
return sid, []sectorbuilder.PublicPieceInfo{pi}, nil
2020-01-09 19:23:42 +00:00
}
2020-01-13 20:47:27 +00:00
func (sb *SBMock) FinalizeSector(context.Context, abi.SectorNumber) error {
2020-01-31 01:27:38 +00:00
return nil
2020-01-31 01:18:48 +00:00
}
func (sb *SBMock) DropStaged(context.Context, abi.SectorNumber) error {
2020-01-31 01:27:38 +00:00
return nil
2020-01-31 01:18:48 +00:00
}
func (sb *SBMock) SectorPath(typ fs.DataType, sectorID abi.SectorNumber) (fs.SectorPath, error) {
2020-01-31 01:18:48 +00:00
panic("implement me")
}
func (sb *SBMock) AllocSectorPath(typ fs.DataType, sectorID abi.SectorNumber, cache bool) (fs.SectorPath, error) {
2020-01-31 01:18:48 +00:00
panic("implement me")
}
func (sb *SBMock) ReleaseSector(fs.DataType, fs.SectorPath) {
panic("implement me")
}
func (m mockVerif) VerifyElectionPost(ctx context.Context, sectorSize abi.SectorSize, sectorInfo sectorbuilder.SortedPublicSectorInfo, challengeSeed []byte, proof []byte, candidates []sectorbuilder.EPostCandidate, proverID address.Address) (bool, error) {
2020-01-13 20:47:27 +00:00
panic("implement me")
}
func (m mockVerif) VerifyFallbackPost(ctx context.Context, sectorSize abi.SectorSize, sectorInfo sectorbuilder.SortedPublicSectorInfo, challengeSeed []byte, proof []byte, candidates []sectorbuilder.EPostCandidate, proverID address.Address, faults uint64) (bool, error) {
2020-01-13 20:47:27 +00:00
panic("implement me")
}
func (m mockVerif) VerifySeal(sectorSize abi.SectorSize, commR, commD []byte, proverID address.Address, ticket []byte, seed []byte, sectorID abi.SectorNumber, proof []byte) (bool, error) {
2020-01-13 20:47:27 +00:00
if len(proof) != 32 { // Real ones are longer, but this should be fine
return false, nil
}
for i, b := range proof {
2020-01-14 02:04:33 +00:00
if b != commD[i]+commR[31-i]-ticket[i]*seed[i] {
2020-01-13 20:47:27 +00:00
return false, nil
}
}
return true, nil
}
func (m mockVerif) GenerateDataCommitment(ssize abi.PaddedPieceSize, pieces []ffi.PublicPieceInfo) ([sectorbuilder.CommLen]byte, error) {
2020-01-13 20:47:27 +00:00
if len(pieces) != 1 {
panic("todo")
}
2020-02-21 19:28:01 +00:00
if pieces[0].Size != ssize.Unpadded() {
2020-01-13 20:47:27 +00:00
panic("todo")
}
return pieces[0].CommP, nil
}
var MockVerifier = mockVerif{}
var _ sectorbuilder.Verifier = MockVerifier
var _ sectorbuilder.Interface = &SBMock{}