resolve comments

Author: hanabi1224

certstore/snapshot.go

@@ -5,86 +5,77 @@ import (
 	"context"
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"io"
 
 	"github.com/filecoin-project/go-f3/gpbft"
-	"github.com/ipfs/go-datastore"
-	xerrors "golang.org/x/xerrors"
+	"github.com/filecoin-project/go-state-types/cbor"
 )
 
-var ErrlatestCertificateNil = errors.New("latest certificate is not available")
+var ErrUnknownLatestCertificate = errors.New("latest certificate is not known")
 
-// Exports an F3 snapshot that includes the finality certificate chain until the current `latestCertificate`.
+// ExportLatestSnapshot exports an F3 snapshot that includes the finality certificate chain until the current `latestCertificate`.
 func (cs *Store) ExportLatestSnapshot(ctx context.Context, writer io.Writer) error {
 	if cs.latestCertificate == nil {
-		return ErrlatestCertificateNil
+		return ErrUnknownLatestCertificate
 	}
 	return cs.ExportSnapshot(ctx, cs.latestCertificate.GPBFTInstance, writer)
 }
 
-// Exports an F3 snapshot that includes the finality certificate chain until the specified `lastInstance`.
-func (cs *Store) ExportSnapshot(ctx context.Context, lastInstance uint64, writer io.Writer) error {
+// ExportSnapshot exports an F3 snapshot that includes the finality certificate chain from the `Store.firstInstance` to the specified `lastInstance`.
+func (cs *Store) ExportSnapshot(ctx context.Context, latestInstance uint64, writer io.Writer) error {
 	initialPowerTable, err := cs.GetPowerTable(ctx, cs.firstInstance)
 	if err != nil {
-		return xerrors.Errorf("failed to get initial power table at instance %d: %w", cs.firstInstance, err)
+		return fmt.Errorf("failed to get initial power table at instance %d: %w", cs.firstInstance, err)
 	}
-	header := SnapshotHeader{1, cs.firstInstance, lastInstance, initialPowerTable}
-	if err := header.WriteToSnapshot(writer); err != nil {
-		return xerrors.Errorf("failed to write snapshot header: %w", err)
+	header := SnapshotHeader{1, cs.firstInstance, latestInstance, initialPowerTable}
+	if _, err := header.WriteTo(writer); err != nil {
+		return fmt.Errorf("failed to write snapshot header: %w", err)
 	}
-	for i := cs.firstInstance; i <= lastInstance; i++ {
+	for i := cs.firstInstance; i <= latestInstance; i++ {
 		cert, err := cs.ds.Get(ctx, cs.keyForCert(i))
 		if err != nil {
-			return xerrors.Errorf("failed to get certificate at instance %d:: %w", i, err)
+			return fmt.Errorf("failed to get certificate at instance %d:: %w", i, err)
 		}
 		buffer := bytes.NewBuffer(cert)
-		if err := writeSnapshotBlockBytes(writer, buffer); err != nil {
+		if _, err := writeSnapshotBlockBytes(writer, buffer); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-// Imports an F3 snapshot and opens the certificate store.
-//
-// The passed Datastore has to be thread safe.
-func ImportSnapshotAndOpenStore(ctx context.Context, ds datastore.Datastore) error {
-	return xerrors.New("to be implemented")
-}
-
 type SnapshotHeader struct {
 	Version           uint64
 	FirstInstance     uint64
 	LatestInstance    uint64
 	InitialPowerTable gpbft.PowerEntries
 }
 
-func (h *SnapshotHeader) WriteToSnapshot(writer io.Writer) error {
-	return writeSnapshotCborEncodedBlock(writer, h)
+func (h *SnapshotHeader) WriteTo(w io.Writer) (int64, error) {
+	return writeSnapshotCborEncodedBlock(w, h)
 }
 
-// Writes CBOR-encoded header or data block with a varint-encoded length prefix
-func writeSnapshotCborEncodedBlock(writer io.Writer, block MarshalCBOR) error {
+// writeSnapshotCborEncodedBlock writes CBOR-encoded header or data block with a varint-encoded length prefix
+func writeSnapshotCborEncodedBlock(writer io.Writer, block cbor.Marshaler) (int64, error) {
 	var buffer bytes.Buffer
 	if err := block.MarshalCBOR(&buffer); err != nil {
-		return err
+		return 0, err
 	}
 	return writeSnapshotBlockBytes(writer, &buffer)
 }
 
-// Writes header or data block with a varint-encoded length prefix
-func writeSnapshotBlockBytes(writer io.Writer, buffer *bytes.Buffer) error {
+// writeSnapshotBlockBytes writes header or data block with a varint-encoded length prefix
+func writeSnapshotBlockBytes(writer io.Writer, buffer *bytes.Buffer) (int64, error) {
 	buf := make([]byte, 8)
 	n := binary.PutUvarint(buf, uint64(buffer.Len()))
-	if _, err := writer.Write(buf[:n]); err != nil {
-		return err
+	len1, err := bytes.NewBuffer(buf[:n]).WriteTo(writer)
+	if err != nil {
+		return 0, err
 	}
-	if _, err := buffer.WriteTo(writer); err != nil {
-		return err
+	len2, err := buffer.WriteTo(writer)
+	if err != nil {
+		return 0, err
 	}
-	return nil
-}
-
-type MarshalCBOR interface {
-	MarshalCBOR(w io.Writer) error
+	return len1 + len2, nil
 }

certstore/snapshot_test.go

@@ -0,0 +1 @@
+package certstore

f3.go

@@ -126,6 +126,13 @@ func (m *F3) GetCert(ctx context.Context, instance uint64) (*certs.FinalityCerti
 	return nil, ErrF3NotRunning
 }
 
+func (m *F3) GetCertStore(ctx context.Context) (*certstore.Store, error) {
+	if state := m.state.Load(); state != nil {
+		return state.cs, nil
+	}
+	return nil, ErrF3NotRunning
+}
+
 // GetPowerTableByInstance returns the power table (committee) used to validate the specified instance.
 func (m *F3) GetPowerTableByInstance(ctx context.Context, instance uint64) (gpbft.PowerEntries, error) {
 	if state := m.state.Load(); state != nil {