Wire up faults in fPoSt

lib/jsonrpc/websocket.go

@@ -423,7 +423,7 @@ func (c *wsConn) handleWsConn(ctx context.Context) {
 			if !ok {
 				if c.incomingErr != nil {
 					if !websocket.IsCloseError(c.incomingErr, websocket.CloseNormalClosure) {
-						log.Warnw("websocket error", "error", c.incomingErr)
+						log.Debugw("websocket error", "error", c.incomingErr)
 					}
 				}
 				return // remote closed

lib/sectorbuilder/scrub.go

@@ -0,0 +1,84 @@
+package sectorbuilder
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	sectorbuilder "github.com/filecoin-project/filecoin-ffi"
+	"golang.org/x/xerrors"
+)
+
+type Fault struct {
+	SectorID uint64
+
+	Err error
+}
+
+func (sb *SectorBuilder) Scrub(sectorSet sectorbuilder.SortedPublicSectorInfo) []*Fault {
+	var faults []*Fault
+
+	for _, sector := range sectorSet.Values() {
+		err := sb.checkSector(sector.SectorID)
+		if err != nil {
+			faults = append(faults, &Fault{SectorID: sector.SectorID, Err: err})
+		}
+	}
+
+	return faults
+}
+
+func (sb *SectorBuilder) checkSector(sectorID uint64) error {
+	cache, err := sb.sectorCacheDir(sectorID)
+	if err != nil {
+		return xerrors.Errorf("getting sector cache dir: %w", err)
+	}
+
+	if err := assertFile(filepath.Join(cache, "p_aux"), 96, 96); err != nil {
+		return err
+	}
+	if err := assertFile(filepath.Join(cache, "sc-01-data-tree-r-last.dat"), (2*sb.ssize)-32, (2*sb.ssize)-32); err != nil {
+		return err
+	}
+
+	// TODO: better validate this
+	if err := assertFile(filepath.Join(cache, "t_aux"), 100, 32000); err != nil { // TODO: what should this actually be?
+		return err
+	}
+
+	dent, err := ioutil.ReadDir(cache)
+	if err != nil {
+		return xerrors.Errorf("reading cache dir %s", cache)
+	}
+	if len(dent) != 3 {
+		return xerrors.Errorf("found %d files in %s, expected 3", len(dent), cache)
+	}
+
+	sealed, err := sb.SealedSectorPath(sectorID)
+	if err != nil {
+		return xerrors.Errorf("getting sealed sector path: %w", err)
+	}
+
+	if err := assertFile(filepath.Join(sealed), sb.ssize, sb.ssize); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func assertFile(path string, minSz uint64, maxSz uint64) error {
+	st, err := os.Stat(path)
+	if err != nil {
+		return xerrors.Errorf("stat %s: %w", path, err)
+	}
+
+	if st.IsDir() {
+		return xerrors.Errorf("expected %s to be a regular file", path)
+	}
+
+	if uint64(st.Size()) < minSz || uint64(st.Size()) > maxSz {
+		return xerrors.Errorf("%s wasn't within size bounds, expected %d < f < %d, got %d", minSz, maxSz, st.Size())
+	}
+
+	return nil
+}

lib/sectorbuilder/sectorbuilder.go

@@ -623,7 +623,7 @@ func (sb *SectorBuilder) ComputeElectionPoSt(sectorInfo SortedPublicSectorInfo,
 	var cseed [CommLen]byte
 	copy(cseed[:], challengeSeed)
 
-	privsects, err := sb.pubSectorToPriv(sectorInfo)
+	privsects, err := sb.pubSectorToPriv(sectorInfo, nil) // TODO: faults
 	if err != nil {
 		return nil, err
 	}
@@ -634,20 +634,29 @@ func (sb *SectorBuilder) ComputeElectionPoSt(sectorInfo SortedPublicSectorInfo,
 }
 
 func (sb *SectorBuilder) GenerateEPostCandidates(sectorInfo SortedPublicSectorInfo, challengeSeed [CommLen]byte, faults []uint64) ([]EPostCandidate, error) {
-	privsectors, err := sb.pubSectorToPriv(sectorInfo)
+	privsectors, err := sb.pubSectorToPriv(sectorInfo, faults)
 	if err != nil {
 		return nil, err
 	}
 
-	challengeCount := types.ElectionPostChallengeCount(uint64(len(sectorInfo.Values())))
+	challengeCount := types.ElectionPostChallengeCount(uint64(len(sectorInfo.Values())), len(faults))
 
 	proverID := addressToProverID(sb.Miner)
 	return sectorbuilder.GenerateCandidates(sb.ssize, proverID, challengeSeed, challengeCount, privsectors)
 }
 
-func (sb *SectorBuilder) pubSectorToPriv(sectorInfo SortedPublicSectorInfo) (SortedPrivateSectorInfo, error) {
+func (sb *SectorBuilder) pubSectorToPriv(sectorInfo SortedPublicSectorInfo, faults []uint64) (SortedPrivateSectorInfo, error) {
+	fmap := map[uint64]struct{}{}
+	for _, fault := range faults {
+		fmap[fault] = struct{}{}
+	}
+
 	var out []sectorbuilder.PrivateSectorInfo
 	for _, s := range sectorInfo.Values() {
+		if _, faulty := fmap[s.SectorID]; faulty {
+			continue
+		}
+
 		cachePath, err := sb.sectorCacheDir(s.SectorID)
 		if err != nil {
 			return SortedPrivateSectorInfo{}, xerrors.Errorf("getting cache path for sector %d: %w", s.SectorID, err)
@@ -669,12 +678,12 @@ func (sb *SectorBuilder) pubSectorToPriv(sectorInfo SortedPublicSectorInfo) (Sor
 }
 
 func (sb *SectorBuilder) GenerateFallbackPoSt(sectorInfo SortedPublicSectorInfo, challengeSeed [CommLen]byte, faults []uint64) ([]EPostCandidate, []byte, error) {
-	privsectors, err := sb.pubSectorToPriv(sectorInfo)
+	privsectors, err := sb.pubSectorToPriv(sectorInfo, faults)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	challengeCount := fallbackPostChallengeCount(uint64(len(sectorInfo.Values())))
+	challengeCount := fallbackPostChallengeCount(uint64(len(sectorInfo.Values())), len(faults))
 
 	proverID := addressToProverID(sb.Miner)
 	candidates, err := sectorbuilder.GenerateCandidates(sb.ssize, proverID, challengeSeed, challengeCount, privsectors)
@@ -690,8 +699,8 @@ func (sb *SectorBuilder) Stop() {
 	close(sb.stopping)
 }
 
-func fallbackPostChallengeCount(sectors uint64) uint64 {
-	challengeCount := types.ElectionPostChallengeCount(sectors)
+func fallbackPostChallengeCount(sectors uint64, faults int) uint64 {
+	challengeCount := types.ElectionPostChallengeCount(sectors, faults)
 	if challengeCount > build.MaxFallbackPostChallengeCount {
 		return build.MaxFallbackPostChallengeCount
 	}

lib/sectorbuilder/simple.go

@@ -37,12 +37,12 @@ func NewSortedPublicSectorInfo(sectors []sectorbuilder.PublicSectorInfo) SortedP
 }
 
 func VerifyElectionPost(ctx context.Context, sectorSize uint64, sectorInfo SortedPublicSectorInfo, challengeSeed []byte, proof []byte, candidates []EPostCandidate, proverID address.Address) (bool, error) {
-	challengeCount := types.ElectionPostChallengeCount(uint64(len(sectorInfo.Values())))
+	challengeCount := types.ElectionPostChallengeCount(uint64(len(sectorInfo.Values())), 0)
 	return verifyPost(ctx, sectorSize, sectorInfo, challengeCount, challengeSeed, proof, candidates, proverID)
 }
 
-func VerifyFallbackPost(ctx context.Context, sectorSize uint64, sectorInfo SortedPublicSectorInfo, challengeSeed []byte, proof []byte, candidates []EPostCandidate, proverID address.Address) (bool, error) {
-	challengeCount := fallbackPostChallengeCount(uint64(len(sectorInfo.Values())))
+func VerifyFallbackPost(ctx context.Context, sectorSize uint64, sectorInfo SortedPublicSectorInfo, challengeSeed []byte, proof []byte, candidates []EPostCandidate, proverID address.Address, faults int) (bool, error) {
+	challengeCount := fallbackPostChallengeCount(uint64(len(sectorInfo.Values())), faults)
 	return verifyPost(ctx, sectorSize, sectorInfo, challengeCount, challengeSeed, proof, candidates, proverID)
 }