Merge pull request #21 from filecoin-project/feat/4-consts-for-seal-status-codes

feat/4 consts for seal status codes

bindings.go

@@ -6,6 +6,9 @@ import (
 	"time"
 	"unsafe"
 
+	"github.com/filecoin-project/go-sectorbuilder/sealed_sector_health"
+	"github.com/filecoin-project/go-sectorbuilder/sealing_state"
+
 	logging "github.com/ipfs/go-log"
 	"github.com/pkg/errors"
 )
@@ -24,18 +27,6 @@ func elapsed(what string) func() {
 	}
 }
 
-// SealedSectorHealth represents the healthiness of a sector managed by a
-// sector builder.
-type SealedSectorHealth int
-
-const (
-	Unknown              SealedSectorHealth = iota
-	Ok                                      // everything is fine
-	ErrorInvalidChecksum                    // sector exists, but checksum is invalid
-	ErrorInvalidLength                      // sector exists, but length is incorrect
-	ErrorMissing                            // sector no longer exists
-)
-
 // SortedSectorInfo is a slice of SectorInfo sorted (lexicographically,
 // ascending) by replica commitment (CommR).
 type SortedSectorInfo struct {
@@ -83,20 +74,20 @@ type SealedSectorMetadata struct {
 	CommRStar [CommitmentBytesLen]byte
 	Proof     []byte
 	Pieces    []PieceMetadata
-	Health    SealedSectorHealth
+	Health    sealed_sector_health.Health
 }
 
 // SectorSealingStatus communicates how far along in the sealing process a
 // sector has progressed.
 type SectorSealingStatus struct {
-	SectorID       uint64
-	SealStatusCode uint8                    // Sealed = 0, Pending = 1, Failed = 2, Sealing = 3
-	SealErrorMsg   string                   // will be nil unless SealStatusCode == 2
-	CommD          [CommitmentBytesLen]byte // will be empty unless SealStatusCode == 0
-	CommR          [CommitmentBytesLen]byte // will be empty unless SealStatusCode == 0
-	CommRStar      [CommitmentBytesLen]byte // will be empty unless SealStatusCode == 0
-	Proof          []byte                   // will be empty unless SealStatusCode == 0
-	Pieces         []PieceMetadata          // will be empty unless SealStatusCode == 0
+	SectorID     uint64
+	State        sealing_state.State
+	SealErrorMsg string                   // will be nil unless State == Failed
+	CommD        [CommitmentBytesLen]byte // will be empty unless State == Sealed
+	CommR        [CommitmentBytesLen]byte // will be empty unless State == Sealed
+	CommRStar    [CommitmentBytesLen]byte // will be empty unless State == Sealed
+	Proof        []byte                   // will be empty unless State == Sealed
+	Pieces       []PieceMetadata          // will be empty unless State == Sealed
 }
 
 // PieceMetadata represents a piece stored by the sector builder.
@@ -418,11 +409,11 @@ func GetSectorSealingStatusByID(sectorBuilderPtr unsafe.Pointer, sectorID uint64
 	}
 
 	if resPtr.seal_status_code == C.Failed {
-		return SectorSealingStatus{SectorID: sectorID, SealStatusCode: 2, SealErrorMsg: C.GoString(resPtr.seal_error_msg)}, nil
+		return SectorSealingStatus{SectorID: sectorID, State: sealing_state.Failed, SealErrorMsg: C.GoString(resPtr.seal_error_msg)}, nil
 	} else if resPtr.seal_status_code == C.Pending {
-		return SectorSealingStatus{SectorID: sectorID, SealStatusCode: 1}, nil
+		return SectorSealingStatus{SectorID: sectorID, State: sealing_state.Pending}, nil
 	} else if resPtr.seal_status_code == C.Sealing {
-		return SectorSealingStatus{SectorID: sectorID, SealStatusCode: 3}, nil
+		return SectorSealingStatus{SectorID: sectorID, State: sealing_state.Sealing}, nil
 	} else if resPtr.seal_status_code == C.Sealed {
 		commRSlice := goBytes(&resPtr.comm_r[0], CommitmentBytesLen)
 		var commR [CommitmentBytesLen]byte
@@ -444,13 +435,13 @@ func GetSectorSealingStatusByID(sectorBuilderPtr unsafe.Pointer, sectorID uint64
 		}
 
 		return SectorSealingStatus{
-			SectorID:       sectorID,
-			SealStatusCode: 0,
-			CommD:          commD,
-			CommR:          commR,
-			CommRStar:      commRStar,
-			Proof:          proof,
-			Pieces:         ps,
+			SectorID:  sectorID,
+			State:     sealing_state.Sealed,
+			CommD:     commD,
+			CommR:     commR,
+			CommRStar: commRStar,
+			Proof:     proof,
+			Pieces:    ps,
 		}, nil
 	} else {
 		// unknown

bindings_test.go

@@ -12,6 +12,8 @@ import (
 	"unsafe"
 
 	sb "github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/go-sectorbuilder/sealed_sector_health"
+	"github.com/filecoin-project/go-sectorbuilder/sealing_state"
 
 	"github.com/stretchr/testify/require"
 )
@@ -63,7 +65,7 @@ func TestSectorBuilderLifecycle(t *testing.T) {
 
 	// block until Groth parameter cache is (lazily) hydrated and sector has
 	// been sealed (or timeout)
-	status, err := pollForSectorSealingStatus(ptr, sectorID, 0, time.Minute*30)
+	status, err := pollForSectorSealingStatus(ptr, sectorID, sealing_state.Sealed, time.Minute*30)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(status.Pieces), "expected to see the one piece we added")
 
@@ -98,7 +100,7 @@ func TestSectorBuilderLifecycle(t *testing.T) {
 	sealedSector := sealedSectors[0]
 	require.Equal(t, uint64(1), sealedSector.SectorID)
 	require.Equal(t, 1, len(sealedSector.Pieces))
-	require.Equal(t, sb.Ok, sealedSector.Health)
+	require.Equal(t, sealed_sector_health.Ok, sealedSector.Health)
 	// the piece is the size of the sector, so its piece commitment should be the
 	// data commitment
 	require.Equal(t, commP, sealedSector.CommD)
@@ -110,7 +112,7 @@ func TestSectorBuilderLifecycle(t *testing.T) {
 	require.Equal(t, pieceBytes, unsealedPieceBytes)
 }
 
-func pollForSectorSealingStatus(ptr unsafe.Pointer, sectorID uint64, sealStatusCode uint8, timeout time.Duration) (status sb.SectorSealingStatus, retErr error) {
+func pollForSectorSealingStatus(ptr unsafe.Pointer, sectorID uint64, targetState sealing_state.State, timeout time.Duration) (status sb.SectorSealingStatus, retErr error) {
 	timeoutCh := time.After(timeout)
 
 	tick := time.Tick(5 * time.Second)
@@ -127,7 +129,7 @@ func pollForSectorSealingStatus(ptr unsafe.Pointer, sectorID uint64, sealStatusC
 				return
 			}
 
-			if sealingStatus.SealStatusCode == sealStatusCode {
+			if sealingStatus.State == targetState {
 				status = sealingStatus
 				return
 			}

sealed_sector_health/health.go

+package sealed_sector_health
+
+// Health represents the healthiness of a sector managed by a
+// sector builder.
+type Health int
+
+const (
+	Unknown         Health = iota
+	Ok                     // everything is fine
+	InvalidChecksum        // sector exists, but checksum is invalid
+	InvalidLength          // sector exists, but length is incorrect
+	Missing                // sector no longer exists
+)
+
+var labels = [...]string{
+	"Unknown",
+	"Ok",
+	"InvalidChecksum",
+	"InvalidLength",
+	"Missing",
+}
+
+func (el Health) String() string {
+	return labels[el]
+}

sealing_state/state.go

+package sealing_state
+
+// State communicates the state of the sector with respect to sealing.
+type State int
+
+const (
+	Unknown State = iota
+	Pending       // sector is still accepting user data
+	Failed        // sealing failed
+	Sealing       // sector is currently being sealed
+	Sealed        // sector has been sealed successfully
+)
+
+var labels = [...]string{
+	"Unknown",
+	"Pending",
+	"Failed",
+	"Sealing",
+	"Sealed",
+}
+
+func (el State) String() string {
+	return labels[el]
+}

transforms.go

@@ -3,6 +3,8 @@ package go_sectorbuilder
 import (
 	"unsafe"
 
+	"github.com/filecoin-project/go-sectorbuilder/sealed_sector_health"
+
 	"github.com/pkg/errors"
 )
 
@@ -127,19 +129,19 @@ func goPieceMetadata(src *C.sector_builder_ffi_FFIPieceMetadata, size C.size_t)
 	return ps, nil
 }
 
-func goSealedSectorHealth(health C.sector_builder_ffi_FFISealedSectorHealth) (SealedSectorHealth, error) {
+func goSealedSectorHealth(health C.sector_builder_ffi_FFISealedSectorHealth) (sealed_sector_health.Health, error) {
 	switch health {
 	case C.Unknown:
-		return Unknown, nil
+		return sealed_sector_health.Unknown, nil
 	case C.Ok:
-		return Ok, nil
+		return sealed_sector_health.Ok, nil
 	case C.ErrorInvalidChecksum:
-		return ErrorInvalidChecksum, nil
+		return sealed_sector_health.InvalidChecksum, nil
 	case C.ErrorInvalidLength:
-		return ErrorInvalidLength, nil
+		return sealed_sector_health.InvalidLength, nil
 	case C.ErrorMissing:
-		return ErrorMissing, nil
+		return sealed_sector_health.Missing, nil
 	default:
-		return Unknown, errors.Errorf("unhandled sealed sector health: %v", health)
+		return sealed_sector_health.Unknown, errors.Errorf("unhandled sealed sector health: %v", health)
 	}
 }