From 9277c2d68d6ce0cadc367d511657e4e30a9ffe7c Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Thu, 14 Apr 2022 13:45:55 +0200 Subject: [PATCH 01/37] Use testground-github-action from testground org --- .github/workflows/testground-on-push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testground-on-push.yml b/.github/workflows/testground-on-push.yml index 2a3c8af1d..8e749bfae 100644 --- a/.github/workflows/testground-on-push.yml +++ b/.github/workflows/testground-on-push.yml @@ -21,7 +21,7 @@ jobs: steps: - uses: actions/checkout@v2 - name: testground run - uses: coryschwartz/testground-github-action@v1.1 + uses: testground/testground-github-action@v1 with: backend_addr: ${{ matrix.backend_addr }} backend_proto: ${{ matrix.backend_proto }} From b2a6d308ba2a0b28cc0e50b079e32288b4416249 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Tue, 12 Apr 2022 11:45:34 -0400 Subject: [PATCH 02/37] Consolidate nullreader files --- extern/storage-sealing/input.go | 4 +++- .../lib/nullreader/nullreader.go | 18 +++++++++++++++++ extern/storage-sealing/nullreader.go | 20 ------------------- extern/storage-sealing/states_sealing.go | 4 +++- lib/rpcenc/reader.go | 3 ++- lib/rpcenc/reader_test.go | 3 ++- 6 files changed, 28 insertions(+), 24 deletions(-) delete mode 100644 extern/storage-sealing/nullreader.go diff --git a/extern/storage-sealing/input.go b/extern/storage-sealing/input.go index 9654296ca..5d6176202 100644 --- a/extern/storage-sealing/input.go +++ b/extern/storage-sealing/input.go @@ -5,6 +5,8 @@ import ( "sort" "time" + "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/filecoin-project/go-padreader" "github.com/filecoin-project/go-statemachine" "github.com/ipfs/go-cid" @@ -220,7 +222,7 @@ func (m *Sealing) handleAddPiece(ctx statemachine.Context, sector SectorInfo) er m.minerSector(sector.SectorType, sector.SectorNumber), pieceSizes, p.Unpadded(), - NewNullReader(p.Unpadded())) + nullreader.NewNullReader(p.Unpadded())) if err != nil { err = xerrors.Errorf("writing padding piece: %w", err) deal.accepted(sector.SectorNumber, offset, err) diff --git a/extern/storage-sealing/lib/nullreader/nullreader.go b/extern/storage-sealing/lib/nullreader/nullreader.go index dc3537ad7..9e4bc523c 100644 --- a/extern/storage-sealing/lib/nullreader/nullreader.go +++ b/extern/storage-sealing/lib/nullreader/nullreader.go @@ -1,5 +1,23 @@ package nullreader +import ( + "io" + + "github.com/filecoin-project/go-state-types/abi" +) + +type NullReader struct { + *io.LimitedReader +} + +func NewNullReader(size abi.UnpaddedPieceSize) io.Reader { + return &NullReader{(io.LimitReader(&Reader{}, int64(size))).(*io.LimitedReader)} +} + +func (m NullReader) NullBytes() int64 { + return m.N +} + // TODO: extract this to someplace where it can be shared with lotus type Reader struct{} diff --git a/extern/storage-sealing/nullreader.go b/extern/storage-sealing/nullreader.go deleted file mode 100644 index 5987a4145..000000000 --- a/extern/storage-sealing/nullreader.go +++ /dev/null @@ -1,20 +0,0 @@ -package sealing - -import ( - "io" - - "github.com/filecoin-project/go-state-types/abi" - nr "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" -) - -type NullReader struct { - *io.LimitedReader -} - -func NewNullReader(size abi.UnpaddedPieceSize) io.Reader { - return &NullReader{(io.LimitReader(&nr.Reader{}, int64(size))).(*io.LimitedReader)} -} - -func (m NullReader) NullBytes() int64 { - return m.N -} diff --git a/extern/storage-sealing/states_sealing.go b/extern/storage-sealing/states_sealing.go index 1b2556943..bc9389688 100644 --- a/extern/storage-sealing/states_sealing.go +++ b/extern/storage-sealing/states_sealing.go @@ -4,6 +4,8 @@ import ( "bytes" "context" + "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/ipfs/go-cid" "golang.org/x/xerrors" @@ -91,7 +93,7 @@ func (m *Sealing) padSector(ctx context.Context, sectorID storage.SectorRef, exi for i, size := range sizes { expectCid := zerocomm.ZeroPieceCommitment(size) - ppi, err := m.sealer.AddPiece(ctx, sectorID, existingPieceSizes, size, NewNullReader(size)) + ppi, err := m.sealer.AddPiece(ctx, sectorID, existingPieceSizes, size, nullreader.NewNullReader(size)) if err != nil { return nil, xerrors.Errorf("add piece: %w", err) } diff --git a/lib/rpcenc/reader.go b/lib/rpcenc/reader.go index 61ae80ba9..1e00fb6be 100644 --- a/lib/rpcenc/reader.go +++ b/lib/rpcenc/reader.go @@ -15,13 +15,14 @@ import ( "sync" "time" + sealing "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/google/uuid" logging "github.com/ipfs/go-log/v2" "golang.org/x/xerrors" "github.com/filecoin-project/go-jsonrpc" "github.com/filecoin-project/go-state-types/abi" - sealing "github.com/filecoin-project/lotus/extern/storage-sealing" ) var log = logging.Logger("rpcenc") diff --git a/lib/rpcenc/reader_test.go b/lib/rpcenc/reader_test.go index 302908df0..06171025a 100644 --- a/lib/rpcenc/reader_test.go +++ b/lib/rpcenc/reader_test.go @@ -9,12 +9,13 @@ import ( "strings" "testing" + sealing "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/gorilla/mux" "github.com/stretchr/testify/require" "golang.org/x/xerrors" "github.com/filecoin-project/go-jsonrpc" - sealing "github.com/filecoin-project/lotus/extern/storage-sealing" ) type ReaderHandler struct { From 98637b357b6521665ddea214b743894dbe2b2e1f Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Thu, 7 Apr 2022 17:00:40 -0400 Subject: [PATCH 03/37] Replica unseal working --- .../sector-storage/ffiwrapper/sealer_cgo.go | 50 +++++++++++++++++-- extern/sector-storage/manager.go | 10 ++-- extern/sector-storage/manager_test.go | 6 +++ 3 files changed, 59 insertions(+), 7 deletions(-) diff --git a/extern/sector-storage/ffiwrapper/sealer_cgo.go b/extern/sector-storage/ffiwrapper/sealer_cgo.go index 400b67211..18a4e64cb 100644 --- a/extern/sector-storage/ffiwrapper/sealer_cgo.go +++ b/extern/sector-storage/ffiwrapper/sealer_cgo.go @@ -15,6 +15,8 @@ import ( "os" "runtime" + nr "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/ipfs/go-cid" "golang.org/x/xerrors" @@ -369,8 +371,8 @@ func (sb *Sealer) pieceCid(spt abi.RegisteredSealProof, in []byte) (cid.Cid, err return pieceCID, werr() } -func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storage.SectorRef, commD cid.Cid, unsealedPath string) (bool, error) { - paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUpdate|storiface.FTSealed|storiface.FTCache, storiface.FTNone, storiface.PathStorage) +func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storage.SectorRef, commD cid.Cid, unsealedPath string, randomness abi.SealRandomness) (bool, error) { + replicaPath, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUpdate|storiface.FTUpdateCache, storiface.FTNone, storiface.PathStorage) if xerrors.Is(err, storiface.ErrSectorNotFound) { return false, nil } else if err != nil { @@ -378,12 +380,52 @@ func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storage.Se } defer done() + sealedPaths, releaseSectorKey, err := sb.AcquireSectorKeyOrRegenerate(ctx, sector, randomness) + if err != nil { + return false, xerrors.Errorf("acquiring sealed sector: %w", err) + } + defer releaseSectorKey() + // Sector data stored in replica update updateProof, err := sector.ProofType.RegisteredUpdateProof() if err != nil { return false, err } - return true, ffi.SectorUpdate.DecodeFrom(updateProof, unsealedPath, paths.Update, paths.Sealed, paths.Cache, commD) + return true, ffi.SectorUpdate.DecodeFrom(updateProof, unsealedPath, replicaPath.Update, sealedPaths.Sealed, sealedPaths.Cache, commD) +} + +func (sb *Sealer) AcquireSectorKeyOrRegenerate(ctx context.Context, sector storage.SectorRef, randomness abi.SealRandomness) (storiface.SectorPaths, func(), error) { + paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.FTNone, storiface.PathStorage) + if err == nil { + return paths, done, err + } else if !xerrors.Is(err, storiface.ErrSectorNotFound) { + return paths, done, xerrors.Errorf("reading sector key: %w", err) + } + + // Sector key can't be found, so let's regenerate it + sectorSize, err := sector.ProofType.SectorSize() + if err != nil { + return paths, done, xerrors.Errorf("retrieving sector size: %w", err) + } + paddedSize := abi.PaddedPieceSize(sectorSize) + + _, err = sb.AddPiece(ctx, sector, nil, paddedSize.Unpadded(), nr.NewNullReader(paddedSize.Unpadded())) + if err != nil { + return paths, done, xerrors.Errorf("recomputing empty data: %w", err) + } + + pc1, err := sb.SealPreCommit1(ctx, sector, randomness, []abi.PieceInfo{{PieceCID: zerocomm.ZeroPieceCommitment(paddedSize.Unpadded()), Size: paddedSize}}) + if err != nil { + return paths, done, xerrors.Errorf("during pc1: %w", err) + } + + _, err = sb.SealPreCommit2(ctx, sector, pc1) + if err != nil { + return paths, done, xerrors.Errorf("during pc2: %w", err) + } + + // Sector key should exist now, let's grab the paths + return sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.FTNone, storiface.PathStorage) } func (sb *Sealer) UnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error { @@ -437,7 +479,7 @@ func (sb *Sealer) UnsealPiece(ctx context.Context, sector storage.SectorRef, off } // If piece data stored in updated replica decode whole sector - decoded, err := sb.tryDecodeUpdatedReplica(ctx, sector, commd, unsealedPath.Unsealed) + decoded, err := sb.tryDecodeUpdatedReplica(ctx, sector, commd, unsealedPath.Unsealed, randomness) if err != nil { return xerrors.Errorf("decoding sector from replica: %w", err) } diff --git a/extern/sector-storage/manager.go b/extern/sector-storage/manager.go index 4b52f9a1d..10869a65f 100644 --- a/extern/sector-storage/manager.go +++ b/extern/sector-storage/manager.go @@ -273,7 +273,7 @@ func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storage.SectorR defer cancel() log.Debugf("acquire unseal sector lock for sector %d", sector.ID) - if err := m.index.StorageLock(ctx, sector.ID, storiface.FTSealed|storiface.FTCache, storiface.FTUnsealed); err != nil { + if err := m.index.StorageLock(ctx, sector.ID, storiface.FTSealed|storiface.FTCache|storiface.FTUpdate|storiface.FTUpdateCache, storiface.FTUnsealed); err != nil { return xerrors.Errorf("acquiring unseal sector lock: %w", err) } @@ -281,8 +281,12 @@ func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storage.SectorR // put it in the sealing scratch space. sealFetch := func(ctx context.Context, worker Worker) error { log.Debugf("copy sealed/cache sector data for sector %d", sector.ID) - if _, err := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.PathSealing, storiface.AcquireCopy)); err != nil { - return xerrors.Errorf("copy sealed/cache sector data: %w", err) + _, err := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.PathSealing, storiface.AcquireCopy)) + if err != nil { + _, err2 := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTUpdate|storiface.FTUpdateCache, storiface.PathSealing, storiface.AcquireCopy)) + if err2 != nil { + return xerrors.Errorf("copy sealed/cache sector data: %w %w", err, err2) + } } return nil diff --git a/extern/sector-storage/manager_test.go b/extern/sector-storage/manager_test.go index 9c844292e..d9f8af461 100644 --- a/extern/sector-storage/manager_test.go +++ b/extern/sector-storage/manager_test.go @@ -315,6 +315,12 @@ func TestSnapDeals(t *testing.T) { require.NoError(t, m.GenerateSectorKeyFromData(ctx, sid, out.NewUnsealed)) fmt.Printf("GSK duration (%s): %s\n", ss.ShortString(), time.Since(startGSK)) + fmt.Printf("Remove data\n") + require.NoError(t, m.FinalizeSector(ctx, sid, nil)) + fmt.Printf("Release Sector Key\n") + require.NoError(t, m.ReleaseSectorKey(ctx, sid)) + fmt.Printf("Unseal Replica\n") + require.NoError(t, m.SectorsUnsealPiece(ctx, sid, 0, p1.Size.Unpadded(), ticket, &out.NewUnsealed)) } func TestRedoPC1(t *testing.T) { From 2134f165c0090e01b3f29404a8e094ccc7e8cabc Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Fri, 22 Apr 2022 14:29:35 +0200 Subject: [PATCH 04/37] Review fixes --- extern/sector-storage/ffiwrapper/sealer_cgo.go | 4 ++-- extern/sector-storage/manager.go | 14 +++++++++----- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/extern/sector-storage/ffiwrapper/sealer_cgo.go b/extern/sector-storage/ffiwrapper/sealer_cgo.go index 18a4e64cb..ea64fb36e 100644 --- a/extern/sector-storage/ffiwrapper/sealer_cgo.go +++ b/extern/sector-storage/ffiwrapper/sealer_cgo.go @@ -380,11 +380,11 @@ func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storage.Se } defer done() - sealedPaths, releaseSectorKey, err := sb.AcquireSectorKeyOrRegenerate(ctx, sector, randomness) + sealedPaths, done2, err := sb.AcquireSectorKeyOrRegenerate(ctx, sector, randomness) if err != nil { return false, xerrors.Errorf("acquiring sealed sector: %w", err) } - defer releaseSectorKey() + defer done2() // Sector data stored in replica update updateProof, err := sector.ProofType.RegisteredUpdateProof() diff --git a/extern/sector-storage/manager.go b/extern/sector-storage/manager.go index 10869a65f..fcbe141b0 100644 --- a/extern/sector-storage/manager.go +++ b/extern/sector-storage/manager.go @@ -282,11 +282,15 @@ func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storage.SectorR sealFetch := func(ctx context.Context, worker Worker) error { log.Debugf("copy sealed/cache sector data for sector %d", sector.ID) _, err := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.PathSealing, storiface.AcquireCopy)) - if err != nil { - _, err2 := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTUpdate|storiface.FTUpdateCache, storiface.PathSealing, storiface.AcquireCopy)) - if err2 != nil { - return xerrors.Errorf("copy sealed/cache sector data: %w %w", err, err2) - } + if err != nil && !xerrors.Is(err, storiface.ErrSectorNotFound) { + return err + } + _, err2 := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTUpdate|storiface.FTUpdateCache, storiface.PathSealing, storiface.AcquireCopy)) + if err2 != nil && !xerrors.Is(err, storiface.ErrSectorNotFound) { + return err + } + if err != nil && err2 != nil { + return xerrors.Errorf("cannot unseal piece. No sealed or updated sector found") } return nil From 5030fd2589065da78dee1848412afb16f617a5c7 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Fri, 15 Apr 2022 10:55:00 -0400 Subject: [PATCH 05/37] Optimize sector key regeneration --- .../sector-storage/ffiwrapper/sealer_cgo.go | 52 ++++++++++++++++--- 1 file changed, 46 insertions(+), 6 deletions(-) diff --git a/extern/sector-storage/ffiwrapper/sealer_cgo.go b/extern/sector-storage/ffiwrapper/sealer_cgo.go index ea64fb36e..273625320 100644 --- a/extern/sector-storage/ffiwrapper/sealer_cgo.go +++ b/extern/sector-storage/ffiwrapper/sealer_cgo.go @@ -414,16 +414,11 @@ func (sb *Sealer) AcquireSectorKeyOrRegenerate(ctx context.Context, sector stora return paths, done, xerrors.Errorf("recomputing empty data: %w", err) } - pc1, err := sb.SealPreCommit1(ctx, sector, randomness, []abi.PieceInfo{{PieceCID: zerocomm.ZeroPieceCommitment(paddedSize.Unpadded()), Size: paddedSize}}) + err = sb.RegenerateSectorKey(ctx, sector, randomness, []abi.PieceInfo{{PieceCID: zerocomm.ZeroPieceCommitment(paddedSize.Unpadded()), Size: paddedSize}}) if err != nil { return paths, done, xerrors.Errorf("during pc1: %w", err) } - _, err = sb.SealPreCommit2(ctx, sector, pc1) - if err != nil { - return paths, done, xerrors.Errorf("during pc2: %w", err) - } - // Sector key should exist now, let's grab the paths return sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.FTNone, storiface.PathStorage) } @@ -660,6 +655,51 @@ func (sb *Sealer) ReadPiece(ctx context.Context, writer io.Writer, sector storag return true, nil } +func (sb *Sealer) RegenerateSectorKey(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) error { + paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed|storiface.FTCache, storiface.FTSealed, storiface.PathSealing) + if err != nil { + return xerrors.Errorf("acquiring sector paths: %w", err) + } + defer done() + + e, err := os.OpenFile(paths.Sealed, os.O_RDWR|os.O_CREATE, 0644) // nolint:gosec + if err != nil { + return xerrors.Errorf("ensuring sealed file exists: %w", err) + } + if err := e.Close(); err != nil { + return err + } + + var sum abi.UnpaddedPieceSize + for _, piece := range pieces { + sum += piece.Size.Unpadded() + } + ssize, err := sector.ProofType.SectorSize() + if err != nil { + return err + } + ussize := abi.PaddedPieceSize(ssize).Unpadded() + if sum != ussize { + return xerrors.Errorf("aggregated piece sizes don't match sector size: %d != %d (%d)", sum, ussize, int64(ussize-sum)) + } + + // TODO: context cancellation respect + _, err = ffi.SealPreCommitPhase1( + sector.ProofType, + paths.Cache, + paths.Unsealed, + paths.Sealed, + sector.ID.Number, + sector.ID.Miner, + ticket, + pieces, + ) + if err != nil { + return xerrors.Errorf("presealing sector %d (%s): %w", sector.ID.Number, paths.Unsealed, err) + } + return nil +} + func (sb *Sealer) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed, storiface.FTSealed|storiface.FTCache, storiface.PathSealing) if err != nil { From ebf5eb6e287877d5bc53075b24ff4328cbddead6 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Tue, 19 Apr 2022 14:14:15 -0300 Subject: [PATCH 06/37] Update lib/rpcenc/reader.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Łukasz Magiera --- lib/rpcenc/reader.go | 8 ++++---- lib/rpcenc/reader_test.go | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/lib/rpcenc/reader.go b/lib/rpcenc/reader.go index 1e00fb6be..4e3ebb8c2 100644 --- a/lib/rpcenc/reader.go +++ b/lib/rpcenc/reader.go @@ -15,14 +15,14 @@ import ( "sync" "time" - sealing "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" - "github.com/google/uuid" logging "github.com/ipfs/go-log/v2" "golang.org/x/xerrors" "github.com/filecoin-project/go-jsonrpc" "github.com/filecoin-project/go-state-types/abi" + + "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" ) var log = logging.Logger("rpcenc") @@ -102,7 +102,7 @@ func ReaderParamEncoder(addr string) jsonrpc.Option { return jsonrpc.WithParamEncoder(new(io.Reader), func(value reflect.Value) (reflect.Value, error) { r := value.Interface().(io.Reader) - if r, ok := r.(*sealing.NullReader); ok { + if r, ok := r.(*nullreader.NullReader); ok { return reflect.ValueOf(ReaderStream{Type: Null, Info: fmt.Sprint(r.N)}), nil } @@ -419,7 +419,7 @@ func ReaderParamDecoder() (http.HandlerFunc, jsonrpc.ServerOption) { return reflect.Value{}, xerrors.Errorf("parsing null byte count: %w", err) } - return reflect.ValueOf(sealing.NewNullReader(abi.UnpaddedPieceSize(n))), nil + return reflect.ValueOf(nullreader.NewNullReader(abi.UnpaddedPieceSize(n))), nil } u, err := uuid.Parse(rs.Info) diff --git a/lib/rpcenc/reader_test.go b/lib/rpcenc/reader_test.go index 06171025a..881cbeaae 100644 --- a/lib/rpcenc/reader_test.go +++ b/lib/rpcenc/reader_test.go @@ -9,13 +9,13 @@ import ( "strings" "testing" - sealing "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" - "github.com/gorilla/mux" "github.com/stretchr/testify/require" "golang.org/x/xerrors" "github.com/filecoin-project/go-jsonrpc" + + "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" ) type ReaderHandler struct { @@ -58,7 +58,7 @@ func (h *ReaderHandler) ReadAll(ctx context.Context, r io.Reader) ([]byte, error } func (h *ReaderHandler) ReadNullLen(ctx context.Context, r io.Reader) (int64, error) { - return r.(*sealing.NullReader).N, nil + return r.(*nullreader.NullReader).N, nil } func (h *ReaderHandler) ReadUrl(ctx context.Context, u string) (string, error) { @@ -119,7 +119,7 @@ func TestNullReaderProxy(t *testing.T) { defer closer() - n, err := client.ReadNullLen(context.TODO(), sealing.NewNullReader(1016)) + n, err := client.ReadNullLen(context.TODO(), nullreader.NewNullReader(1016)) require.NoError(t, err) require.Equal(t, int64(1016), n) } From f6b08af337c878972bc5e7ed5725bfca31cfed76 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Tue, 19 Apr 2022 13:17:12 -0400 Subject: [PATCH 07/37] reorg import --- extern/sector-storage/ffiwrapper/sealer_cgo.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/extern/sector-storage/ffiwrapper/sealer_cgo.go b/extern/sector-storage/ffiwrapper/sealer_cgo.go index 273625320..79de4fdb9 100644 --- a/extern/sector-storage/ffiwrapper/sealer_cgo.go +++ b/extern/sector-storage/ffiwrapper/sealer_cgo.go @@ -15,8 +15,6 @@ import ( "os" "runtime" - nr "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" - "github.com/ipfs/go-cid" "golang.org/x/xerrors" @@ -33,6 +31,7 @@ import ( "github.com/filecoin-project/lotus/extern/sector-storage/fr32" "github.com/filecoin-project/lotus/extern/sector-storage/partialfile" "github.com/filecoin-project/lotus/extern/sector-storage/storiface" + nr "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" ) var _ Storage = &Sealer{} From 00015a21d45a7581fcdad24d114ddc393039ecd7 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Fri, 22 Apr 2022 14:36:58 +0200 Subject: [PATCH 08/37] Fix imports --- extern/storage-sealing/input.go | 3 +-- extern/storage-sealing/states_sealing.go | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/extern/storage-sealing/input.go b/extern/storage-sealing/input.go index 5d6176202..71b3b39d3 100644 --- a/extern/storage-sealing/input.go +++ b/extern/storage-sealing/input.go @@ -5,8 +5,6 @@ import ( "sort" "time" - "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" - "github.com/filecoin-project/go-padreader" "github.com/filecoin-project/go-statemachine" "github.com/ipfs/go-cid" @@ -24,6 +22,7 @@ import ( "github.com/filecoin-project/lotus/chain/types" sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" + "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" "github.com/filecoin-project/lotus/extern/storage-sealing/sealiface" ) diff --git a/extern/storage-sealing/states_sealing.go b/extern/storage-sealing/states_sealing.go index bc9389688..d20bbf696 100644 --- a/extern/storage-sealing/states_sealing.go +++ b/extern/storage-sealing/states_sealing.go @@ -4,8 +4,6 @@ import ( "bytes" "context" - "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" - "github.com/ipfs/go-cid" "golang.org/x/xerrors" @@ -23,6 +21,7 @@ import ( "github.com/filecoin-project/lotus/chain/actors" "github.com/filecoin-project/lotus/chain/actors/builtin/miner" "github.com/filecoin-project/lotus/chain/actors/policy" + "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" ) var DealSectorPriority = 1024 From 94ceb0355d4f2c6323e78bb6066a3828752b258c Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Sat, 23 Apr 2022 21:36:15 +0200 Subject: [PATCH 09/37] local worker now returns typed error instead of string --- extern/sector-storage/worker_local.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extern/sector-storage/worker_local.go b/extern/sector-storage/worker_local.go index 9a14e42b5..355915a34 100644 --- a/extern/sector-storage/worker_local.go +++ b/extern/sector-storage/worker_local.go @@ -289,7 +289,7 @@ func (l *LocalWorker) asyncCall(ctx context.Context, sector storage.SectorRef, r log.Errorf("get hostname err: %+v", err) } - err = xerrors.Errorf("%w [Hostname: %s]", err.Error(), hostname) + err = xerrors.Errorf("%w [Hostname: %s]", err, hostname) } if doReturn(ctx, rt, ci, l.ret, res, toCallError(err)) { From b50f4a57f0969c59923b4fc210c78f834f31bad1 Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Mon, 2 May 2022 15:34:45 -0400 Subject: [PATCH 10/37] replica unseal with work with worker fetch over rpc --- extern/sector-storage/manager.go | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/extern/sector-storage/manager.go b/extern/sector-storage/manager.go index fcbe141b0..8a41aa8f1 100644 --- a/extern/sector-storage/manager.go +++ b/extern/sector-storage/manager.go @@ -282,15 +282,10 @@ func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storage.SectorR sealFetch := func(ctx context.Context, worker Worker) error { log.Debugf("copy sealed/cache sector data for sector %d", sector.ID) _, err := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.PathSealing, storiface.AcquireCopy)) - if err != nil && !xerrors.Is(err, storiface.ErrSectorNotFound) { - return err - } _, err2 := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, storiface.FTUpdate|storiface.FTUpdateCache, storiface.PathSealing, storiface.AcquireCopy)) - if err2 != nil && !xerrors.Is(err, storiface.ErrSectorNotFound) { - return err - } + if err != nil && err2 != nil { - return xerrors.Errorf("cannot unseal piece. No sealed or updated sector found") + return xerrors.Errorf("cannot unseal piece. error fetching sealed data: %w. error fetching replica data: %w", err, err2) } return nil From 7e492f23b1cb3a1fdeba2d49bd99d8fdb0f0fcb1 Mon Sep 17 00:00:00 2001 From: LexLuthr Date: Thu, 12 May 2022 19:46:53 +0530 Subject: [PATCH 11/37] add dagstore register-shard command --- api/api_storage.go | 3 ++ api/proxy_gen.go | 13 ++++++++ cmd/lotus-miner/dagstore.go | 39 ++++++++++++++++++++++++ documentation/en/api-v0-methods-miner.md | 17 +++++++++++ node/impl/storminer.go | 32 +++++++++++++++++++ 5 files changed, 104 insertions(+) diff --git a/api/api_storage.go b/api/api_storage.go index 5785ede1f..9de54ff3e 100644 --- a/api/api_storage.go +++ b/api/api_storage.go @@ -227,6 +227,9 @@ type StorageMiner interface { // DagstoreGC runs garbage collection on the DAG store. DagstoreGC(ctx context.Context) ([]DagstoreShardResult, error) //perm:admin + // DagstoreRegisterShard registers a shard manually with dagstore with given pieceCID + DagstoreRegisterShard(ctx context.Context, key string) error //perm:admin + // IndexerAnnounceDeal informs indexer nodes that a new deal was received, // so they can download its index IndexerAnnounceDeal(ctx context.Context, proposalCid cid.Cid) error //perm:admin diff --git a/api/proxy_gen.go b/api/proxy_gen.go index 7542ac367..a40d665ce 100644 --- a/api/proxy_gen.go +++ b/api/proxy_gen.go @@ -663,6 +663,8 @@ type StorageMinerStruct struct { DagstoreRecoverShard func(p0 context.Context, p1 string) error `perm:"write"` + DagstoreRegisterShard func(p0 context.Context, p1 string) error `perm:"admin"` + DealsConsiderOfflineRetrievalDeals func(p0 context.Context) (bool, error) `perm:"admin"` DealsConsiderOfflineStorageDeals func(p0 context.Context) (bool, error) `perm:"admin"` @@ -3990,6 +3992,17 @@ func (s *StorageMinerStub) DagstoreRecoverShard(p0 context.Context, p1 string) e return ErrNotSupported } +func (s *StorageMinerStruct) DagstoreRegisterShard(p0 context.Context, p1 string) error { + if s.Internal.DagstoreRegisterShard == nil { + return ErrNotSupported + } + return s.Internal.DagstoreRegisterShard(p0, p1) +} + +func (s *StorageMinerStub) DagstoreRegisterShard(p0 context.Context, p1 string) error { + return ErrNotSupported +} + func (s *StorageMinerStruct) DealsConsiderOfflineRetrievalDeals(p0 context.Context) (bool, error) { if s.Internal.DealsConsiderOfflineRetrievalDeals == nil { return false, ErrNotSupported diff --git a/cmd/lotus-miner/dagstore.go b/cmd/lotus-miner/dagstore.go index b35dcbe50..0937f86b8 100644 --- a/cmd/lotus-miner/dagstore.go +++ b/cmd/lotus-miner/dagstore.go @@ -59,6 +59,45 @@ var dagstoreListShardsCmd = &cli.Command{ }, } +var dagstoreRegisterShardCmd = &cli.Command{ + Name: "register-shard", + ArgsUsage: "[key/pieceCID]", + Usage: "Register a shard", + Flags: []cli.Flag{ + &cli.BoolFlag{ + Name: "color", + Usage: "use color in display output", + DefaultText: "depends on output being a TTY", + }, + }, + Action: func(cctx *cli.Context) error { + if cctx.IsSet("color") { + color.NoColor = !cctx.Bool("color") + } + + if cctx.NArg() != 1 { + return fmt.Errorf("must provide a single shard key") + } + + marketsAPI, closer, err := lcli.GetMarketsAPI(cctx) + if err != nil { + return err + } + defer closer() + + ctx := lcli.ReqContext(cctx) + + shardKey := cctx.Args().First() + err = marketsAPI.DagstoreRegisterShard(ctx, shardKey) + if err != nil { + return err + } + + fmt.Println("Registered shard " + shardKey) + return nil + }, +} + var dagstoreInitializeShardCmd = &cli.Command{ Name: "initialize-shard", ArgsUsage: "[key]", diff --git a/documentation/en/api-v0-methods-miner.md b/documentation/en/api-v0-methods-miner.md index 7642efbee..5a01ab715 100644 --- a/documentation/en/api-v0-methods-miner.md +++ b/documentation/en/api-v0-methods-miner.md @@ -22,6 +22,7 @@ * [CreateBackup](#CreateBackup) * [Dagstore](#Dagstore) * [DagstoreGC](#DagstoreGC) + * [DagstoreRegisterShard] (#DagstoreRegisterShard) * [DagstoreInitializeAll](#DagstoreInitializeAll) * [DagstoreInitializeShard](#DagstoreInitializeShard) * [DagstoreListShards](#DagstoreListShards) @@ -509,6 +510,22 @@ Response: ] ``` +### DagstoreRegisterShard +DagstoreRegisterShard registers a shard with the dagstore. It takes +a PieceCID as input and generates a success or error message. + + +Perms: admin + +Inputs: +```json +[ + "string value" +] +``` + +Response: `{}` + ### DagstoreInitializeAll DagstoreInitializeAll initializes all uninitialized shards in bulk, according to the policy passed in the parameters. diff --git a/node/impl/storminer.go b/node/impl/storminer.go index f34761d89..eb8952004 100644 --- a/node/impl/storminer.go +++ b/node/impl/storminer.go @@ -37,8 +37,10 @@ import ( "github.com/filecoin-project/go-fil-markets/piecestore" "github.com/filecoin-project/go-fil-markets/retrievalmarket" "github.com/filecoin-project/go-fil-markets/storagemarket" + filmktsstore "github.com/filecoin-project/go-fil-markets/stores" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/network" + mktsdagstore "github.com/filecoin-project/lotus/markets/dagstore" sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage" "github.com/filecoin-project/lotus/extern/sector-storage/fsutil" @@ -83,6 +85,7 @@ type StorageMinerAPI struct { SectorBlocks *sectorblocks.SectorBlocks `optional:"true"` Host host.Host `optional:"true"` DAGStore *dagstore.DAGStore `optional:"true"` + DAGStoreWrapper *mktsdagstore.Wrapper `optional:"true"` // Miner / storage Miner *storage.Miner `optional:"true"` @@ -792,6 +795,35 @@ func (sm *StorageMinerAPI) DagstoreListShards(ctx context.Context) ([]api.Dagsto return ret, nil } +func (sm *StorageMinerAPI) DagstoreRegisterShard(ctx context.Context, key string) error { + if sm.DAGStore == nil { + return fmt.Errorf("dagstore not available on this node") + } + + // First check if the shard has already been registered + k := shard.KeyFromString(key) + _, err := sm.DAGStore.GetShardInfo(k) + if err == nil { + // Shard already registered, nothing further to do + return nil + } + // If the shard is not registered we would expect ErrShardUnknown + if !errors.Is(err, dagstore.ErrShardUnknown) { + return fmt.Errorf("getting shard info from DAG store: %w", err) + } + + pieceCid, err := cid.Parse(key) + if err != nil { + return fmt.Errorf("parsing shard key as piece cid: %w", err) + } + + if err = filmktsstore.RegisterShardSync(ctx, sm.DAGStoreWrapper, pieceCid, "", true); err != nil { + return fmt.Errorf("failed to register shard: %w", err) + } + + return nil +} + func (sm *StorageMinerAPI) DagstoreInitializeShard(ctx context.Context, key string) error { if sm.DAGStore == nil { return fmt.Errorf("dagstore not available on this node") From 4326fc370bbcd9e27cffd2b0a38d4f9a18645d46 Mon Sep 17 00:00:00 2001 From: LexLuthr Date: Fri, 13 May 2022 00:02:17 +0530 Subject: [PATCH 12/37] add the new subcommand --- cmd/lotus-miner/dagstore.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cmd/lotus-miner/dagstore.go b/cmd/lotus-miner/dagstore.go index 0937f86b8..37d048825 100644 --- a/cmd/lotus-miner/dagstore.go +++ b/cmd/lotus-miner/dagstore.go @@ -19,6 +19,7 @@ var dagstoreCmd = &cli.Command{ Usage: "Manage the dagstore on the markets subsystem", Subcommands: []*cli.Command{ dagstoreListShardsCmd, + dagstoreRegisterShardCmd, dagstoreInitializeShardCmd, dagstoreRecoverShardCmd, dagstoreInitializeAllCmd, @@ -61,7 +62,7 @@ var dagstoreListShardsCmd = &cli.Command{ var dagstoreRegisterShardCmd = &cli.Command{ Name: "register-shard", - ArgsUsage: "[key/pieceCID]", + ArgsUsage: "[key]", Usage: "Register a shard", Flags: []cli.Flag{ &cli.BoolFlag{ From 6115bd02f113500031203959421aafb67ecac202 Mon Sep 17 00:00:00 2001 From: LexLuthr Date: Fri, 13 May 2022 00:27:26 +0530 Subject: [PATCH 13/37] run make gen --- build/openrpc/full.json.gz | Bin 27588 -> 27589 bytes build/openrpc/miner.json.gz | Bin 13713 -> 13766 bytes build/openrpc/worker.json.gz | Bin 4614 -> 4613 bytes documentation/en/api-v0-methods-miner.md | 33 +++++++++++------------ 4 files changed, 16 insertions(+), 17 deletions(-) diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz index 92731a5f6c7916b672ed8af83b0118ad5784a7c6..5b8d28f20c18172e0ec82d43f2a529105777d724 100644 GIT binary patch delta 27004 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 YJ<)Ki=Zgpgj7 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 an|*zxJw1JW`u_m{0RR6+c_Q&$s{#P2S|4`+ diff --git a/build/openrpc/worker.json.gz b/build/openrpc/worker.json.gz index cbbeec7d1e462377c3359e18e508d684a9c23200..8e5a736f04ab2a8d5e79b30ff766ed19c6a8d365 100644 GIT binary patch delta 3760 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 delta 3761 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 Date: Fri, 13 May 2022 01:18:03 +0530 Subject: [PATCH 14/37] add new command to docs --- documentation/en/cli-lotus-miner.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index 5be59a1b6..e03ae7cc1 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -1035,6 +1035,7 @@ USAGE: COMMANDS: list-shards List all shards known to the dagstore, with their current status + register-shard Register a shard initialize-shard Initialize the specified shard recover-shard Attempt to recover a shard in errored state initialize-all Initialize all uninitialized shards, streaming results as they're produced; only shards for unsealed pieces are initialized by default @@ -1061,6 +1062,20 @@ OPTIONS: ``` +### lotus-miner dagstore register-shard +``` +NAME: + lotus-miner dagstore register-shard - Register a shard + +USAGE: + lotus-miner dagstore register-shard [command options] [key] + +OPTIONS: + --color use color in display output (default: depends on output being a TTY) + --help, -h show help (default: false) + +``` + ### lotus-miner dagstore initialize-shard ``` NAME: From 6b3bc8c9d2a806f8b87dcb7e72b0b6350e8de922 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Wed, 18 May 2022 12:19:27 +0200 Subject: [PATCH 15/37] feat: worker: lotus-worker run --no-default --- cmd/lotus-worker/main.go | 15 +++++++++++++-- documentation/en/cli-lotus-worker.md | 1 + 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/cmd/lotus-worker/main.go b/cmd/lotus-worker/main.go index 83c821105..f0fe993c7 100644 --- a/cmd/lotus-worker/main.go +++ b/cmd/lotus-worker/main.go @@ -182,12 +182,16 @@ var runCmd = &cli.Command{ Usage: "enable window post", Value: false, }, - &cli.BoolFlag{ Name: "winningpost", Usage: "enable winning post", Value: false, }, + &cli.BoolFlag{ + Name: "no-default", + Usage: "disable all default tasks, use the worker for storage only", + Value: false, + }, &cli.IntFlag{ Name: "parallel-fetch-limit", Usage: "maximum fetch operations to run in parallel", @@ -308,8 +312,11 @@ var runCmd = &cli.Command{ } if workerType == "" { - workerType = sealtasks.WorkerSealing taskTypes = append(taskTypes, sealtasks.TTFetch, sealtasks.TTCommit1, sealtasks.TTProveReplicaUpdate1, sealtasks.TTFinalize, sealtasks.TTFinalizeReplicaUpdate) + + if !cctx.Bool("no-default") { + workerType = sealtasks.WorkerSealing + } } if (workerType == sealtasks.WorkerSealing || cctx.IsSet("addpiece")) && cctx.Bool("addpiece") { @@ -337,6 +344,10 @@ var runCmd = &cli.Command{ taskTypes = append(taskTypes, sealtasks.TTRegenSectorKey) } + if cctx.Bool("no-default") && workerType == "" { + workerType = sealtasks.WorkerSealing + } + if len(taskTypes) == 0 { return xerrors.Errorf("no task types specified") } diff --git a/documentation/en/cli-lotus-worker.md b/documentation/en/cli-lotus-worker.md index 68d0d45c2..6624cfa9d 100644 --- a/documentation/en/cli-lotus-worker.md +++ b/documentation/en/cli-lotus-worker.md @@ -49,6 +49,7 @@ OPTIONS: --regen-sector-key enable regen sector key (default: true) --windowpost enable window post (default: false) --winningpost enable winning post (default: false) + --no-default disable all default tasks, use the worker for storage only (default: false) --parallel-fetch-limit value maximum fetch operations to run in parallel (default: 5) --post-parallel-reads value maximum number of parallel challenge reads (0 = no limit) (default: 128) --post-read-timeout value time limit for reading PoSt challenges (0 = no limit) (default: 0s) From 7c37451f48306839f4e3c6f0269ba2c88fe78112 Mon Sep 17 00:00:00 2001 From: zengroundumbass <105332265+zengroundumbass@users.noreply.github.com> Date: Fri, 20 May 2022 11:09:55 -0400 Subject: [PATCH 16/37] Fix inaccurate config comment --- documentation/en/default-lotus-miner-config.toml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/documentation/en/default-lotus-miner-config.toml b/documentation/en/default-lotus-miner-config.toml index 1e1b0369d..ef3b23b5c 100644 --- a/documentation/en/default-lotus-miner-config.toml +++ b/documentation/en/default-lotus-miner-config.toml @@ -444,12 +444,14 @@ # env var: LOTUS_SEALING_AGGREGATECOMMITS #AggregateCommits = true - # maximum batched commit size - batches will be sent immediately above this size + # minimum batched commit size - batches above this size will eventually be sent on a timeout # # type: int # env var: LOTUS_SEALING_MINCOMMITBATCH #MinCommitBatch = 4 + # maximum batched commit size - batches will be sent immediately above this size + # # type: int # env var: LOTUS_SEALING_MAXCOMMITBATCH #MaxCommitBatch = 819 From a9b40c448ba55939087e276ec6fc03073fcea264 Mon Sep 17 00:00:00 2001 From: Aayush Rajasekaran Date: Fri, 20 May 2022 13:38:23 -0400 Subject: [PATCH 17/37] verifreg: fix deprecation log --- cmd/lotus-shed/verifreg.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/cmd/lotus-shed/verifreg.go b/cmd/lotus-shed/verifreg.go index fb2598fda..7725b2f1b 100644 --- a/cmd/lotus-shed/verifreg.go +++ b/cmd/lotus-shed/verifreg.go @@ -193,7 +193,7 @@ var verifRegVerifyClientCmd = &cli.Command{ }, }, Action: func(cctx *cli.Context) error { - fmt.Println("DEPRECATED: This behavior is being moved to `lotus verifreg`") + fmt.Println("DEPRECATED: This behavior is being moved to `lotus filplus`") froms := cctx.String("from") if froms == "" { return fmt.Errorf("must specify from address with --from") @@ -262,7 +262,7 @@ var verifRegListVerifiersCmd = &cli.Command{ Usage: "list all verifiers", Hidden: true, Action: func(cctx *cli.Context) error { - fmt.Println("DEPRECATED: This behavior is being moved to `lotus verifreg`") + fmt.Println("DEPRECATED: This behavior is being moved to `lotus filplus`") api, closer, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err @@ -294,7 +294,7 @@ var verifRegListClientsCmd = &cli.Command{ Usage: "list all verified clients", Hidden: true, Action: func(cctx *cli.Context) error { - fmt.Println("DEPRECATED: This behavior is being moved to `lotus verifreg`") + fmt.Println("DEPRECATED: This behavior is being moved to `lotus filplus`") api, closer, err := lcli.GetFullNodeAPI(cctx) if err != nil { return err @@ -326,7 +326,7 @@ var verifRegCheckClientCmd = &cli.Command{ Usage: "check verified client remaining bytes", Hidden: true, Action: func(cctx *cli.Context) error { - fmt.Println("DEPRECATED: This behavior is being moved to `lotus verifreg`") + fmt.Println("DEPRECATED: This behavior is being moved to `lotus filplus`") if !cctx.Args().Present() { return fmt.Errorf("must specify client address to check") } @@ -362,7 +362,7 @@ var verifRegCheckVerifierCmd = &cli.Command{ Usage: "check verifiers remaining bytes", Hidden: true, Action: func(cctx *cli.Context) error { - fmt.Println("DEPRECATED: This behavior is being moved to `lotus verifreg`") + fmt.Println("DEPRECATED: This behavior is being moved to `lotus filplus`") if !cctx.Args().Present() { return fmt.Errorf("must specify verifier address to check") } From f491e39f22b0d654964180949f2a5bf9103efb27 Mon Sep 17 00:00:00 2001 From: Steven Allen Date: Fri, 20 May 2022 18:53:27 -0400 Subject: [PATCH 18/37] fix: vm: support raw blocks in chain export We need this for NV16 to include code in chain snapshots. NOTE: I've also checked the splitstore, and we appear to be doing the right thing there already. --- chain/store/snapshot.go | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/chain/store/snapshot.go b/chain/store/snapshot.go index b9630bcbd..07d086e1f 100644 --- a/chain/store/snapshot.go +++ b/chain/store/snapshot.go @@ -8,6 +8,7 @@ import ( "github.com/ipfs/go-cid" "github.com/ipld/go-car" carutil "github.com/ipld/go-car/util" + mh "github.com/multiformats/go-multihash" cbg "github.com/whyrusleeping/cbor-gen" "golang.org/x/xerrors" @@ -142,7 +143,18 @@ func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRe for _, c := range out { if seen.Visit(c) { - if c.Prefix().Codec != cid.DagCBOR { + prefix := c.Prefix() + + // Don't include identity CIDs. + if prefix.MhType == mh.IDENTITY { + continue + } + + // We only include raw and dagcbor, for now. + // Raw for "code" CIDs. + switch prefix.Codec { + case cid.Raw, cid.DagCBOR: + default: continue } From ea282ea0558aaf57d1524d15e114307405596fc0 Mon Sep 17 00:00:00 2001 From: swift-mx Date: Mon, 23 May 2022 12:54:00 +0800 Subject: [PATCH 19/37] feat: precommits info --- cmd/lotus-miner/precommits-info.go | 54 ++++++++++++++++++++++++++++++ cmd/lotus-miner/sectors.go | 1 + 2 files changed, 55 insertions(+) create mode 100644 cmd/lotus-miner/precommits-info.go diff --git a/cmd/lotus-miner/precommits-info.go b/cmd/lotus-miner/precommits-info.go new file mode 100644 index 000000000..9416e6f58 --- /dev/null +++ b/cmd/lotus-miner/precommits-info.go @@ -0,0 +1,54 @@ +package main + +import ( + "fmt" + "sort" + + "github.com/filecoin-project/lotus/blockstore" + "github.com/filecoin-project/lotus/chain/actors/builtin/miner" + "github.com/filecoin-project/lotus/chain/types" + lcli "github.com/filecoin-project/lotus/cli" + "github.com/filecoin-project/specs-actors/v7/actors/util/adt" + cbor "github.com/ipfs/go-ipld-cbor" + "github.com/urfave/cli/v2" +) + +var sectorPreCommitsCmd = &cli.Command{ + Name: "precommits-info", + Usage: "Print precommits info", + Action: func(cctx *cli.Context) error { + ctx := lcli.ReqContext(cctx) + mapi, closer, err := lcli.GetFullNodeAPI(cctx) + if err != nil { + return err + } + defer closer() + maddr, err := getActorAddress(ctx, cctx) + if err != nil { + return err + } + mact, err := mapi.StateGetActor(ctx, maddr, types.EmptyTSK) + if err != nil { + return err + } + store := adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewAPIBlockstore(mapi))) + mst, err := miner.Load(store, mact) + if err != nil { + return err + } + preCommitSector := make([]miner.SectorPreCommitOnChainInfo, 0) + err = mst.ForEachPrecommittedSector(func(info miner.SectorPreCommitOnChainInfo) error { + preCommitSector = append(preCommitSector, info) + return err + }) + less := func(i, j int) bool { + return preCommitSector[i].Info.SectorNumber <= preCommitSector[j].Info.SectorNumber + } + sort.Slice(preCommitSector, less) + for _, info := range preCommitSector { + fmt.Printf("%s: %s\n", info.Info.SectorNumber, info.PreCommitEpoch) + } + + return nil + }, +} diff --git a/cmd/lotus-miner/sectors.go b/cmd/lotus-miner/sectors.go index 1aa964f7e..0e9957528 100644 --- a/cmd/lotus-miner/sectors.go +++ b/cmd/lotus-miner/sectors.go @@ -45,6 +45,7 @@ var sectorsCmd = &cli.Command{ sectorsRefsCmd, sectorsUpdateCmd, sectorsPledgeCmd, + sectorPreCommitsCmd, sectorsCheckExpireCmd, sectorsExpiredCmd, sectorsRenewCmd, From 3ea55333a8d2a020bd9ef80d61953600a99c8d49 Mon Sep 17 00:00:00 2001 From: swift-mx Date: Mon, 23 May 2022 14:28:47 +0800 Subject: [PATCH 20/37] fix: docsgen-cli --- documentation/en/cli-lotus-miner.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index e03ae7cc1..d6f37861d 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -1667,6 +1667,7 @@ COMMANDS: refs List References to sectors update-state ADVANCED: manually update the state of a sector, this may aid in error recovery pledge store random data in a sector + precommits-info Print precommits info check-expire Inspect expiring sectors expired Get or cleanup expired sectors renew Renew expiring sectors while not exceeding each sector's max life @@ -1765,6 +1766,19 @@ OPTIONS: ``` +### lotus-miner sectors precommits-info +``` +NAME: + lotus-miner sectors precommits-info - Print precommits info + +USAGE: + lotus-miner sectors precommits-info [command options] [arguments...] + +OPTIONS: + --help, -h show help (default: false) + +``` + ### lotus-miner sectors check-expire ``` NAME: From 0b3ee32ce48ff981f4ed0204ef9bce2e8909cb38 Mon Sep 17 00:00:00 2001 From: swift-mx Date: Tue, 24 May 2022 00:11:59 +0800 Subject: [PATCH 21/37] Update cmd/lotus-miner/precommits-info.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Łukasz Magiera --- cmd/lotus-miner/precommits-info.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/lotus-miner/precommits-info.go b/cmd/lotus-miner/precommits-info.go index 9416e6f58..23616e895 100644 --- a/cmd/lotus-miner/precommits-info.go +++ b/cmd/lotus-miner/precommits-info.go @@ -14,7 +14,7 @@ import ( ) var sectorPreCommitsCmd = &cli.Command{ - Name: "precommits-info", + Name: "precommits", Usage: "Print precommits info", Action: func(cctx *cli.Context) error { ctx := lcli.ReqContext(cctx) From ae8f3d8fe2a7107b8213f01228f2057b580ed2b0 Mon Sep 17 00:00:00 2001 From: swift-mx Date: Tue, 24 May 2022 00:12:09 +0800 Subject: [PATCH 22/37] Update cmd/lotus-miner/precommits-info.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Łukasz Magiera --- cmd/lotus-miner/precommits-info.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/lotus-miner/precommits-info.go b/cmd/lotus-miner/precommits-info.go index 23616e895..e700859e9 100644 --- a/cmd/lotus-miner/precommits-info.go +++ b/cmd/lotus-miner/precommits-info.go @@ -15,7 +15,7 @@ import ( var sectorPreCommitsCmd = &cli.Command{ Name: "precommits", - Usage: "Print precommits info", + Usage: "Print on-chain precommit info", Action: func(cctx *cli.Context) error { ctx := lcli.ReqContext(cctx) mapi, closer, err := lcli.GetFullNodeAPI(cctx) From 23f9ac4c3c1b3c06a410b42a3e0cecf70ef3351f Mon Sep 17 00:00:00 2001 From: swift-mx Date: Tue, 24 May 2022 00:17:38 +0800 Subject: [PATCH 23/37] Update cli-lotus-miner.md --- documentation/en/cli-lotus-miner.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index d6f37861d..78f11e822 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -1667,7 +1667,7 @@ COMMANDS: refs List References to sectors update-state ADVANCED: manually update the state of a sector, this may aid in error recovery pledge store random data in a sector - precommits-info Print precommits info + precommits Print on-chain precommit info check-expire Inspect expiring sectors expired Get or cleanup expired sectors renew Renew expiring sectors while not exceeding each sector's max life @@ -1766,13 +1766,13 @@ OPTIONS: ``` -### lotus-miner sectors precommits-info +### lotus-miner sectors precommits ``` NAME: - lotus-miner sectors precommits-info - Print precommits info + lotus-miner sectors precommits - Print on-chain precommit info USAGE: - lotus-miner sectors precommits-info [command options] [arguments...] + lotus-miner sectors precommits [command options] [arguments...] OPTIONS: --help, -h show help (default: false) From 6216fae0f8dcf788142e501cd030a591efab358c Mon Sep 17 00:00:00 2001 From: Geoff Stuart Date: Tue, 10 May 2022 17:35:59 -0400 Subject: [PATCH 24/37] Implement cli command for compactPartitions --- cmd/lotus-miner/sectors.go | 87 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/cmd/lotus-miner/sectors.go b/cmd/lotus-miner/sectors.go index 1aa964f7e..b16137e8e 100644 --- a/cmd/lotus-miner/sectors.go +++ b/cmd/lotus-miner/sectors.go @@ -58,6 +58,7 @@ var sectorsCmd = &cli.Command{ sectorsCapacityCollateralCmd, sectorsBatching, sectorsRefreshPieceMatchingCmd, + sectorsCompactPartitionsCmd, }, } @@ -2088,3 +2089,89 @@ func yesno(b bool) string { } return color.RedString("NO") } + +var sectorsCompactPartitionsCmd = &cli.Command{ + Name: "compact-partitions", + Usage: "removes dead sectors from partitions and reduces the number of partitions used if possible", + Flags: []cli.Flag{ + &cli.Uint64Flag{ + Name: "deadline", + Usage: "the deadline to compact the partitions in", + Required: true, + }, + &cli.Int64SliceFlag{ + Name: "partitions", + Usage: "list of partitions to compact sectors in", + Required: true, + }, + &cli.BoolFlag{ + Name: "really-do-it", + Usage: "Actually send transaction performing the action", + Value: false, + }, + }, + Action: func(cctx *cli.Context) error { + if !cctx.Bool("really-do-it") { + fmt.Println("Pass --really-do-it to actually execute this action") + return nil + } + + api, acloser, err := lcli.GetFullNodeAPI(cctx) + if err != nil { + return err + } + defer acloser() + + ctx := lcli.ReqContext(cctx) + + maddr, err := getActorAddress(ctx, cctx) + if err != nil { + return err + } + + minfo, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK) + if err != nil { + return err + } + + deadline := cctx.Uint64("deadline") + if err != nil { + return err + } + + parts := cctx.Int64Slice("partitions") + if len(parts) <= 0 { + return fmt.Errorf("must include at least one partition to compact") + } + + partitions := bitfield.BitField{} + for _, partition := range parts { + partitions.Set(uint64(partition)) + } + + params := miner5.CompactPartitionsParams{ + Deadline: deadline, + Partitions: partitions, + } + + sp, err := actors.SerializeParams(¶ms) + if err != nil { + return xerrors.Errorf("serializing params: %w", err) + } + + smsg, err := api.MpoolPushMessage(ctx, &types.Message{ + From: minfo.Worker, + To: maddr, + Method: miner.Methods.CompactPartitions, + Value: big.Zero(), + Params: sp, + }, nil) + if err != nil { + return xerrors.Errorf("mpool push: %w", err) + } + + fmt.Println("Message CID:", smsg.Cid()) + + return nil + }, +} From d7bc0e8413196771bd936ed44aa91158266b0aec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Mon, 23 May 2022 18:25:51 +0200 Subject: [PATCH 25/37] make docsgen-cli --- documentation/en/cli-lotus-miner.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index e03ae7cc1..425fa9279 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -1680,6 +1680,7 @@ COMMANDS: get-cc-collateral Get the collateral required to pledge a committed capacity sector batching manage batch sector operations match-pending-pieces force a refreshed match of pending pieces to open sectors without manually waiting for more deals + compact-partitions removes dead sectors from partitions and reduces the number of partitions used if possible help, h Shows a list of commands or help for one command OPTIONS: @@ -2021,6 +2022,22 @@ OPTIONS: ``` +### lotus-miner sectors compact-partitions +``` +NAME: + lotus-miner sectors compact-partitions - removes dead sectors from partitions and reduces the number of partitions used if possible + +USAGE: + lotus-miner sectors compact-partitions [command options] [arguments...] + +OPTIONS: + --deadline value the deadline to compact the partitions in (default: 0) + --partitions value list of partitions to compact sectors in + --really-do-it Actually send transaction performing the action (default: false) + --help, -h show help (default: false) + +``` + ## lotus-miner proving ``` NAME: From 389df95b0045ffe346a14a5ecf3b0188ebc1ef3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Mon, 23 May 2022 18:49:01 +0200 Subject: [PATCH 26/37] config: Update batching comment in all the places --- node/config/doc_gen.go | 4 ++-- node/config/types.go | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/node/config/doc_gen.go b/node/config/doc_gen.go index cf51fb13e..757d80932 100644 --- a/node/config/doc_gen.go +++ b/node/config/doc_gen.go @@ -897,13 +897,13 @@ This is useful for forcing all deals to be assigned as snap deals to sectors mar Name: "MinCommitBatch", Type: "int", - Comment: `maximum batched commit size - batches will be sent immediately above this size`, + Comment: `minimum batched commit size - batches above this size will eventually be sent on a timeout`, }, { Name: "MaxCommitBatch", Type: "int", - Comment: ``, + Comment: `maximum batched commit size - batches will be sent immediately above this size`, }, { Name: "CommitBatchWait", diff --git a/node/config/types.go b/node/config/types.go index b5b1fae7e..1505ecb39 100644 --- a/node/config/types.go +++ b/node/config/types.go @@ -290,8 +290,9 @@ type SealingConfig struct { // enable / disable commit aggregation (takes effect after nv13) AggregateCommits bool - // maximum batched commit size - batches will be sent immediately above this size + // minimum batched commit size - batches above this size will eventually be sent on a timeout MinCommitBatch int + // maximum batched commit size - batches will be sent immediately above this size MaxCommitBatch int // how long to wait before submitting a batch after crossing the minimum batch size CommitBatchWait Duration From abf8316eda00bff42493c81e24c3dcb19a1c75f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Mon, 23 May 2022 18:52:40 +0200 Subject: [PATCH 27/37] worker: Less confusing usage on --no-default --- cmd/lotus-worker/main.go | 2 +- documentation/en/cli-lotus-worker.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/lotus-worker/main.go b/cmd/lotus-worker/main.go index f0fe993c7..8faabf70b 100644 --- a/cmd/lotus-worker/main.go +++ b/cmd/lotus-worker/main.go @@ -189,7 +189,7 @@ var runCmd = &cli.Command{ }, &cli.BoolFlag{ Name: "no-default", - Usage: "disable all default tasks, use the worker for storage only", + Usage: "disable all default compute tasks, use the worker for storage/fetching only", Value: false, }, &cli.IntFlag{ diff --git a/documentation/en/cli-lotus-worker.md b/documentation/en/cli-lotus-worker.md index 6624cfa9d..dbc5e40c4 100644 --- a/documentation/en/cli-lotus-worker.md +++ b/documentation/en/cli-lotus-worker.md @@ -49,7 +49,7 @@ OPTIONS: --regen-sector-key enable regen sector key (default: true) --windowpost enable window post (default: false) --winningpost enable winning post (default: false) - --no-default disable all default tasks, use the worker for storage only (default: false) + --no-default disable all default compute tasks, use the worker for storage/fetching only (default: false) --parallel-fetch-limit value maximum fetch operations to run in parallel (default: 5) --post-parallel-reads value maximum number of parallel challenge reads (0 = no limit) (default: 128) --post-read-timeout value time limit for reading PoSt challenges (0 = no limit) (default: 0s) From dbe146b0c950c48cfa80b1f1e31a862b4e20b00b Mon Sep 17 00:00:00 2001 From: jennijuju Date: Thu, 12 May 2022 15:16:48 -0400 Subject: [PATCH 28/37] bump the version to v1.15.4-rc1 --- build/openrpc/full.json.gz | Bin 27589 -> 27589 bytes build/openrpc/miner.json.gz | Bin 13766 -> 13766 bytes build/openrpc/worker.json.gz | Bin 4613 -> 4613 bytes build/version.go | 2 +- documentation/en/cli-lotus-miner.md | 2 +- documentation/en/cli-lotus-worker.md | 2 +- documentation/en/cli-lotus.md | 2 +- 7 files changed, 4 insertions(+), 4 deletions(-) diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz index 5b8d28f20c18172e0ec82d43f2a529105777d724..63589e07a49c0450a4727be53fa594f47bc9a01a 100644 GIT binary patch literal 27589 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 UuVg>|3jhHB|KG;TbyQ*n0M^`zH~;_u literal 27589 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 delta 21 dcmX?>eJp!IJEPpj4l`4ZJ!PHKmab!B003%(2@~ delta 21 ccmZowX;qof!nkE)YlR?(?46Fq2lyEo09&~S*8l(j diff --git a/build/version.go b/build/version.go index ff1b55fa7..24da6355e 100644 --- a/build/version.go +++ b/build/version.go @@ -37,7 +37,7 @@ func BuildTypeString() string { } // BuildVersion is the local build version -const BuildVersion = "1.15.3-dev" +const BuildVersion = "1.15.4-dev" func UserVersion() string { if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" { diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index e03ae7cc1..a28702487 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -7,7 +7,7 @@ USAGE: lotus-miner [global options] command [command options] [arguments...] VERSION: - 1.15.3-dev + 1.15.4-dev COMMANDS: init Initialize a lotus miner repo diff --git a/documentation/en/cli-lotus-worker.md b/documentation/en/cli-lotus-worker.md index 68d0d45c2..708b82178 100644 --- a/documentation/en/cli-lotus-worker.md +++ b/documentation/en/cli-lotus-worker.md @@ -7,7 +7,7 @@ USAGE: lotus-worker [global options] command [command options] [arguments...] VERSION: - 1.15.3-dev + 1.15.4-dev COMMANDS: run Start lotus worker diff --git a/documentation/en/cli-lotus.md b/documentation/en/cli-lotus.md index 9a87a5008..d1f798f5f 100644 --- a/documentation/en/cli-lotus.md +++ b/documentation/en/cli-lotus.md @@ -7,7 +7,7 @@ USAGE: lotus [global options] command [command options] [arguments...] VERSION: - 1.15.3-dev + 1.15.4-dev COMMANDS: daemon Start a lotus daemon process From 38bce53e1881c714cc7a1c121df49f7d7a0795fd Mon Sep 17 00:00:00 2001 From: Jennifer Wang Date: Mon, 23 May 2022 13:49:28 -0400 Subject: [PATCH 29/37] update to the latest golibp2p tag --- go.mod | 8 ++++---- go.sum | 13 ++++++++----- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/go.mod b/go.mod index e11e69a80..dc25cfa19 100644 --- a/go.mod +++ b/go.mod @@ -41,7 +41,7 @@ require ( github.com/filecoin-project/go-legs v0.3.7 github.com/filecoin-project/go-padreader v0.0.1 github.com/filecoin-project/go-paramfetch v0.0.4 - github.com/filecoin-project/go-state-types v0.1.3 + github.com/filecoin-project/go-state-types v0.1.4 github.com/filecoin-project/go-statemachine v1.0.2 github.com/filecoin-project/go-statestore v0.2.0 github.com/filecoin-project/go-storedcounter v0.1.0 @@ -109,7 +109,7 @@ require ( github.com/koalacxr/quantile v0.0.1 github.com/libp2p/go-buffer-pool v0.0.2 github.com/libp2p/go-eventbus v0.2.1 - github.com/libp2p/go-libp2p v0.19.0 + github.com/libp2p/go-libp2p v0.19.3 github.com/libp2p/go-libp2p-connmgr v0.3.1 github.com/libp2p/go-libp2p-core v0.15.1 github.com/libp2p/go-libp2p-discovery v0.6.0 @@ -145,7 +145,7 @@ require ( github.com/syndtr/goleveldb v1.0.0 github.com/urfave/cli/v2 v2.3.0 github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba - github.com/whyrusleeping/cbor-gen v0.0.0-20220302191723-37c43cae8e14 + github.com/whyrusleeping/cbor-gen v0.0.0-20220323183124-98fa8256a799 github.com/whyrusleeping/ledger-filecoin-go v0.9.1-0.20201010031517-c3dcc1bddce4 github.com/whyrusleeping/multiaddr-filter v0.0.0-20160516205228-e903e4adabd7 github.com/xorcare/golden v0.6.1-0.20191112154924-b87f686d7542 @@ -277,7 +277,7 @@ require ( github.com/libp2p/go-tcp-transport v0.5.1 // indirect github.com/libp2p/go-ws-transport v0.6.0 // indirect github.com/libp2p/go-yamux/v3 v3.1.1 // indirect - github.com/lucas-clemente/quic-go v0.27.0 // indirect + github.com/lucas-clemente/quic-go v0.27.1 // indirect github.com/lucasb-eyer/go-colorful v1.0.3 // indirect github.com/magefile/mage v1.9.0 // indirect github.com/mailru/easyjson v0.7.6 // indirect diff --git a/go.sum b/go.sum index 5112c7bd3..56211d9df 100644 --- a/go.sum +++ b/go.sum @@ -368,8 +368,9 @@ github.com/filecoin-project/go-state-types v0.0.0-20201102161440-c8033295a1fc/go github.com/filecoin-project/go-state-types v0.1.0/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g= github.com/filecoin-project/go-state-types v0.1.1-0.20210810190654-139e0e79e69e/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g= github.com/filecoin-project/go-state-types v0.1.1/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g= -github.com/filecoin-project/go-state-types v0.1.3 h1:rzIJyQo5HO2ptc8Jcu8P0qTutnI7NWwTle54eAHoNO0= github.com/filecoin-project/go-state-types v0.1.3/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g= +github.com/filecoin-project/go-state-types v0.1.4 h1:NU0veVNxtDiLD/eRyKHV9lv3njSzfTh/sJGxxvcYcpg= +github.com/filecoin-project/go-state-types v0.1.4/go.mod h1:xCA/WfKlC2zcn3fUmDv4IrzznwS98X5XW/irUP3Lhxg= github.com/filecoin-project/go-statemachine v0.0.0-20200925024713-05bd7c71fbfe/go.mod h1:FGwQgZAt2Gh5mjlwJUlVB62JeYdo+if0xWxSEfBD9ig= github.com/filecoin-project/go-statemachine v1.0.1/go.mod h1:jZdXXiHa61n4NmgWFG4w8tnqgvZVHYbJ3yW7+y8bF54= github.com/filecoin-project/go-statemachine v1.0.2-0.20220322104818-27f8fbb86dfd/go.mod h1:jZdXXiHa61n4NmgWFG4w8tnqgvZVHYbJ3yW7+y8bF54= @@ -1086,8 +1087,8 @@ github.com/libp2p/go-libp2p v0.16.0/go.mod h1:ump42BsirwAWxKzsCiFnTtN1Yc+DuPu76f github.com/libp2p/go-libp2p v0.17.0/go.mod h1:Fkin50rsGdv5mm5BshBUtPRZknt9esfmYXBOYcwOTgw= github.com/libp2p/go-libp2p v0.18.0-rc1/go.mod h1:RgYlH7IIWHXREimC92bw5Lg1V2R5XmSzuLHb5fTnr+8= github.com/libp2p/go-libp2p v0.18.0-rc3/go.mod h1:WYL+Xw1iuwi6rdfzw5VIEpD+HqzYucHZ6fcUuumbI3M= -github.com/libp2p/go-libp2p v0.19.0 h1:zosskMbaobL7UDCVLEe1m5CGs1TaFNFoN/M5XLiKg0U= -github.com/libp2p/go-libp2p v0.19.0/go.mod h1:Ki9jJXLO2YqrTIFxofV7Twyd3INWPT97+r8hGt7XPjI= +github.com/libp2p/go-libp2p v0.19.3 h1:LqjvuBWdyYSqvkH4VVYxA78Fkphzg2Pq86VMnilqgkw= +github.com/libp2p/go-libp2p v0.19.3/go.mod h1:AGlPVLjh0+6jvEtf+a2gZEux7yHJrYXnG9IC7wcQ2NY= github.com/libp2p/go-libp2p-asn-util v0.0.0-20200825225859-85005c6cf052/go.mod h1:nRMRTab+kZuk0LnKZpxhOVH/ndsdr2Nr//Zltc/vwgo= github.com/libp2p/go-libp2p-asn-util v0.1.0 h1:rABPCO77SjdbJ/eJ/ynIo8vWICy1VEnL5JAxJbQLo1E= github.com/libp2p/go-libp2p-asn-util v0.1.0/go.mod h1:wu+AnM9Ii2KgO5jMmS1rz9dvzTdj8BXqsPR9HR0XB7I= @@ -1457,8 +1458,9 @@ github.com/lucas-clemente/quic-go v0.21.2/go.mod h1:vF5M1XqhBAHgbjKcJOXY3JZz3GP0 github.com/lucas-clemente/quic-go v0.23.0/go.mod h1:paZuzjXCE5mj6sikVLMvqXk8lJV2AsqtJ6bDhjEfxx0= github.com/lucas-clemente/quic-go v0.24.0/go.mod h1:paZuzjXCE5mj6sikVLMvqXk8lJV2AsqtJ6bDhjEfxx0= github.com/lucas-clemente/quic-go v0.25.0/go.mod h1:YtzP8bxRVCBlO77yRanE264+fY/T2U9ZlW1AaHOsMOg= -github.com/lucas-clemente/quic-go v0.27.0 h1:v6WY87q9zD4dKASbG8hy/LpzAVNzEQzw8sEIeloJsc4= github.com/lucas-clemente/quic-go v0.27.0/go.mod h1:AzgQoPda7N+3IqMMMkywBKggIFo2KT6pfnlrQ2QieeI= +github.com/lucas-clemente/quic-go v0.27.1 h1:sOw+4kFSVrdWOYmUjufQ9GBVPqZ+tu+jMtXxXNmRJyk= +github.com/lucas-clemente/quic-go v0.27.1/go.mod h1:AzgQoPda7N+3IqMMMkywBKggIFo2KT6pfnlrQ2QieeI= github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac= github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/lufia/iostat v1.1.0/go.mod h1:rEPNA0xXgjHQjuI5Cy05sLlS2oRcSlWHRLrvh/AQ+Pg= @@ -1981,8 +1983,9 @@ github.com/whyrusleeping/cbor-gen v0.0.0-20210219115102-f37d292932f2/go.mod h1:f github.com/whyrusleeping/cbor-gen v0.0.0-20210303213153-67a261a1d291/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ= github.com/whyrusleeping/cbor-gen v0.0.0-20210713220151-be142a5ae1a8/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ= github.com/whyrusleeping/cbor-gen v0.0.0-20220224212727-7a699437a831/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ= -github.com/whyrusleeping/cbor-gen v0.0.0-20220302191723-37c43cae8e14 h1:vo2wkP2ceHyGyZwFFtAabpot03EeSxxwAe57pOI9E/4= github.com/whyrusleeping/cbor-gen v0.0.0-20220302191723-37c43cae8e14/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ= +github.com/whyrusleeping/cbor-gen v0.0.0-20220323183124-98fa8256a799 h1:DOOT2B85S0tHoLGTzV+FakaSSihgRCVwZkjqKQP5L/w= +github.com/whyrusleeping/cbor-gen v0.0.0-20220323183124-98fa8256a799/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ= github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f h1:jQa4QT2UP9WYv2nzyawpKMOCl+Z/jW7djv2/J50lj9E= github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8= github.com/whyrusleeping/go-ctrlnet v0.0.0-20180313164037-f564fbbdaa95/go.mod h1:SJqKCCPXRfBFCwXjfNT/skfsceF7+MBFLI2OrvuRA7g= From f2d09b65ccfcc6ca235416627d69875fb8e61a66 Mon Sep 17 00:00:00 2001 From: Travis Person Date: Mon, 23 May 2022 18:55:22 +0000 Subject: [PATCH 30/37] fix: deps: restore butterfly network genesis from v1.14.4 --- build/genesis/butterflynet.car | Bin 2185801 -> 2185803 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/build/genesis/butterflynet.car b/build/genesis/butterflynet.car index c79eab38eb96c401356d80105c4479513ddf4e2f..6ef5243beb1f3416cba583f129a3944535cd3338 100644 GIT binary patch delta 2184 zcmb7^do+}J7{})>gG_ESgVAWzv|VV&B_X%P<}!vdZfObQ(pqv$MNKne zopNj3a&n8=A*zjHLYNqXLb|ZncjWBZKRV6&PoZs*HzR&wS&-dX~B!T$=87lPa z!hRSRqTFN^5Wc}AqBu_7spIjN`=4mV{m&>LjSoBxK1Pd*4vh#0mqNgig(DEWw15n2 z5QyQ4-n}0~gQpwpoNw>xv$TxlC!aR6YG;Bh8BCBTo8yHyRo_+T zsNm!>+AP9F-Q-)d86H1Fi!+opFAymX9VqIq<;X+z@lr4OLX+@t zL?WeY+b}x&uS%p&_?&dA*cP8G*8ipWc3JcHA znz_x=#RN>?bmPF6&SPnu5||-=kCxrr9?Q=*xI-eiLoU+sO`pR0&vRq$heW#i&fEjS zawz;77>}`^ozqG0^&6Tb=g1mrF6X`uQFe+2?d@wBav(hK|Fygo5d_BX_EG1{4JM5@ z&HGtcw77Epsr46d$UF6W(#?aykg2^K^12>;sdZ7cZ6v={SoVduVA4isqBV{qDqQ!Q zz9Jbd)h;G*Y-IKEM3IsK`qpi>|6(fIUoWqSATM)D7*Z7gFW4-D)}6NCWCNF$BL2KG z;eo)4=;Z_F>MQ3g5sRQ_(eYWchuMYis(h)OaoMeS6OtiZ%a$58o~7GSzO$3)Pgu^# z8+%$qjn16I#gI=Xl8`JC5)1(0l9157QSQ=e%kcaW%7)+8w}N#saAW~}=978a+icy0 zA#zjA$429X$k?T+!A28RENI#6-bIaQH4;nZ4TNI^+rknjKmlL?aIQE3u^3L5)*}WL zT$}bB8?2?vdvx|*vVG-{+wUD#0`IQ_C9QdqR2d5%mRq#<=GYC@6m;o$A9N!;y1zME zP}=VDo?)ZR>gcqsqT z!`Ke}MLzNNGL@COJM>Qt#_Uw#mE?v+JLaTNF7~A!31=D4AOK_l)&a-@AOYk6A~H z9^k&oh`*2!X5HplLJ= zY8=fHgvvQhw{D8?!$L(2CQzaWb$?{#8;mQgt1#A1xq4#;#Jt8#(zIn?eBprd!I$y#myC>*ks||g5R33&>z) z`Hn_3pUA&H5I^f0o{WW#Nj}E(I`OcKHW_aSuHJYqpVN~zk=fI8sqOu+PRJcWaPQPU z1yo3!VYvfuNw8C3{t|%+T1nrp%g(~!d4aP>WD2sv+^^f0%*R5-lA}OlIEq~Msv22c z!alaiah5a^e+6p_9bfsiwRRs9%wT4_Oe4_rBP;PGOu-q&h5^*Bijj;-mPgI?(id%= z`?>C!t?Alu8Vbd~)xda?6IUHt$5yYkHY>mcN>X~aVOf~+le`{UM`Toew4rRFC*uwl zI=Q0wKW*vruP-s7D{3UY3om7 ztF;zpbsI=qni6UHTIX?9TiULbXcrHN)jpLyY$IwLZ4MxjNxhK=>g-yS>ab_ia>fdZ z#}+g+@6x?2DWngo^QVQ4w?t delta 2186 zcmbW1c{tR09LMJ}ra_Y<%}DwYiJqLTqaq<}SS_hBWi4x*<7Ojc$IM_PLPI1W<%r18 zt}AD0LOCWiIXWnIFldn!vA@9|`$tdnw12#Q&+mDD-_QH|{(Y{_yRp!AkQ5n8TzkbA zNU_xFAF>Ch=_uvqfjjyvvQ^7@@`An|)33h6^LJu!h*S$<%l1EO8e4cZEM9V-W_SE4+ipE!W5VuadETBxe;f^sb8VOiJ;od09mIM45HpfhsoA0}60c0at|?WU6|U?d4Z1 zOT2<-{Pxu1#NL8SaqXzmKYwQ0qPW0n+K+GFwKOH;CI>u?tTGoZx0F~Nb?Kb!D$;f6 z+Bdq$G~c8PRE%N{ubB47KtAg%?&T(=m>J-qGnn5@uoCtf zuJcLh@jLdD3=U#SGIb*BlNSFt>c*P!W=?F{1H9f}6R~qn{7d{pzWUs5&YOXXf_a%I zDV90!uhO0OQakB7Xoe0N3IeOvLBoxLPYTN|6|W6X@%yVT(vbSmYdp!ANu^nj0V*j| zVI?PK4>Cvj0aM|n-KMHM{-s?Zca>hXlH)svVN5;5ZpI`T4uSv?sh%VwzxY#x)rjf{ zwJzHi&{VE`r2nen-+Avu*efJ#8DYJlgcVO`d zZ;-uLJ0snYgLb-$xld`u!(I-!h{>@ozo zvoij5^HUN^uBAUcI8^kB^M2ZGDxOm}9&Od5v?@KOImR%UMS_Tepg=Z(ph3hy#6cuL zHiKY5wtz^2NP$R$$bf9EHkg$i4WtO`Gx~pK?vTkHmTGCjFDjhOMxU$h5iy2S_4u7DzLPCMcc0K&AbUcEEbmXpS&M z!>;FP+A;%k2MpWdXJsQkk=h$^aGpT0=rhlHdoGOI(B_xsJpELZ!OA+a_^6k0emc7F zI)%ltS&TbQZ3sOvl->F`p{Syw2@5?J_F5}>Q!6#qq zoAZ{1*Bs>*UicCKjbs&L4KWH1J}K}&5cApcPSK2hQ$V`%=}2VStp$fA9DH2h|9cw) z>$xVFQsKqs$5St(&pamkz2(?i*iGT!Q{YuIQKgwH5?n?7^hIw|v-|}9Si*5V9DHIu z`!2nY^lSZc*-Odc$Fx7h%tb{p#%fa@H95rI-fddM!u0s%MyUpM_Zd4IymZtdV!f!e zjN|_xx7quEzxdVp!V=b$zd1W!867NbI zuatgc7YJLK0%=OhccyAXTiB)*XeZJNZd|h?Xw~c&Y0MtJ71kT--I*zwIs$usu8o)9 z=qazO7DDj}&rr@k+$Lk8T(M_ETiAjYXn${8%R?O@;vU{4O+C$E;#t>V_lL~ From 5cfedacf9fbe0de4585d3730f6577feaad124086 Mon Sep 17 00:00:00 2001 From: Jennifer Wang Date: Mon, 23 May 2022 15:11:46 -0400 Subject: [PATCH 31/37] make jen --- api/cbor_gen.go | 294 ++++++----- chain/exchange/cbor_gen.go | 168 +++--- chain/market/cbor_gen.go | 38 +- chain/types/cbor_gen.go | 541 +++++++++++--------- chain/vm/cbor_gen.go | 48 +- cmd/lotus-shed/shedgen/cbor_gen.go | 32 +- conformance/chaos/cbor_gen.go | 312 ++++++----- extern/sector-storage/cbor_gen.go | 144 +++--- extern/sector-storage/storiface/cbor_gen.go | 38 +- extern/storage-sealing/cbor_gen.go | 400 ++++++++------- node/hello/cbor_gen.go | 74 +-- paychmgr/cbor_gen.go | 214 ++++---- 12 files changed, 1298 insertions(+), 1005 deletions(-) diff --git a/api/cbor_gen.go b/api/cbor_gen.go index eb4c34f8a..62e523df1 100644 --- a/api/cbor_gen.go +++ b/api/cbor_gen.go @@ -26,25 +26,26 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{163}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{163}); err != nil { return err } - scratch := make([]byte, 9) - // t.Channel (address.Address) (struct) if len("Channel") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Channel\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Channel"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Channel"))); err != nil { return err } if _, err := io.WriteString(w, string("Channel")); err != nil { return err } - if err := t.Channel.MarshalCBOR(w); err != nil { + if err := t.Channel.MarshalCBOR(cw); err != nil { return err } @@ -53,14 +54,14 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"WaitSentinel\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil { return err } if _, err := io.WriteString(w, string("WaitSentinel")); err != nil { return err } - if err := cbg.WriteCidBuf(scratch, w, t.WaitSentinel); err != nil { + if err := cbg.WriteCid(cw, t.WaitSentinel); err != nil { return xerrors.Errorf("failed to write cid field t.WaitSentinel: %w", err) } @@ -69,7 +70,7 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Vouchers\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Vouchers"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Vouchers"))); err != nil { return err } if _, err := io.WriteString(w, string("Vouchers")); err != nil { @@ -80,27 +81,32 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Vouchers was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Vouchers))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Vouchers))); err != nil { return err } for _, v := range t.Vouchers { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } return nil } -func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error { +func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) (err error) { *t = PaymentInfo{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -115,7 +121,7 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -129,7 +135,7 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.Channel.UnmarshalCBOR(br); err != nil { + if err := t.Channel.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Channel: %w", err) } @@ -139,7 +145,7 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.WaitSentinel: %w", err) } @@ -150,7 +156,7 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error { // t.Vouchers ([]*paych.SignedVoucher) (slice) case "Vouchers": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -170,7 +176,7 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v paych.SignedVoucher - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -190,25 +196,26 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{163}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{163}); err != nil { return err } - scratch := make([]byte, 9) - // t.SectorID (abi.SectorNumber) (uint64) if len("SectorID") > cbg.MaxLength { return xerrors.Errorf("Value in field \"SectorID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SectorID"))); err != nil { return err } if _, err := io.WriteString(w, string("SectorID")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorID)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.SectorID)); err != nil { return err } @@ -217,14 +224,14 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Offset\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Offset"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Offset"))); err != nil { return err } if _, err := io.WriteString(w, string("Offset")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Offset)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Offset)); err != nil { return err } @@ -233,30 +240,35 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Size\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Size"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Size"))); err != nil { return err } if _, err := io.WriteString(w, string("Size")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Size)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { return err } return nil } -func (t *SealedRef) UnmarshalCBOR(r io.Reader) error { +func (t *SealedRef) UnmarshalCBOR(r io.Reader) (err error) { *t = SealedRef{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -271,7 +283,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -285,7 +297,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -300,7 +312,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -315,7 +327,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -339,18 +351,19 @@ func (t *SealedRefs) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{161}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{161}); err != nil { return err } - scratch := make([]byte, 9) - // t.Refs ([]api.SealedRef) (slice) if len("Refs") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Refs\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Refs"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Refs"))); err != nil { return err } if _, err := io.WriteString(w, string("Refs")); err != nil { @@ -361,27 +374,32 @@ func (t *SealedRefs) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Refs was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Refs))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Refs))); err != nil { return err } for _, v := range t.Refs { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } return nil } -func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error { +func (t *SealedRefs) UnmarshalCBOR(r io.Reader) (err error) { *t = SealedRefs{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -396,7 +414,7 @@ func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -408,7 +426,7 @@ func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error { // t.Refs ([]api.SealedRef) (slice) case "Refs": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -428,7 +446,7 @@ func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v SealedRef - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -448,18 +466,19 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{162}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { return err } - scratch := make([]byte, 9) - // t.Value (abi.SealRandomness) (slice) if len("Value") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Value\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Value"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Value"))); err != nil { return err } if _, err := io.WriteString(w, string("Value")); err != nil { @@ -470,11 +489,11 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Value was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Value))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Value))); err != nil { return err } - if _, err := w.Write(t.Value[:]); err != nil { + if _, err := cw.Write(t.Value[:]); err != nil { return err } @@ -483,7 +502,7 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Epoch\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Epoch"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Epoch"))); err != nil { return err } if _, err := io.WriteString(w, string("Epoch")); err != nil { @@ -491,27 +510,32 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error { } if t.Epoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil { return err } } return nil } -func (t *SealTicket) UnmarshalCBOR(r io.Reader) error { +func (t *SealTicket) UnmarshalCBOR(r io.Reader) (err error) { *t = SealTicket{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -526,7 +550,7 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -538,7 +562,7 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) error { // t.Value (abi.SealRandomness) (slice) case "Value": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -554,13 +578,13 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) error { t.Value = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Value[:]); err != nil { + if _, err := io.ReadFull(cr, t.Value[:]); err != nil { return err } // t.Epoch (abi.ChainEpoch) (int64) case "Epoch": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -597,18 +621,19 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{162}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { return err } - scratch := make([]byte, 9) - // t.Value (abi.InteractiveSealRandomness) (slice) if len("Value") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Value\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Value"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Value"))); err != nil { return err } if _, err := io.WriteString(w, string("Value")); err != nil { @@ -619,11 +644,11 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Value was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Value))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Value))); err != nil { return err } - if _, err := w.Write(t.Value[:]); err != nil { + if _, err := cw.Write(t.Value[:]); err != nil { return err } @@ -632,7 +657,7 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Epoch\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Epoch"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Epoch"))); err != nil { return err } if _, err := io.WriteString(w, string("Epoch")); err != nil { @@ -640,27 +665,32 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error { } if t.Epoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil { return err } } return nil } -func (t *SealSeed) UnmarshalCBOR(r io.Reader) error { +func (t *SealSeed) UnmarshalCBOR(r io.Reader) (err error) { *t = SealSeed{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -675,7 +705,7 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -687,7 +717,7 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) error { // t.Value (abi.InteractiveSealRandomness) (slice) case "Value": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -703,13 +733,13 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) error { t.Value = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Value[:]); err != nil { + if _, err := io.ReadFull(cr, t.Value[:]); err != nil { return err } // t.Epoch (abi.ChainEpoch) (int64) case "Epoch": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -746,18 +776,19 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{165}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{165}); err != nil { return err } - scratch := make([]byte, 9) - // t.PublishCid (cid.Cid) (struct) if len("PublishCid") > cbg.MaxLength { return xerrors.Errorf("Value in field \"PublishCid\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PublishCid"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PublishCid"))); err != nil { return err } if _, err := io.WriteString(w, string("PublishCid")); err != nil { @@ -765,11 +796,11 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { } if t.PublishCid == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.PublishCid); err != nil { + if err := cbg.WriteCid(cw, *t.PublishCid); err != nil { return xerrors.Errorf("failed to write cid field t.PublishCid: %w", err) } } @@ -779,14 +810,14 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"DealID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealID"))); err != nil { return err } if _, err := io.WriteString(w, string("DealID")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.DealID)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.DealID)); err != nil { return err } @@ -795,14 +826,14 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"DealProposal\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealProposal"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealProposal"))); err != nil { return err } if _, err := io.WriteString(w, string("DealProposal")); err != nil { return err } - if err := t.DealProposal.MarshalCBOR(w); err != nil { + if err := t.DealProposal.MarshalCBOR(cw); err != nil { return err } @@ -811,14 +842,14 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"DealSchedule\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealSchedule"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealSchedule"))); err != nil { return err } if _, err := io.WriteString(w, string("DealSchedule")); err != nil { return err } - if err := t.DealSchedule.MarshalCBOR(w); err != nil { + if err := t.DealSchedule.MarshalCBOR(cw); err != nil { return err } @@ -827,7 +858,7 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"KeepUnsealed\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("KeepUnsealed"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("KeepUnsealed"))); err != nil { return err } if _, err := io.WriteString(w, string("KeepUnsealed")); err != nil { @@ -840,16 +871,21 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error { return nil } -func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { +func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) (err error) { *t = PieceDealInfo{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -864,7 +900,7 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -878,16 +914,16 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.PublishCid: %w", err) } @@ -901,7 +937,7 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -916,16 +952,16 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.DealProposal = new(market.DealProposal) - if err := t.DealProposal.UnmarshalCBOR(br); err != nil { + if err := t.DealProposal.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.DealProposal pointer: %w", err) } } @@ -936,7 +972,7 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.DealSchedule.UnmarshalCBOR(br); err != nil { + if err := t.DealSchedule.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.DealSchedule: %w", err) } @@ -944,7 +980,7 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) error { // t.KeepUnsealed (bool) (bool) case "KeepUnsealed": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -973,18 +1009,19 @@ func (t *DealSchedule) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{162}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { return err } - scratch := make([]byte, 9) - // t.StartEpoch (abi.ChainEpoch) (int64) if len("StartEpoch") > cbg.MaxLength { return xerrors.Errorf("Value in field \"StartEpoch\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("StartEpoch"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("StartEpoch"))); err != nil { return err } if _, err := io.WriteString(w, string("StartEpoch")); err != nil { @@ -992,11 +1029,11 @@ func (t *DealSchedule) MarshalCBOR(w io.Writer) error { } if t.StartEpoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.StartEpoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.StartEpoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.StartEpoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.StartEpoch-1)); err != nil { return err } } @@ -1006,7 +1043,7 @@ func (t *DealSchedule) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"EndEpoch\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("EndEpoch"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("EndEpoch"))); err != nil { return err } if _, err := io.WriteString(w, string("EndEpoch")); err != nil { @@ -1014,27 +1051,32 @@ func (t *DealSchedule) MarshalCBOR(w io.Writer) error { } if t.EndEpoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.EndEpoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.EndEpoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.EndEpoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.EndEpoch-1)); err != nil { return err } } return nil } -func (t *DealSchedule) UnmarshalCBOR(r io.Reader) error { +func (t *DealSchedule) UnmarshalCBOR(r io.Reader) (err error) { *t = DealSchedule{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -1049,7 +1091,7 @@ func (t *DealSchedule) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -1061,7 +1103,7 @@ func (t *DealSchedule) UnmarshalCBOR(r io.Reader) error { // t.StartEpoch (abi.ChainEpoch) (int64) case "StartEpoch": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1087,7 +1129,7 @@ func (t *DealSchedule) UnmarshalCBOR(r io.Reader) error { // t.EndEpoch (abi.ChainEpoch) (int64) case "EndEpoch": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err diff --git a/chain/exchange/cbor_gen.go b/chain/exchange/cbor_gen.go index 7a8597fd0..9c7f68ab8 100644 --- a/chain/exchange/cbor_gen.go +++ b/chain/exchange/cbor_gen.go @@ -26,51 +26,57 @@ func (t *Request) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufRequest); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufRequest); err != nil { return err } - scratch := make([]byte, 9) - // t.Head ([]cid.Cid) (slice) if len(t.Head) > cbg.MaxLength { return xerrors.Errorf("Slice value in field t.Head was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Head))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Head))); err != nil { return err } for _, v := range t.Head { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.Head: %w", err) } } // t.Length (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Length)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Length)); err != nil { return err } // t.Options (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Options)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Options)); err != nil { return err } return nil } -func (t *Request) UnmarshalCBOR(r io.Reader) error { +func (t *Request) UnmarshalCBOR(r io.Reader) (err error) { *t = Request{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -81,7 +87,7 @@ func (t *Request) UnmarshalCBOR(r io.Reader) error { // t.Head ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -100,7 +106,7 @@ func (t *Request) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.Head failed: %w", err) } @@ -111,7 +117,7 @@ func (t *Request) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -125,7 +131,7 @@ func (t *Request) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -145,15 +151,16 @@ func (t *Response) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufResponse); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufResponse); err != nil { return err } - scratch := make([]byte, 9) - // t.Status (exchange.status) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Status)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Status)); err != nil { return err } @@ -162,7 +169,7 @@ func (t *Response) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.ErrorMessage was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.ErrorMessage))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ErrorMessage))); err != nil { return err } if _, err := io.WriteString(w, string(t.ErrorMessage)); err != nil { @@ -174,27 +181,32 @@ func (t *Response) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Chain was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Chain))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Chain))); err != nil { return err } for _, v := range t.Chain { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } return nil } -func (t *Response) UnmarshalCBOR(r io.Reader) error { +func (t *Response) UnmarshalCBOR(r io.Reader) (err error) { *t = Response{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -207,7 +219,7 @@ func (t *Response) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -220,7 +232,7 @@ func (t *Response) UnmarshalCBOR(r io.Reader) error { // t.ErrorMessage (string) (string) { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -229,7 +241,7 @@ func (t *Response) UnmarshalCBOR(r io.Reader) error { } // t.Chain ([]*exchange.BSTipSet) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -249,7 +261,7 @@ func (t *Response) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v BSTipSet - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -266,22 +278,23 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufCompactedMessages); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufCompactedMessages); err != nil { return err } - scratch := make([]byte, 9) - // t.Bls ([]*types.Message) (slice) if len(t.Bls) > cbg.MaxLength { return xerrors.Errorf("Slice value in field t.Bls was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Bls))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Bls))); err != nil { return err } for _, v := range t.Bls { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -291,7 +304,7 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.BlsIncludes was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BlsIncludes))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.BlsIncludes))); err != nil { return err } for _, v := range t.BlsIncludes { @@ -299,11 +312,11 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field v was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(v))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(v))); err != nil { return err } for _, v := range v { - if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + if err := cw.CborWriteHeader(cbg.MajUnsignedInt, uint64(v)); err != nil { return err } } @@ -314,11 +327,11 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Secpk was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Secpk))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Secpk))); err != nil { return err } for _, v := range t.Secpk { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -328,7 +341,7 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.SecpkIncludes was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.SecpkIncludes))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.SecpkIncludes))); err != nil { return err } for _, v := range t.SecpkIncludes { @@ -336,11 +349,11 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field v was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(v))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(v))); err != nil { return err } for _, v := range v { - if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + if err := cw.CborWriteHeader(cbg.MajUnsignedInt, uint64(v)); err != nil { return err } } @@ -348,16 +361,21 @@ func (t *CompactedMessages) MarshalCBOR(w io.Writer) error { return nil } -func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { +func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) (err error) { *t = CompactedMessages{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -368,7 +386,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { // t.Bls ([]*types.Message) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -388,7 +406,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v types.Message - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -397,7 +415,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { // t.BlsIncludes ([][]uint64) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -420,7 +438,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { var extra uint64 var err error - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -439,7 +457,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { for j := 0; j < int(extra); j++ { - maj, val, err := cbg.CborReadHeaderBuf(br, scratch) + maj, val, err := cr.ReadHeader() if err != nil { return xerrors.Errorf("failed to read uint64 for t.BlsIncludes[i] slice: %w", err) } @@ -456,7 +474,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { // t.Secpk ([]*types.SignedMessage) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -476,7 +494,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v types.SignedMessage - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -485,7 +503,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { // t.SecpkIncludes ([][]uint64) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -508,7 +526,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { var extra uint64 var err error - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -527,7 +545,7 @@ func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error { for j := 0; j < int(extra); j++ { - maj, val, err := cbg.CborReadHeaderBuf(br, scratch) + maj, val, err := cr.ReadHeader() if err != nil { return xerrors.Errorf("failed to read uint64 for t.SecpkIncludes[i] slice: %w", err) } @@ -552,43 +570,49 @@ func (t *BSTipSet) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufBSTipSet); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufBSTipSet); err != nil { return err } - scratch := make([]byte, 9) - // t.Blocks ([]*types.BlockHeader) (slice) if len(t.Blocks) > cbg.MaxLength { return xerrors.Errorf("Slice value in field t.Blocks was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Blocks))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Blocks))); err != nil { return err } for _, v := range t.Blocks { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } // t.Messages (exchange.CompactedMessages) (struct) - if err := t.Messages.MarshalCBOR(w); err != nil { + if err := t.Messages.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error { +func (t *BSTipSet) UnmarshalCBOR(r io.Reader) (err error) { *t = BSTipSet{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -599,7 +623,7 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error { // t.Blocks ([]*types.BlockHeader) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -619,7 +643,7 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v types.BlockHeader - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -630,16 +654,16 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Messages = new(CompactedMessages) - if err := t.Messages.UnmarshalCBOR(br); err != nil { + if err := t.Messages.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Messages pointer: %w", err) } } diff --git a/chain/market/cbor_gen.go b/chain/market/cbor_gen.go index 1c13e9ddc..9c9ef1a94 100644 --- a/chain/market/cbor_gen.go +++ b/chain/market/cbor_gen.go @@ -25,30 +25,31 @@ func (t *FundedAddressState) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufFundedAddressState); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufFundedAddressState); err != nil { return err } - scratch := make([]byte, 9) - // t.Addr (address.Address) (struct) - if err := t.Addr.MarshalCBOR(w); err != nil { + if err := t.Addr.MarshalCBOR(cw); err != nil { return err } // t.AmtReserved (big.Int) (struct) - if err := t.AmtReserved.MarshalCBOR(w); err != nil { + if err := t.AmtReserved.MarshalCBOR(cw); err != nil { return err } // t.MsgCid (cid.Cid) (struct) if t.MsgCid == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.MsgCid); err != nil { + if err := cbg.WriteCid(cw, *t.MsgCid); err != nil { return xerrors.Errorf("failed to write cid field t.MsgCid: %w", err) } } @@ -56,16 +57,21 @@ func (t *FundedAddressState) MarshalCBOR(w io.Writer) error { return nil } -func (t *FundedAddressState) UnmarshalCBOR(r io.Reader) error { +func (t *FundedAddressState) UnmarshalCBOR(r io.Reader) (err error) { *t = FundedAddressState{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -78,7 +84,7 @@ func (t *FundedAddressState) UnmarshalCBOR(r io.Reader) error { { - if err := t.Addr.UnmarshalCBOR(br); err != nil { + if err := t.Addr.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Addr: %w", err) } @@ -87,7 +93,7 @@ func (t *FundedAddressState) UnmarshalCBOR(r io.Reader) error { { - if err := t.AmtReserved.UnmarshalCBOR(br); err != nil { + if err := t.AmtReserved.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.AmtReserved: %w", err) } @@ -96,16 +102,16 @@ func (t *FundedAddressState) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.MsgCid: %w", err) } diff --git a/chain/types/cbor_gen.go b/chain/types/cbor_gen.go index b54c18c07..544728a3c 100644 --- a/chain/types/cbor_gen.go +++ b/chain/types/cbor_gen.go @@ -29,24 +29,25 @@ func (t *BlockHeader) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufBlockHeader); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufBlockHeader); err != nil { return err } - scratch := make([]byte, 9) - // t.Miner (address.Address) (struct) - if err := t.Miner.MarshalCBOR(w); err != nil { + if err := t.Miner.MarshalCBOR(cw); err != nil { return err } // t.Ticket (types.Ticket) (struct) - if err := t.Ticket.MarshalCBOR(w); err != nil { + if err := t.Ticket.MarshalCBOR(cw); err != nil { return err } // t.ElectionProof (types.ElectionProof) (struct) - if err := t.ElectionProof.MarshalCBOR(w); err != nil { + if err := t.ElectionProof.MarshalCBOR(cw); err != nil { return err } @@ -55,11 +56,11 @@ func (t *BlockHeader) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.BeaconEntries was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BeaconEntries))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.BeaconEntries))); err != nil { return err } for _, v := range t.BeaconEntries { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -69,11 +70,11 @@ func (t *BlockHeader) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.WinPoStProof was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.WinPoStProof))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.WinPoStProof))); err != nil { return err } for _, v := range t.WinPoStProof { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -83,88 +84,93 @@ func (t *BlockHeader) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Parents was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Parents))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Parents))); err != nil { return err } for _, v := range t.Parents { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.Parents: %w", err) } } // t.ParentWeight (big.Int) (struct) - if err := t.ParentWeight.MarshalCBOR(w); err != nil { + if err := t.ParentWeight.MarshalCBOR(cw); err != nil { return err } // t.Height (abi.ChainEpoch) (int64) if t.Height >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Height)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Height)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil { return err } } // t.ParentStateRoot (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.ParentStateRoot); err != nil { + if err := cbg.WriteCid(cw, t.ParentStateRoot); err != nil { return xerrors.Errorf("failed to write cid field t.ParentStateRoot: %w", err) } // t.ParentMessageReceipts (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.ParentMessageReceipts); err != nil { + if err := cbg.WriteCid(cw, t.ParentMessageReceipts); err != nil { return xerrors.Errorf("failed to write cid field t.ParentMessageReceipts: %w", err) } // t.Messages (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.Messages); err != nil { + if err := cbg.WriteCid(cw, t.Messages); err != nil { return xerrors.Errorf("failed to write cid field t.Messages: %w", err) } // t.BLSAggregate (crypto.Signature) (struct) - if err := t.BLSAggregate.MarshalCBOR(w); err != nil { + if err := t.BLSAggregate.MarshalCBOR(cw); err != nil { return err } // t.Timestamp (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Timestamp)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Timestamp)); err != nil { return err } // t.BlockSig (crypto.Signature) (struct) - if err := t.BlockSig.MarshalCBOR(w); err != nil { + if err := t.BlockSig.MarshalCBOR(cw); err != nil { return err } // t.ForkSignaling (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ForkSignaling)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ForkSignaling)); err != nil { return err } // t.ParentBaseFee (big.Int) (struct) - if err := t.ParentBaseFee.MarshalCBOR(w); err != nil { + if err := t.ParentBaseFee.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { +func (t *BlockHeader) UnmarshalCBOR(r io.Reader) (err error) { *t = BlockHeader{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -177,7 +183,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - if err := t.Miner.UnmarshalCBOR(br); err != nil { + if err := t.Miner.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Miner: %w", err) } @@ -186,16 +192,16 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Ticket = new(Ticket) - if err := t.Ticket.UnmarshalCBOR(br); err != nil { + if err := t.Ticket.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Ticket pointer: %w", err) } } @@ -205,16 +211,16 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.ElectionProof = new(ElectionProof) - if err := t.ElectionProof.UnmarshalCBOR(br); err != nil { + if err := t.ElectionProof.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.ElectionProof pointer: %w", err) } } @@ -222,7 +228,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { } // t.BeaconEntries ([]types.BeaconEntry) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -242,7 +248,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v BeaconEntry - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -251,7 +257,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { // t.WinPoStProof ([]proof.PoStProof) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -271,7 +277,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v proof.PoStProof - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -280,7 +286,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { // t.Parents ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -299,7 +305,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.Parents failed: %w", err) } @@ -310,14 +316,14 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - if err := t.ParentWeight.UnmarshalCBOR(br); err != nil { + if err := t.ParentWeight.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.ParentWeight: %w", err) } } // t.Height (abi.ChainEpoch) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -344,7 +350,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.ParentStateRoot: %w", err) } @@ -356,7 +362,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.ParentMessageReceipts: %w", err) } @@ -368,7 +374,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.Messages: %w", err) } @@ -380,16 +386,16 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.BLSAggregate = new(crypto.Signature) - if err := t.BLSAggregate.UnmarshalCBOR(br); err != nil { + if err := t.BLSAggregate.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.BLSAggregate pointer: %w", err) } } @@ -399,7 +405,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -413,16 +419,16 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.BlockSig = new(crypto.Signature) - if err := t.BlockSig.UnmarshalCBOR(br); err != nil { + if err := t.BlockSig.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.BlockSig pointer: %w", err) } } @@ -432,7 +438,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -446,7 +452,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error { { - if err := t.ParentBaseFee.UnmarshalCBOR(br); err != nil { + if err := t.ParentBaseFee.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.ParentBaseFee: %w", err) } @@ -461,37 +467,43 @@ func (t *Ticket) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufTicket); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufTicket); err != nil { return err } - scratch := make([]byte, 9) - // t.VRFProof ([]uint8) (slice) if len(t.VRFProof) > cbg.ByteArrayMaxLen { return xerrors.Errorf("Byte array in field t.VRFProof was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.VRFProof))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.VRFProof))); err != nil { return err } - if _, err := w.Write(t.VRFProof[:]); err != nil { + if _, err := cw.Write(t.VRFProof[:]); err != nil { return err } return nil } -func (t *Ticket) UnmarshalCBOR(r io.Reader) error { +func (t *Ticket) UnmarshalCBOR(r io.Reader) (err error) { *t = Ticket{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -502,7 +514,7 @@ func (t *Ticket) UnmarshalCBOR(r io.Reader) error { // t.VRFProof ([]uint8) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -518,7 +530,7 @@ func (t *Ticket) UnmarshalCBOR(r io.Reader) error { t.VRFProof = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.VRFProof[:]); err != nil { + if _, err := io.ReadFull(cr, t.VRFProof[:]); err != nil { return err } return nil @@ -531,19 +543,20 @@ func (t *ElectionProof) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufElectionProof); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufElectionProof); err != nil { return err } - scratch := make([]byte, 9) - // t.WinCount (int64) (int64) if t.WinCount >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.WinCount)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.WinCount)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.WinCount-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.WinCount-1)); err != nil { return err } } @@ -553,26 +566,31 @@ func (t *ElectionProof) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.VRFProof was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.VRFProof))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.VRFProof))); err != nil { return err } - if _, err := w.Write(t.VRFProof[:]); err != nil { + if _, err := cw.Write(t.VRFProof[:]); err != nil { return err } return nil } -func (t *ElectionProof) UnmarshalCBOR(r io.Reader) error { +func (t *ElectionProof) UnmarshalCBOR(r io.Reader) (err error) { *t = ElectionProof{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -583,7 +601,7 @@ func (t *ElectionProof) UnmarshalCBOR(r io.Reader) error { // t.WinCount (int64) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -608,7 +626,7 @@ func (t *ElectionProof) UnmarshalCBOR(r io.Reader) error { } // t.VRFProof ([]uint8) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -624,7 +642,7 @@ func (t *ElectionProof) UnmarshalCBOR(r io.Reader) error { t.VRFProof = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.VRFProof[:]); err != nil { + if _, err := io.ReadFull(cr, t.VRFProof[:]); err != nil { return err } return nil @@ -637,63 +655,64 @@ func (t *Message) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufMessage); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufMessage); err != nil { return err } - scratch := make([]byte, 9) - // t.Version (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Version)); err != nil { return err } // t.To (address.Address) (struct) - if err := t.To.MarshalCBOR(w); err != nil { + if err := t.To.MarshalCBOR(cw); err != nil { return err } // t.From (address.Address) (struct) - if err := t.From.MarshalCBOR(w); err != nil { + if err := t.From.MarshalCBOR(cw); err != nil { return err } // t.Nonce (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Nonce)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Nonce)); err != nil { return err } // t.Value (big.Int) (struct) - if err := t.Value.MarshalCBOR(w); err != nil { + if err := t.Value.MarshalCBOR(cw); err != nil { return err } // t.GasLimit (int64) (int64) if t.GasLimit >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.GasLimit)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.GasLimit)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.GasLimit-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.GasLimit-1)); err != nil { return err } } // t.GasFeeCap (big.Int) (struct) - if err := t.GasFeeCap.MarshalCBOR(w); err != nil { + if err := t.GasFeeCap.MarshalCBOR(cw); err != nil { return err } // t.GasPremium (big.Int) (struct) - if err := t.GasPremium.MarshalCBOR(w); err != nil { + if err := t.GasPremium.MarshalCBOR(cw); err != nil { return err } // t.Method (abi.MethodNum) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Method)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Method)); err != nil { return err } @@ -702,26 +721,31 @@ func (t *Message) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Params was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Params))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Params))); err != nil { return err } - if _, err := w.Write(t.Params[:]); err != nil { + if _, err := cw.Write(t.Params[:]); err != nil { return err } return nil } -func (t *Message) UnmarshalCBOR(r io.Reader) error { +func (t *Message) UnmarshalCBOR(r io.Reader) (err error) { *t = Message{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -734,7 +758,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -748,7 +772,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - if err := t.To.UnmarshalCBOR(br); err != nil { + if err := t.To.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.To: %w", err) } @@ -757,7 +781,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - if err := t.From.UnmarshalCBOR(br); err != nil { + if err := t.From.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.From: %w", err) } @@ -766,7 +790,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -780,14 +804,14 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - if err := t.Value.UnmarshalCBOR(br); err != nil { + if err := t.Value.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Value: %w", err) } } // t.GasLimit (int64) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -814,7 +838,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - if err := t.GasFeeCap.UnmarshalCBOR(br); err != nil { + if err := t.GasFeeCap.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.GasFeeCap: %w", err) } @@ -823,7 +847,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - if err := t.GasPremium.UnmarshalCBOR(br); err != nil { + if err := t.GasPremium.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.GasPremium: %w", err) } @@ -832,7 +856,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -844,7 +868,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { } // t.Params ([]uint8) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -860,7 +884,7 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error { t.Params = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Params[:]); err != nil { + if _, err := io.ReadFull(cr, t.Params[:]); err != nil { return err } return nil @@ -873,32 +897,40 @@ func (t *SignedMessage) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufSignedMessage); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufSignedMessage); err != nil { return err } // t.Message (types.Message) (struct) - if err := t.Message.MarshalCBOR(w); err != nil { + if err := t.Message.MarshalCBOR(cw); err != nil { return err } // t.Signature (crypto.Signature) (struct) - if err := t.Signature.MarshalCBOR(w); err != nil { + if err := t.Signature.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *SignedMessage) UnmarshalCBOR(r io.Reader) error { +func (t *SignedMessage) UnmarshalCBOR(r io.Reader) (err error) { *t = SignedMessage{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -911,7 +943,7 @@ func (t *SignedMessage) UnmarshalCBOR(r io.Reader) error { { - if err := t.Message.UnmarshalCBOR(br); err != nil { + if err := t.Message.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Message: %w", err) } @@ -920,7 +952,7 @@ func (t *SignedMessage) UnmarshalCBOR(r io.Reader) error { { - if err := t.Signature.UnmarshalCBOR(br); err != nil { + if err := t.Signature.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Signature: %w", err) } @@ -935,37 +967,43 @@ func (t *MsgMeta) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufMsgMeta); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufMsgMeta); err != nil { return err } - scratch := make([]byte, 9) - // t.BlsMessages (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.BlsMessages); err != nil { + if err := cbg.WriteCid(cw, t.BlsMessages); err != nil { return xerrors.Errorf("failed to write cid field t.BlsMessages: %w", err) } // t.SecpkMessages (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.SecpkMessages); err != nil { + if err := cbg.WriteCid(cw, t.SecpkMessages); err != nil { return xerrors.Errorf("failed to write cid field t.SecpkMessages: %w", err) } return nil } -func (t *MsgMeta) UnmarshalCBOR(r io.Reader) error { +func (t *MsgMeta) UnmarshalCBOR(r io.Reader) (err error) { *t = MsgMeta{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -978,7 +1016,7 @@ func (t *MsgMeta) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.BlsMessages: %w", err) } @@ -990,7 +1028,7 @@ func (t *MsgMeta) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.SecpkMessages: %w", err) } @@ -1008,47 +1046,53 @@ func (t *Actor) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufActor); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufActor); err != nil { return err } - scratch := make([]byte, 9) - // t.Code (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.Code); err != nil { + if err := cbg.WriteCid(cw, t.Code); err != nil { return xerrors.Errorf("failed to write cid field t.Code: %w", err) } // t.Head (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.Head); err != nil { + if err := cbg.WriteCid(cw, t.Head); err != nil { return xerrors.Errorf("failed to write cid field t.Head: %w", err) } // t.Nonce (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Nonce)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Nonce)); err != nil { return err } // t.Balance (big.Int) (struct) - if err := t.Balance.MarshalCBOR(w); err != nil { + if err := t.Balance.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *Actor) UnmarshalCBOR(r io.Reader) error { +func (t *Actor) UnmarshalCBOR(r io.Reader) (err error) { *t = Actor{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -1061,7 +1105,7 @@ func (t *Actor) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.Code: %w", err) } @@ -1073,7 +1117,7 @@ func (t *Actor) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.Head: %w", err) } @@ -1085,7 +1129,7 @@ func (t *Actor) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1099,7 +1143,7 @@ func (t *Actor) UnmarshalCBOR(r io.Reader) error { { - if err := t.Balance.UnmarshalCBOR(br); err != nil { + if err := t.Balance.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Balance: %w", err) } @@ -1114,19 +1158,20 @@ func (t *MessageReceipt) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufMessageReceipt); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufMessageReceipt); err != nil { return err } - scratch := make([]byte, 9) - // t.ExitCode (exitcode.ExitCode) (int64) if t.ExitCode >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ExitCode)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ExitCode)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.ExitCode-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ExitCode-1)); err != nil { return err } } @@ -1136,37 +1181,42 @@ func (t *MessageReceipt) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Return was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Return))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Return))); err != nil { return err } - if _, err := w.Write(t.Return[:]); err != nil { + if _, err := cw.Write(t.Return[:]); err != nil { return err } // t.GasUsed (int64) (int64) if t.GasUsed >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.GasUsed)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.GasUsed)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.GasUsed-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.GasUsed-1)); err != nil { return err } } return nil } -func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error { +func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) (err error) { *t = MessageReceipt{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -1177,7 +1227,7 @@ func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error { // t.ExitCode (exitcode.ExitCode) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1202,7 +1252,7 @@ func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error { } // t.Return ([]uint8) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1218,12 +1268,12 @@ func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error { t.Return = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Return[:]); err != nil { + if _, err := io.ReadFull(cr, t.Return[:]); err != nil { return err } // t.GasUsed (int64) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1256,14 +1306,15 @@ func (t *BlockMsg) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufBlockMsg); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufBlockMsg); err != nil { return err } - scratch := make([]byte, 9) - // t.Header (types.BlockHeader) (struct) - if err := t.Header.MarshalCBOR(w); err != nil { + if err := t.Header.MarshalCBOR(cw); err != nil { return err } @@ -1272,11 +1323,11 @@ func (t *BlockMsg) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.BlsMessages was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BlsMessages))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.BlsMessages))); err != nil { return err } for _, v := range t.BlsMessages { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.BlsMessages: %w", err) } } @@ -1286,27 +1337,32 @@ func (t *BlockMsg) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.SecpkMessages was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.SecpkMessages))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.SecpkMessages))); err != nil { return err } for _, v := range t.SecpkMessages { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.SecpkMessages: %w", err) } } return nil } -func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error { +func (t *BlockMsg) UnmarshalCBOR(r io.Reader) (err error) { *t = BlockMsg{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -1319,16 +1375,16 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Header = new(BlockHeader) - if err := t.Header.UnmarshalCBOR(br); err != nil { + if err := t.Header.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Header pointer: %w", err) } } @@ -1336,7 +1392,7 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error { } // t.BlsMessages ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1355,7 +1411,7 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.BlsMessages failed: %w", err) } @@ -1364,7 +1420,7 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error { // t.SecpkMessages ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1383,7 +1439,7 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.SecpkMessages failed: %w", err) } @@ -1400,22 +1456,23 @@ func (t *ExpTipSet) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufExpTipSet); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufExpTipSet); err != nil { return err } - scratch := make([]byte, 9) - // t.Cids ([]cid.Cid) (slice) if len(t.Cids) > cbg.MaxLength { return xerrors.Errorf("Slice value in field t.Cids was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Cids))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Cids))); err != nil { return err } for _, v := range t.Cids { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.Cids: %w", err) } } @@ -1425,38 +1482,43 @@ func (t *ExpTipSet) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Blocks was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Blocks))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Blocks))); err != nil { return err } for _, v := range t.Blocks { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } // t.Height (abi.ChainEpoch) (int64) if t.Height >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Height)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Height)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil { return err } } return nil } -func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error { +func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) (err error) { *t = ExpTipSet{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -1467,7 +1529,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error { // t.Cids ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1486,7 +1548,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.Cids failed: %w", err) } @@ -1495,7 +1557,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error { // t.Blocks ([]*types.BlockHeader) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1515,7 +1577,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v BlockHeader - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -1524,7 +1586,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error { // t.Height (abi.ChainEpoch) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1557,15 +1619,16 @@ func (t *BeaconEntry) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufBeaconEntry); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufBeaconEntry); err != nil { return err } - scratch := make([]byte, 9) - // t.Round (uint64) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Round)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Round)); err != nil { return err } @@ -1574,26 +1637,31 @@ func (t *BeaconEntry) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Data was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Data))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Data))); err != nil { return err } - if _, err := w.Write(t.Data[:]); err != nil { + if _, err := cw.Write(t.Data[:]); err != nil { return err } return nil } -func (t *BeaconEntry) UnmarshalCBOR(r io.Reader) error { +func (t *BeaconEntry) UnmarshalCBOR(r io.Reader) (err error) { *t = BeaconEntry{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -1606,7 +1674,7 @@ func (t *BeaconEntry) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1618,7 +1686,7 @@ func (t *BeaconEntry) UnmarshalCBOR(r io.Reader) error { } // t.Data ([]uint8) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1634,7 +1702,7 @@ func (t *BeaconEntry) UnmarshalCBOR(r io.Reader) error { t.Data = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Data[:]); err != nil { + if _, err := io.ReadFull(cr, t.Data[:]); err != nil { return err } return nil @@ -1647,43 +1715,49 @@ func (t *StateRoot) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufStateRoot); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufStateRoot); err != nil { return err } - scratch := make([]byte, 9) - // t.Version (types.StateTreeVersion) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Version)); err != nil { return err } // t.Actors (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.Actors); err != nil { + if err := cbg.WriteCid(cw, t.Actors); err != nil { return xerrors.Errorf("failed to write cid field t.Actors: %w", err) } // t.Info (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.Info); err != nil { + if err := cbg.WriteCid(cw, t.Info); err != nil { return xerrors.Errorf("failed to write cid field t.Info: %w", err) } return nil } -func (t *StateRoot) UnmarshalCBOR(r io.Reader) error { +func (t *StateRoot) UnmarshalCBOR(r io.Reader) (err error) { *t = StateRoot{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -1696,7 +1770,7 @@ func (t *StateRoot) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1710,7 +1784,7 @@ func (t *StateRoot) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.Actors: %w", err) } @@ -1722,7 +1796,7 @@ func (t *StateRoot) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.Info: %w", err) } @@ -1740,23 +1814,30 @@ func (t *StateInfo0) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufStateInfo0); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufStateInfo0); err != nil { return err } - return nil } -func (t *StateInfo0) UnmarshalCBOR(r io.Reader) error { +func (t *StateInfo0) UnmarshalCBOR(r io.Reader) (err error) { *t = StateInfo0{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } diff --git a/chain/vm/cbor_gen.go b/chain/vm/cbor_gen.go index 76d8e9d48..0e1677c95 100644 --- a/chain/vm/cbor_gen.go +++ b/chain/vm/cbor_gen.go @@ -26,19 +26,20 @@ func (t *FvmExecutionTrace) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufFvmExecutionTrace); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufFvmExecutionTrace); err != nil { return err } - scratch := make([]byte, 9) - // t.Msg (types.Message) (struct) - if err := t.Msg.MarshalCBOR(w); err != nil { + if err := t.Msg.MarshalCBOR(cw); err != nil { return err } // t.MsgRct (types.MessageReceipt) (struct) - if err := t.MsgRct.MarshalCBOR(w); err != nil { + if err := t.MsgRct.MarshalCBOR(cw); err != nil { return err } @@ -47,7 +48,7 @@ func (t *FvmExecutionTrace) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Error was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Error))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Error))); err != nil { return err } if _, err := io.WriteString(w, string(t.Error)); err != nil { @@ -59,27 +60,32 @@ func (t *FvmExecutionTrace) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Subcalls was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Subcalls))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Subcalls))); err != nil { return err } for _, v := range t.Subcalls { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } return nil } -func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) error { +func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) (err error) { *t = FvmExecutionTrace{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -92,16 +98,16 @@ func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Msg = new(types.Message) - if err := t.Msg.UnmarshalCBOR(br); err != nil { + if err := t.Msg.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Msg pointer: %w", err) } } @@ -111,16 +117,16 @@ func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.MsgRct = new(types.MessageReceipt) - if err := t.MsgRct.UnmarshalCBOR(br); err != nil { + if err := t.MsgRct.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.MsgRct pointer: %w", err) } } @@ -129,7 +135,7 @@ func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) error { // t.Error (string) (string) { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -138,7 +144,7 @@ func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) error { } // t.Subcalls ([]vm.FvmExecutionTrace) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -158,7 +164,7 @@ func (t *FvmExecutionTrace) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v FvmExecutionTrace - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } diff --git a/cmd/lotus-shed/shedgen/cbor_gen.go b/cmd/lotus-shed/shedgen/cbor_gen.go index 37ed95539..a04d52c8e 100644 --- a/cmd/lotus-shed/shedgen/cbor_gen.go +++ b/cmd/lotus-shed/shedgen/cbor_gen.go @@ -23,18 +23,19 @@ func (t *CarbNode) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{161}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{161}); err != nil { return err } - scratch := make([]byte, 9) - // t.Sub ([]cid.Cid) (slice) if len("Sub") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Sub\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Sub"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Sub"))); err != nil { return err } if _, err := io.WriteString(w, string("Sub")); err != nil { @@ -45,27 +46,32 @@ func (t *CarbNode) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Sub was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Sub))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Sub))); err != nil { return err } for _, v := range t.Sub { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.Sub: %w", err) } } return nil } -func (t *CarbNode) UnmarshalCBOR(r io.Reader) error { +func (t *CarbNode) UnmarshalCBOR(r io.Reader) (err error) { *t = CarbNode{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -80,7 +86,7 @@ func (t *CarbNode) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -92,7 +98,7 @@ func (t *CarbNode) UnmarshalCBOR(r io.Reader) error { // t.Sub ([]cid.Cid) (slice) case "Sub": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -111,7 +117,7 @@ func (t *CarbNode) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.Sub failed: %w", err) } diff --git a/conformance/chaos/cbor_gen.go b/conformance/chaos/cbor_gen.go index d0d1ad627..436849cdc 100644 --- a/conformance/chaos/cbor_gen.go +++ b/conformance/chaos/cbor_gen.go @@ -28,18 +28,19 @@ func (t *State) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufState); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufState); err != nil { return err } - scratch := make([]byte, 9) - // t.Value (string) (string) if len(t.Value) > cbg.MaxLength { return xerrors.Errorf("Value in field t.Value was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Value))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { return err } if _, err := io.WriteString(w, string(t.Value)); err != nil { @@ -51,27 +52,32 @@ func (t *State) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Unmarshallable was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Unmarshallable))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Unmarshallable))); err != nil { return err } for _, v := range t.Unmarshallable { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } return nil } -func (t *State) UnmarshalCBOR(r io.Reader) error { +func (t *State) UnmarshalCBOR(r io.Reader) (err error) { *t = State{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -83,7 +89,7 @@ func (t *State) UnmarshalCBOR(r io.Reader) error { // t.Value (string) (string) { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -92,7 +98,7 @@ func (t *State) UnmarshalCBOR(r io.Reader) error { } // t.Unmarshallable ([]*chaos.UnmarshallableCBOR) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -112,7 +118,7 @@ func (t *State) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v UnmarshallableCBOR - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -129,19 +135,20 @@ func (t *CallerValidationArgs) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufCallerValidationArgs); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufCallerValidationArgs); err != nil { return err } - scratch := make([]byte, 9) - // t.Branch (chaos.CallerValidationBranch) (int64) if t.Branch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Branch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Branch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil { return err } } @@ -151,11 +158,11 @@ func (t *CallerValidationArgs) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Addrs was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Addrs))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Addrs))); err != nil { return err } for _, v := range t.Addrs { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -165,27 +172,32 @@ func (t *CallerValidationArgs) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Types was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Types))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Types))); err != nil { return err } for _, v := range t.Types { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.Types: %w", err) } } return nil } -func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error { +func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) (err error) { *t = CallerValidationArgs{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -196,7 +208,7 @@ func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error { // t.Branch (chaos.CallerValidationBranch) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -221,7 +233,7 @@ func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error { } // t.Addrs ([]address.Address) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -241,7 +253,7 @@ func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v address.Address - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -250,7 +262,7 @@ func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error { // t.Types ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -269,7 +281,7 @@ func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.Types failed: %w", err) } @@ -286,12 +298,13 @@ func (t *CreateActorArgs) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufCreateActorArgs); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufCreateActorArgs); err != nil { return err } - scratch := make([]byte, 9) - // t.UndefActorCID (bool) (bool) if err := cbg.WriteBool(w, t.UndefActorCID); err != nil { return err @@ -299,7 +312,7 @@ func (t *CreateActorArgs) MarshalCBOR(w io.Writer) error { // t.ActorCID (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.ActorCID); err != nil { + if err := cbg.WriteCid(cw, t.ActorCID); err != nil { return xerrors.Errorf("failed to write cid field t.ActorCID: %w", err) } @@ -309,22 +322,27 @@ func (t *CreateActorArgs) MarshalCBOR(w io.Writer) error { } // t.Address (address.Address) (struct) - if err := t.Address.MarshalCBOR(w); err != nil { + if err := t.Address.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error { +func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) (err error) { *t = CreateActorArgs{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -335,7 +353,7 @@ func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error { // t.UndefActorCID (bool) (bool) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -354,7 +372,7 @@ func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.ActorCID: %w", err) } @@ -364,7 +382,7 @@ func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error { } // t.UndefAddress (bool) (bool) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -383,7 +401,7 @@ func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error { { - if err := t.Address.UnmarshalCBOR(br); err != nil { + if err := t.Address.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Address: %w", err) } @@ -398,12 +416,15 @@ func (t *ResolveAddressResponse) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufResolveAddressResponse); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufResolveAddressResponse); err != nil { return err } // t.Address (address.Address) (struct) - if err := t.Address.MarshalCBOR(w); err != nil { + if err := t.Address.MarshalCBOR(cw); err != nil { return err } @@ -414,16 +435,21 @@ func (t *ResolveAddressResponse) MarshalCBOR(w io.Writer) error { return nil } -func (t *ResolveAddressResponse) UnmarshalCBOR(r io.Reader) error { +func (t *ResolveAddressResponse) UnmarshalCBOR(r io.Reader) (err error) { *t = ResolveAddressResponse{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -436,14 +462,14 @@ func (t *ResolveAddressResponse) UnmarshalCBOR(r io.Reader) error { { - if err := t.Address.UnmarshalCBOR(br); err != nil { + if err := t.Address.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Address: %w", err) } } // t.Success (bool) (bool) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -468,25 +494,26 @@ func (t *SendArgs) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufSendArgs); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufSendArgs); err != nil { return err } - scratch := make([]byte, 9) - // t.To (address.Address) (struct) - if err := t.To.MarshalCBOR(w); err != nil { + if err := t.To.MarshalCBOR(cw); err != nil { return err } // t.Value (big.Int) (struct) - if err := t.Value.MarshalCBOR(w); err != nil { + if err := t.Value.MarshalCBOR(cw); err != nil { return err } // t.Method (abi.MethodNum) (uint64) - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Method)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Method)); err != nil { return err } @@ -495,26 +522,31 @@ func (t *SendArgs) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Params was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Params))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Params))); err != nil { return err } - if _, err := w.Write(t.Params[:]); err != nil { + if _, err := cw.Write(t.Params[:]); err != nil { return err } return nil } -func (t *SendArgs) UnmarshalCBOR(r io.Reader) error { +func (t *SendArgs) UnmarshalCBOR(r io.Reader) (err error) { *t = SendArgs{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -527,7 +559,7 @@ func (t *SendArgs) UnmarshalCBOR(r io.Reader) error { { - if err := t.To.UnmarshalCBOR(br); err != nil { + if err := t.To.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.To: %w", err) } @@ -536,7 +568,7 @@ func (t *SendArgs) UnmarshalCBOR(r io.Reader) error { { - if err := t.Value.UnmarshalCBOR(br); err != nil { + if err := t.Value.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Value: %w", err) } @@ -545,7 +577,7 @@ func (t *SendArgs) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -557,7 +589,7 @@ func (t *SendArgs) UnmarshalCBOR(r io.Reader) error { } // t.Params ([]uint8) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -573,7 +605,7 @@ func (t *SendArgs) UnmarshalCBOR(r io.Reader) error { t.Params = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Params[:]); err != nil { + if _, err := io.ReadFull(cr, t.Params[:]); err != nil { return err } return nil @@ -586,48 +618,54 @@ func (t *SendReturn) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufSendReturn); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufSendReturn); err != nil { return err } - scratch := make([]byte, 9) - // t.Return (builtin.CBORBytes) (slice) if len(t.Return) > cbg.ByteArrayMaxLen { return xerrors.Errorf("Byte array in field t.Return was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Return))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Return))); err != nil { return err } - if _, err := w.Write(t.Return[:]); err != nil { + if _, err := cw.Write(t.Return[:]); err != nil { return err } // t.Code (exitcode.ExitCode) (int64) if t.Code >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Code)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Code)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil { return err } } return nil } -func (t *SendReturn) UnmarshalCBOR(r io.Reader) error { +func (t *SendReturn) UnmarshalCBOR(r io.Reader) (err error) { *t = SendReturn{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -638,7 +676,7 @@ func (t *SendReturn) UnmarshalCBOR(r io.Reader) error { // t.Return (builtin.CBORBytes) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -654,12 +692,12 @@ func (t *SendReturn) UnmarshalCBOR(r io.Reader) error { t.Return = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Return[:]); err != nil { + if _, err := io.ReadFull(cr, t.Return[:]); err != nil { return err } // t.Code (exitcode.ExitCode) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -692,18 +730,19 @@ func (t *MutateStateArgs) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufMutateStateArgs); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufMutateStateArgs); err != nil { return err } - scratch := make([]byte, 9) - // t.Value (string) (string) if len(t.Value) > cbg.MaxLength { return xerrors.Errorf("Value in field t.Value was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Value))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { return err } if _, err := io.WriteString(w, string(t.Value)); err != nil { @@ -712,27 +751,32 @@ func (t *MutateStateArgs) MarshalCBOR(w io.Writer) error { // t.Branch (chaos.MutateStateBranch) (int64) if t.Branch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Branch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Branch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil { return err } } return nil } -func (t *MutateStateArgs) UnmarshalCBOR(r io.Reader) error { +func (t *MutateStateArgs) UnmarshalCBOR(r io.Reader) (err error) { *t = MutateStateArgs{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -744,7 +788,7 @@ func (t *MutateStateArgs) UnmarshalCBOR(r io.Reader) error { // t.Value (string) (string) { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -753,7 +797,7 @@ func (t *MutateStateArgs) UnmarshalCBOR(r io.Reader) error { } // t.Branch (chaos.MutateStateBranch) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -786,19 +830,20 @@ func (t *AbortWithArgs) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufAbortWithArgs); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufAbortWithArgs); err != nil { return err } - scratch := make([]byte, 9) - // t.Code (exitcode.ExitCode) (int64) if t.Code >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Code)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Code)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil { return err } } @@ -808,7 +853,7 @@ func (t *AbortWithArgs) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Message was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Message))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil { return err } if _, err := io.WriteString(w, string(t.Message)); err != nil { @@ -822,16 +867,21 @@ func (t *AbortWithArgs) MarshalCBOR(w io.Writer) error { return nil } -func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) error { +func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) (err error) { *t = AbortWithArgs{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -842,7 +892,7 @@ func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) error { // t.Code (exitcode.ExitCode) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -868,7 +918,7 @@ func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) error { // t.Message (string) (string) { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -877,7 +927,7 @@ func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) error { } // t.Uncontrolled (bool) (bool) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -902,60 +952,66 @@ func (t *InspectRuntimeReturn) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufInspectRuntimeReturn); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufInspectRuntimeReturn); err != nil { return err } - scratch := make([]byte, 9) - // t.Caller (address.Address) (struct) - if err := t.Caller.MarshalCBOR(w); err != nil { + if err := t.Caller.MarshalCBOR(cw); err != nil { return err } // t.Receiver (address.Address) (struct) - if err := t.Receiver.MarshalCBOR(w); err != nil { + if err := t.Receiver.MarshalCBOR(cw); err != nil { return err } // t.ValueReceived (big.Int) (struct) - if err := t.ValueReceived.MarshalCBOR(w); err != nil { + if err := t.ValueReceived.MarshalCBOR(cw); err != nil { return err } // t.CurrEpoch (abi.ChainEpoch) (int64) if t.CurrEpoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.CurrEpoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.CurrEpoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.CurrEpoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.CurrEpoch-1)); err != nil { return err } } // t.CurrentBalance (big.Int) (struct) - if err := t.CurrentBalance.MarshalCBOR(w); err != nil { + if err := t.CurrentBalance.MarshalCBOR(cw); err != nil { return err } // t.State (chaos.State) (struct) - if err := t.State.MarshalCBOR(w); err != nil { + if err := t.State.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error { +func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) (err error) { *t = InspectRuntimeReturn{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -968,7 +1024,7 @@ func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error { { - if err := t.Caller.UnmarshalCBOR(br); err != nil { + if err := t.Caller.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Caller: %w", err) } @@ -977,7 +1033,7 @@ func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error { { - if err := t.Receiver.UnmarshalCBOR(br); err != nil { + if err := t.Receiver.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Receiver: %w", err) } @@ -986,14 +1042,14 @@ func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error { { - if err := t.ValueReceived.UnmarshalCBOR(br); err != nil { + if err := t.ValueReceived.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.ValueReceived: %w", err) } } // t.CurrEpoch (abi.ChainEpoch) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1020,7 +1076,7 @@ func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error { { - if err := t.CurrentBalance.UnmarshalCBOR(br); err != nil { + if err := t.CurrentBalance.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.CurrentBalance: %w", err) } @@ -1029,7 +1085,7 @@ func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error { { - if err := t.State.UnmarshalCBOR(br); err != nil { + if err := t.State.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.State: %w", err) } diff --git a/extern/sector-storage/cbor_gen.go b/extern/sector-storage/cbor_gen.go index 623d75b33..fd99576cc 100644 --- a/extern/sector-storage/cbor_gen.go +++ b/extern/sector-storage/cbor_gen.go @@ -24,25 +24,26 @@ func (t *Call) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{164}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{164}); err != nil { return err } - scratch := make([]byte, 9) - // t.ID (storiface.CallID) (struct) if len("ID") > cbg.MaxLength { return xerrors.Errorf("Value in field \"ID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil { return err } if _, err := io.WriteString(w, string("ID")); err != nil { return err } - if err := t.ID.MarshalCBOR(w); err != nil { + if err := t.ID.MarshalCBOR(cw); err != nil { return err } @@ -51,7 +52,7 @@ func (t *Call) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"RetType\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("RetType"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("RetType"))); err != nil { return err } if _, err := io.WriteString(w, string("RetType")); err != nil { @@ -62,7 +63,7 @@ func (t *Call) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.RetType was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.RetType))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RetType))); err != nil { return err } if _, err := io.WriteString(w, string(t.RetType)); err != nil { @@ -74,14 +75,14 @@ func (t *Call) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"State\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("State"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("State"))); err != nil { return err } if _, err := io.WriteString(w, string("State")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.State)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.State)); err != nil { return err } @@ -90,29 +91,34 @@ func (t *Call) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Result\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Result"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Result"))); err != nil { return err } if _, err := io.WriteString(w, string("Result")); err != nil { return err } - if err := t.Result.MarshalCBOR(w); err != nil { + if err := t.Result.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *Call) UnmarshalCBOR(r io.Reader) error { +func (t *Call) UnmarshalCBOR(r io.Reader) (err error) { *t = Call{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -127,7 +133,7 @@ func (t *Call) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -141,7 +147,7 @@ func (t *Call) UnmarshalCBOR(r io.Reader) error { { - if err := t.ID.UnmarshalCBOR(br); err != nil { + if err := t.ID.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.ID: %w", err) } @@ -150,7 +156,7 @@ func (t *Call) UnmarshalCBOR(r io.Reader) error { case "RetType": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -162,7 +168,7 @@ func (t *Call) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -177,16 +183,16 @@ func (t *Call) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Result = new(ManyBytes) - if err := t.Result.UnmarshalCBOR(br); err != nil { + if err := t.Result.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Result pointer: %w", err) } } @@ -206,25 +212,26 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{166}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{166}); err != nil { return err } - scratch := make([]byte, 9) - // t.ID (sectorstorage.WorkID) (struct) if len("ID") > cbg.MaxLength { return xerrors.Errorf("Value in field \"ID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil { return err } if _, err := io.WriteString(w, string("ID")); err != nil { return err } - if err := t.ID.MarshalCBOR(w); err != nil { + if err := t.ID.MarshalCBOR(cw); err != nil { return err } @@ -233,7 +240,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Status\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Status"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Status"))); err != nil { return err } if _, err := io.WriteString(w, string("Status")); err != nil { @@ -244,7 +251,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Status was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Status))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { return err } if _, err := io.WriteString(w, string(t.Status)); err != nil { @@ -256,14 +263,14 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"WorkerCall\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WorkerCall"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WorkerCall"))); err != nil { return err } if _, err := io.WriteString(w, string("WorkerCall")); err != nil { return err } - if err := t.WorkerCall.MarshalCBOR(w); err != nil { + if err := t.WorkerCall.MarshalCBOR(cw); err != nil { return err } @@ -272,7 +279,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"WorkError\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WorkError"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WorkError"))); err != nil { return err } if _, err := io.WriteString(w, string("WorkError")); err != nil { @@ -283,7 +290,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.WorkError was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.WorkError))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.WorkError))); err != nil { return err } if _, err := io.WriteString(w, string(t.WorkError)); err != nil { @@ -295,7 +302,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"WorkerHostname\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WorkerHostname"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WorkerHostname"))); err != nil { return err } if _, err := io.WriteString(w, string("WorkerHostname")); err != nil { @@ -306,7 +313,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.WorkerHostname was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.WorkerHostname))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.WorkerHostname))); err != nil { return err } if _, err := io.WriteString(w, string(t.WorkerHostname)); err != nil { @@ -318,7 +325,7 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"StartTime\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("StartTime"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("StartTime"))); err != nil { return err } if _, err := io.WriteString(w, string("StartTime")); err != nil { @@ -326,27 +333,32 @@ func (t *WorkState) MarshalCBOR(w io.Writer) error { } if t.StartTime >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.StartTime)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.StartTime)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.StartTime-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.StartTime-1)); err != nil { return err } } return nil } -func (t *WorkState) UnmarshalCBOR(r io.Reader) error { +func (t *WorkState) UnmarshalCBOR(r io.Reader) (err error) { *t = WorkState{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -361,7 +373,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -375,7 +387,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { { - if err := t.ID.UnmarshalCBOR(br); err != nil { + if err := t.ID.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.ID: %w", err) } @@ -384,7 +396,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { case "Status": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -396,7 +408,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { { - if err := t.WorkerCall.UnmarshalCBOR(br); err != nil { + if err := t.WorkerCall.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.WorkerCall: %w", err) } @@ -405,7 +417,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { case "WorkError": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -416,7 +428,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { case "WorkerHostname": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -426,7 +438,7 @@ func (t *WorkState) UnmarshalCBOR(r io.Reader) error { // t.StartTime (int64) (int64) case "StartTime": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -463,18 +475,19 @@ func (t *WorkID) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{162}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { return err } - scratch := make([]byte, 9) - // t.Method (sealtasks.TaskType) (string) if len("Method") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Method\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Method"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Method"))); err != nil { return err } if _, err := io.WriteString(w, string("Method")); err != nil { @@ -485,7 +498,7 @@ func (t *WorkID) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Method was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Method))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Method))); err != nil { return err } if _, err := io.WriteString(w, string(t.Method)); err != nil { @@ -497,7 +510,7 @@ func (t *WorkID) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Params\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Params"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Params"))); err != nil { return err } if _, err := io.WriteString(w, string("Params")); err != nil { @@ -508,7 +521,7 @@ func (t *WorkID) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Params was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Params))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Params))); err != nil { return err } if _, err := io.WriteString(w, string(t.Params)); err != nil { @@ -517,16 +530,21 @@ func (t *WorkID) MarshalCBOR(w io.Writer) error { return nil } -func (t *WorkID) UnmarshalCBOR(r io.Reader) error { +func (t *WorkID) UnmarshalCBOR(r io.Reader) (err error) { *t = WorkID{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -541,7 +559,7 @@ func (t *WorkID) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -554,7 +572,7 @@ func (t *WorkID) UnmarshalCBOR(r io.Reader) error { case "Method": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -565,7 +583,7 @@ func (t *WorkID) UnmarshalCBOR(r io.Reader) error { case "Params": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } diff --git a/extern/sector-storage/storiface/cbor_gen.go b/extern/sector-storage/storiface/cbor_gen.go index 44b5ae9ee..5b4623175 100644 --- a/extern/sector-storage/storiface/cbor_gen.go +++ b/extern/sector-storage/storiface/cbor_gen.go @@ -23,25 +23,26 @@ func (t *CallID) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{162}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { return err } - scratch := make([]byte, 9) - // t.Sector (abi.SectorID) (struct) if len("Sector") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Sector\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Sector"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Sector"))); err != nil { return err } if _, err := io.WriteString(w, string("Sector")); err != nil { return err } - if err := t.Sector.MarshalCBOR(w); err != nil { + if err := t.Sector.MarshalCBOR(cw); err != nil { return err } @@ -50,7 +51,7 @@ func (t *CallID) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"ID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ID"))); err != nil { return err } if _, err := io.WriteString(w, string("ID")); err != nil { @@ -61,26 +62,31 @@ func (t *CallID) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.ID was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.ID))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.ID))); err != nil { return err } - if _, err := w.Write(t.ID[:]); err != nil { + if _, err := cw.Write(t.ID[:]); err != nil { return err } return nil } -func (t *CallID) UnmarshalCBOR(r io.Reader) error { +func (t *CallID) UnmarshalCBOR(r io.Reader) (err error) { *t = CallID{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -95,7 +101,7 @@ func (t *CallID) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -109,7 +115,7 @@ func (t *CallID) UnmarshalCBOR(r io.Reader) error { { - if err := t.Sector.UnmarshalCBOR(br); err != nil { + if err := t.Sector.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Sector: %w", err) } @@ -117,7 +123,7 @@ func (t *CallID) UnmarshalCBOR(r io.Reader) error { // t.ID (uuid.UUID) (array) case "ID": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -135,7 +141,7 @@ func (t *CallID) UnmarshalCBOR(r io.Reader) error { t.ID = [16]uint8{} - if _, err := io.ReadFull(br, t.ID[:]); err != nil { + if _, err := io.ReadFull(cr, t.ID[:]); err != nil { return err } diff --git a/extern/storage-sealing/cbor_gen.go b/extern/storage-sealing/cbor_gen.go index c1e2b08fa..8794fdf4d 100644 --- a/extern/storage-sealing/cbor_gen.go +++ b/extern/storage-sealing/cbor_gen.go @@ -26,25 +26,26 @@ func (t *Piece) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{162}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { return err } - scratch := make([]byte, 9) - // t.Piece (abi.PieceInfo) (struct) if len("Piece") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Piece\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Piece"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Piece"))); err != nil { return err } if _, err := io.WriteString(w, string("Piece")); err != nil { return err } - if err := t.Piece.MarshalCBOR(w); err != nil { + if err := t.Piece.MarshalCBOR(cw); err != nil { return err } @@ -53,29 +54,34 @@ func (t *Piece) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"DealInfo\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealInfo"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealInfo"))); err != nil { return err } if _, err := io.WriteString(w, string("DealInfo")); err != nil { return err } - if err := t.DealInfo.MarshalCBOR(w); err != nil { + if err := t.DealInfo.MarshalCBOR(cw); err != nil { return err } return nil } -func (t *Piece) UnmarshalCBOR(r io.Reader) error { +func (t *Piece) UnmarshalCBOR(r io.Reader) (err error) { *t = Piece{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -90,7 +96,7 @@ func (t *Piece) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -104,7 +110,7 @@ func (t *Piece) UnmarshalCBOR(r io.Reader) error { { - if err := t.Piece.UnmarshalCBOR(br); err != nil { + if err := t.Piece.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Piece: %w", err) } @@ -114,16 +120,16 @@ func (t *Piece) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.DealInfo = new(api.PieceDealInfo) - if err := t.DealInfo.UnmarshalCBOR(br); err != nil { + if err := t.DealInfo.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.DealInfo pointer: %w", err) } } @@ -143,18 +149,19 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{184, 32}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{184, 32}); err != nil { return err } - scratch := make([]byte, 9) - // t.State (sealing.SectorState) (string) if len("State") > cbg.MaxLength { return xerrors.Errorf("Value in field \"State\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("State"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("State"))); err != nil { return err } if _, err := io.WriteString(w, string("State")); err != nil { @@ -165,7 +172,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.State was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.State))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { return err } if _, err := io.WriteString(w, string(t.State)); err != nil { @@ -177,14 +184,14 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"SectorNumber\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorNumber"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SectorNumber"))); err != nil { return err } if _, err := io.WriteString(w, string("SectorNumber")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorNumber)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.SectorNumber)); err != nil { return err } @@ -193,7 +200,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"SectorType\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorType"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SectorType"))); err != nil { return err } if _, err := io.WriteString(w, string("SectorType")); err != nil { @@ -201,11 +208,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.SectorType >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorType)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.SectorType)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SectorType-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.SectorType-1)); err != nil { return err } } @@ -215,7 +222,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CreationTime\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CreationTime"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CreationTime"))); err != nil { return err } if _, err := io.WriteString(w, string("CreationTime")); err != nil { @@ -223,11 +230,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.CreationTime >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.CreationTime)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.CreationTime)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.CreationTime-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.CreationTime-1)); err != nil { return err } } @@ -237,7 +244,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Pieces\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Pieces"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Pieces"))); err != nil { return err } if _, err := io.WriteString(w, string("Pieces")); err != nil { @@ -248,11 +255,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Pieces was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Pieces))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Pieces))); err != nil { return err } for _, v := range t.Pieces { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -262,7 +269,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"TicketValue\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("TicketValue"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("TicketValue"))); err != nil { return err } if _, err := io.WriteString(w, string("TicketValue")); err != nil { @@ -273,11 +280,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.TicketValue was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.TicketValue))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.TicketValue))); err != nil { return err } - if _, err := w.Write(t.TicketValue[:]); err != nil { + if _, err := cw.Write(t.TicketValue[:]); err != nil { return err } @@ -286,7 +293,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"TicketEpoch\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("TicketEpoch"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("TicketEpoch"))); err != nil { return err } if _, err := io.WriteString(w, string("TicketEpoch")); err != nil { @@ -294,11 +301,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.TicketEpoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TicketEpoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TicketEpoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TicketEpoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.TicketEpoch-1)); err != nil { return err } } @@ -308,7 +315,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PreCommit1Out\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommit1Out"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PreCommit1Out"))); err != nil { return err } if _, err := io.WriteString(w, string("PreCommit1Out")); err != nil { @@ -319,11 +326,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.PreCommit1Out was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.PreCommit1Out))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.PreCommit1Out))); err != nil { return err } - if _, err := w.Write(t.PreCommit1Out[:]); err != nil { + if _, err := cw.Write(t.PreCommit1Out[:]); err != nil { return err } @@ -332,7 +339,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CommD\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CommD"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CommD"))); err != nil { return err } if _, err := io.WriteString(w, string("CommD")); err != nil { @@ -340,11 +347,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.CommD == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.CommD); err != nil { + if err := cbg.WriteCid(cw, *t.CommD); err != nil { return xerrors.Errorf("failed to write cid field t.CommD: %w", err) } } @@ -354,7 +361,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CommR\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CommR"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CommR"))); err != nil { return err } if _, err := io.WriteString(w, string("CommR")); err != nil { @@ -362,11 +369,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.CommR == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.CommR); err != nil { + if err := cbg.WriteCid(cw, *t.CommR); err != nil { return xerrors.Errorf("failed to write cid field t.CommR: %w", err) } } @@ -376,7 +383,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Proof\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Proof"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Proof"))); err != nil { return err } if _, err := io.WriteString(w, string("Proof")); err != nil { @@ -387,11 +394,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Proof was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Proof))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Proof))); err != nil { return err } - if _, err := w.Write(t.Proof[:]); err != nil { + if _, err := cw.Write(t.Proof[:]); err != nil { return err } @@ -400,14 +407,14 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PreCommitInfo\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitInfo"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PreCommitInfo"))); err != nil { return err } if _, err := io.WriteString(w, string("PreCommitInfo")); err != nil { return err } - if err := t.PreCommitInfo.MarshalCBOR(w); err != nil { + if err := t.PreCommitInfo.MarshalCBOR(cw); err != nil { return err } @@ -416,14 +423,14 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PreCommitDeposit\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitDeposit"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PreCommitDeposit"))); err != nil { return err } if _, err := io.WriteString(w, string("PreCommitDeposit")); err != nil { return err } - if err := t.PreCommitDeposit.MarshalCBOR(w); err != nil { + if err := t.PreCommitDeposit.MarshalCBOR(cw); err != nil { return err } @@ -432,7 +439,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PreCommitMessage\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitMessage"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PreCommitMessage"))); err != nil { return err } if _, err := io.WriteString(w, string("PreCommitMessage")); err != nil { @@ -440,11 +447,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.PreCommitMessage == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.PreCommitMessage); err != nil { + if err := cbg.WriteCid(cw, *t.PreCommitMessage); err != nil { return xerrors.Errorf("failed to write cid field t.PreCommitMessage: %w", err) } } @@ -454,7 +461,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PreCommitTipSet\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitTipSet"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PreCommitTipSet"))); err != nil { return err } if _, err := io.WriteString(w, string("PreCommitTipSet")); err != nil { @@ -465,11 +472,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.PreCommitTipSet was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.PreCommitTipSet))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.PreCommitTipSet))); err != nil { return err } - if _, err := w.Write(t.PreCommitTipSet[:]); err != nil { + if _, err := cw.Write(t.PreCommitTipSet[:]); err != nil { return err } @@ -478,14 +485,14 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PreCommit2Fails\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommit2Fails"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PreCommit2Fails"))); err != nil { return err } if _, err := io.WriteString(w, string("PreCommit2Fails")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.PreCommit2Fails)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PreCommit2Fails)); err != nil { return err } @@ -494,7 +501,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"SeedValue\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SeedValue"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SeedValue"))); err != nil { return err } if _, err := io.WriteString(w, string("SeedValue")); err != nil { @@ -505,11 +512,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.SeedValue was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.SeedValue))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.SeedValue))); err != nil { return err } - if _, err := w.Write(t.SeedValue[:]); err != nil { + if _, err := cw.Write(t.SeedValue[:]); err != nil { return err } @@ -518,7 +525,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"SeedEpoch\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SeedEpoch"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SeedEpoch"))); err != nil { return err } if _, err := io.WriteString(w, string("SeedEpoch")); err != nil { @@ -526,11 +533,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.SeedEpoch >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SeedEpoch)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.SeedEpoch)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SeedEpoch-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.SeedEpoch-1)); err != nil { return err } } @@ -540,7 +547,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CommitMessage\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CommitMessage"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CommitMessage"))); err != nil { return err } if _, err := io.WriteString(w, string("CommitMessage")); err != nil { @@ -548,11 +555,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.CommitMessage == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.CommitMessage); err != nil { + if err := cbg.WriteCid(cw, *t.CommitMessage); err != nil { return xerrors.Errorf("failed to write cid field t.CommitMessage: %w", err) } } @@ -562,14 +569,14 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"InvalidProofs\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("InvalidProofs"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("InvalidProofs"))); err != nil { return err } if _, err := io.WriteString(w, string("InvalidProofs")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.InvalidProofs)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.InvalidProofs)); err != nil { return err } @@ -578,7 +585,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CCUpdate\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CCUpdate"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CCUpdate"))); err != nil { return err } if _, err := io.WriteString(w, string("CCUpdate")); err != nil { @@ -594,7 +601,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CCPieces\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CCPieces"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CCPieces"))); err != nil { return err } if _, err := io.WriteString(w, string("CCPieces")); err != nil { @@ -605,11 +612,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.CCPieces was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.CCPieces))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.CCPieces))); err != nil { return err } for _, v := range t.CCPieces { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -619,7 +626,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"UpdateSealed\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("UpdateSealed"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("UpdateSealed"))); err != nil { return err } if _, err := io.WriteString(w, string("UpdateSealed")); err != nil { @@ -627,11 +634,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.UpdateSealed == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.UpdateSealed); err != nil { + if err := cbg.WriteCid(cw, *t.UpdateSealed); err != nil { return xerrors.Errorf("failed to write cid field t.UpdateSealed: %w", err) } } @@ -641,7 +648,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"UpdateUnsealed\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("UpdateUnsealed"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("UpdateUnsealed"))); err != nil { return err } if _, err := io.WriteString(w, string("UpdateUnsealed")); err != nil { @@ -649,11 +656,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.UpdateUnsealed == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.UpdateUnsealed); err != nil { + if err := cbg.WriteCid(cw, *t.UpdateUnsealed); err != nil { return xerrors.Errorf("failed to write cid field t.UpdateUnsealed: %w", err) } } @@ -663,7 +670,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"ReplicaUpdateProof\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ReplicaUpdateProof"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ReplicaUpdateProof"))); err != nil { return err } if _, err := io.WriteString(w, string("ReplicaUpdateProof")); err != nil { @@ -674,11 +681,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.ReplicaUpdateProof was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.ReplicaUpdateProof))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.ReplicaUpdateProof))); err != nil { return err } - if _, err := w.Write(t.ReplicaUpdateProof[:]); err != nil { + if _, err := cw.Write(t.ReplicaUpdateProof[:]); err != nil { return err } @@ -687,7 +694,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"ReplicaUpdateMessage\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ReplicaUpdateMessage"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ReplicaUpdateMessage"))); err != nil { return err } if _, err := io.WriteString(w, string("ReplicaUpdateMessage")); err != nil { @@ -695,11 +702,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.ReplicaUpdateMessage == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.ReplicaUpdateMessage); err != nil { + if err := cbg.WriteCid(cw, *t.ReplicaUpdateMessage); err != nil { return xerrors.Errorf("failed to write cid field t.ReplicaUpdateMessage: %w", err) } } @@ -709,7 +716,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"FaultReportMsg\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("FaultReportMsg"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("FaultReportMsg"))); err != nil { return err } if _, err := io.WriteString(w, string("FaultReportMsg")); err != nil { @@ -717,11 +724,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.FaultReportMsg == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.FaultReportMsg); err != nil { + if err := cbg.WriteCid(cw, *t.FaultReportMsg); err != nil { return xerrors.Errorf("failed to write cid field t.FaultReportMsg: %w", err) } } @@ -731,7 +738,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Return\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Return"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Return"))); err != nil { return err } if _, err := io.WriteString(w, string("Return")); err != nil { @@ -742,7 +749,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Return was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Return))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Return))); err != nil { return err } if _, err := io.WriteString(w, string(t.Return)); err != nil { @@ -754,7 +761,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"TerminateMessage\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("TerminateMessage"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("TerminateMessage"))); err != nil { return err } if _, err := io.WriteString(w, string("TerminateMessage")); err != nil { @@ -762,11 +769,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.TerminateMessage == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.TerminateMessage); err != nil { + if err := cbg.WriteCid(cw, *t.TerminateMessage); err != nil { return xerrors.Errorf("failed to write cid field t.TerminateMessage: %w", err) } } @@ -776,7 +783,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"TerminatedAt\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("TerminatedAt"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("TerminatedAt"))); err != nil { return err } if _, err := io.WriteString(w, string("TerminatedAt")); err != nil { @@ -784,11 +791,11 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } if t.TerminatedAt >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TerminatedAt)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TerminatedAt)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TerminatedAt-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.TerminatedAt-1)); err != nil { return err } } @@ -798,7 +805,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"LastErr\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("LastErr"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("LastErr"))); err != nil { return err } if _, err := io.WriteString(w, string("LastErr")); err != nil { @@ -809,7 +816,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.LastErr was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.LastErr))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.LastErr))); err != nil { return err } if _, err := io.WriteString(w, string(t.LastErr)); err != nil { @@ -821,7 +828,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Log\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Log"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Log"))); err != nil { return err } if _, err := io.WriteString(w, string("Log")); err != nil { @@ -832,27 +839,32 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Log was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Log))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Log))); err != nil { return err } for _, v := range t.Log { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } return nil } -func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { +func (t *SectorInfo) UnmarshalCBOR(r io.Reader) (err error) { *t = SectorInfo{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -867,7 +879,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -880,7 +892,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { case "State": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -892,7 +904,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -905,7 +917,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.SectorType (abi.RegisteredSealProof) (int64) case "SectorType": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -931,7 +943,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.CreationTime (int64) (int64) case "CreationTime": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -957,7 +969,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.Pieces ([]sealing.Piece) (slice) case "Pieces": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -977,7 +989,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v Piece - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -987,7 +999,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.TicketValue (abi.SealRandomness) (slice) case "TicketValue": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1003,13 +1015,13 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.TicketValue = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.TicketValue[:]); err != nil { + if _, err := io.ReadFull(cr, t.TicketValue[:]); err != nil { return err } // t.TicketEpoch (abi.ChainEpoch) (int64) case "TicketEpoch": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1035,7 +1047,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.PreCommit1Out (storage.PreCommit1Out) (slice) case "PreCommit1Out": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1051,7 +1063,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.PreCommit1Out = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.PreCommit1Out[:]); err != nil { + if _, err := io.ReadFull(cr, t.PreCommit1Out[:]); err != nil { return err } // t.CommD (cid.Cid) (struct) @@ -1059,16 +1071,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.CommD: %w", err) } @@ -1082,16 +1094,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.CommR: %w", err) } @@ -1103,7 +1115,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.Proof ([]uint8) (slice) case "Proof": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1119,7 +1131,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.Proof = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Proof[:]); err != nil { + if _, err := io.ReadFull(cr, t.Proof[:]); err != nil { return err } // t.PreCommitInfo (miner.SectorPreCommitInfo) (struct) @@ -1127,16 +1139,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.PreCommitInfo = new(miner.SectorPreCommitInfo) - if err := t.PreCommitInfo.UnmarshalCBOR(br); err != nil { + if err := t.PreCommitInfo.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.PreCommitInfo pointer: %w", err) } } @@ -1147,7 +1159,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.PreCommitDeposit.UnmarshalCBOR(br); err != nil { + if err := t.PreCommitDeposit.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.PreCommitDeposit: %w", err) } @@ -1157,16 +1169,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.PreCommitMessage: %w", err) } @@ -1178,7 +1190,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.PreCommitTipSet (sealing.TipSetToken) (slice) case "PreCommitTipSet": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1194,7 +1206,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.PreCommitTipSet = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.PreCommitTipSet[:]); err != nil { + if _, err := io.ReadFull(cr, t.PreCommitTipSet[:]); err != nil { return err } // t.PreCommit2Fails (uint64) (uint64) @@ -1202,7 +1214,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1215,7 +1227,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.SeedValue (abi.InteractiveSealRandomness) (slice) case "SeedValue": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1231,13 +1243,13 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.SeedValue = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.SeedValue[:]); err != nil { + if _, err := io.ReadFull(cr, t.SeedValue[:]); err != nil { return err } // t.SeedEpoch (abi.ChainEpoch) (int64) case "SeedEpoch": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1265,16 +1277,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.CommitMessage: %w", err) } @@ -1288,7 +1300,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1301,7 +1313,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.CCUpdate (bool) (bool) case "CCUpdate": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1319,7 +1331,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.CCPieces ([]sealing.Piece) (slice) case "CCPieces": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1339,7 +1351,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v Piece - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -1351,16 +1363,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.UpdateSealed: %w", err) } @@ -1374,16 +1386,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.UpdateUnsealed: %w", err) } @@ -1395,7 +1407,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.ReplicaUpdateProof (storage.ReplicaUpdateProof) (slice) case "ReplicaUpdateProof": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1411,7 +1423,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { t.ReplicaUpdateProof = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.ReplicaUpdateProof[:]); err != nil { + if _, err := io.ReadFull(cr, t.ReplicaUpdateProof[:]); err != nil { return err } // t.ReplicaUpdateMessage (cid.Cid) (struct) @@ -1419,16 +1431,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.ReplicaUpdateMessage: %w", err) } @@ -1442,16 +1454,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.FaultReportMsg: %w", err) } @@ -1464,7 +1476,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { case "Return": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -1476,16 +1488,16 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.TerminateMessage: %w", err) } @@ -1497,7 +1509,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.TerminatedAt (abi.ChainEpoch) (int64) case "TerminatedAt": { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -1524,7 +1536,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { case "LastErr": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -1534,7 +1546,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { // t.Log ([]sealing.Log) (slice) case "Log": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1554,7 +1566,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v Log - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -1574,25 +1586,26 @@ func (t *Log) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{164}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{164}); err != nil { return err } - scratch := make([]byte, 9) - // t.Timestamp (uint64) (uint64) if len("Timestamp") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Timestamp\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Timestamp"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Timestamp"))); err != nil { return err } if _, err := io.WriteString(w, string("Timestamp")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Timestamp)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Timestamp)); err != nil { return err } @@ -1601,7 +1614,7 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Trace\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Trace"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Trace"))); err != nil { return err } if _, err := io.WriteString(w, string("Trace")); err != nil { @@ -1612,7 +1625,7 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Trace was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Trace))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Trace))); err != nil { return err } if _, err := io.WriteString(w, string(t.Trace)); err != nil { @@ -1624,7 +1637,7 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Message\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Message"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Message"))); err != nil { return err } if _, err := io.WriteString(w, string("Message")); err != nil { @@ -1635,7 +1648,7 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Message was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Message))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil { return err } if _, err := io.WriteString(w, string(t.Message)); err != nil { @@ -1647,7 +1660,7 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Kind\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Kind"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Kind"))); err != nil { return err } if _, err := io.WriteString(w, string("Kind")); err != nil { @@ -1658,7 +1671,7 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Kind was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Kind))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil { return err } if _, err := io.WriteString(w, string(t.Kind)); err != nil { @@ -1667,16 +1680,21 @@ func (t *Log) MarshalCBOR(w io.Writer) error { return nil } -func (t *Log) UnmarshalCBOR(r io.Reader) error { +func (t *Log) UnmarshalCBOR(r io.Reader) (err error) { *t = Log{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -1691,7 +1709,7 @@ func (t *Log) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -1705,7 +1723,7 @@ func (t *Log) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -1719,7 +1737,7 @@ func (t *Log) UnmarshalCBOR(r io.Reader) error { case "Trace": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -1730,7 +1748,7 @@ func (t *Log) UnmarshalCBOR(r io.Reader) error { case "Message": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -1741,7 +1759,7 @@ func (t *Log) UnmarshalCBOR(r io.Reader) error { case "Kind": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } diff --git a/node/hello/cbor_gen.go b/node/hello/cbor_gen.go index 145a19728..68c82e2bb 100644 --- a/node/hello/cbor_gen.go +++ b/node/hello/cbor_gen.go @@ -26,61 +26,67 @@ func (t *HelloMessage) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufHelloMessage); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufHelloMessage); err != nil { return err } - scratch := make([]byte, 9) - // t.HeaviestTipSet ([]cid.Cid) (slice) if len(t.HeaviestTipSet) > cbg.MaxLength { return xerrors.Errorf("Slice value in field t.HeaviestTipSet was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.HeaviestTipSet))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.HeaviestTipSet))); err != nil { return err } for _, v := range t.HeaviestTipSet { - if err := cbg.WriteCidBuf(scratch, w, v); err != nil { + if err := cbg.WriteCid(w, v); err != nil { return xerrors.Errorf("failed writing cid field t.HeaviestTipSet: %w", err) } } // t.HeaviestTipSetHeight (abi.ChainEpoch) (int64) if t.HeaviestTipSetHeight >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.HeaviestTipSetHeight)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.HeaviestTipSetHeight)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.HeaviestTipSetHeight-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.HeaviestTipSetHeight-1)); err != nil { return err } } // t.HeaviestTipSetWeight (big.Int) (struct) - if err := t.HeaviestTipSetWeight.MarshalCBOR(w); err != nil { + if err := t.HeaviestTipSetWeight.MarshalCBOR(cw); err != nil { return err } // t.GenesisHash (cid.Cid) (struct) - if err := cbg.WriteCidBuf(scratch, w, t.GenesisHash); err != nil { + if err := cbg.WriteCid(cw, t.GenesisHash); err != nil { return xerrors.Errorf("failed to write cid field t.GenesisHash: %w", err) } return nil } -func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error { +func (t *HelloMessage) UnmarshalCBOR(r io.Reader) (err error) { *t = HelloMessage{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -91,7 +97,7 @@ func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error { // t.HeaviestTipSet ([]cid.Cid) (slice) - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -110,7 +116,7 @@ func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("reading cid field t.HeaviestTipSet failed: %w", err) } @@ -119,7 +125,7 @@ func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error { // t.HeaviestTipSetHeight (abi.ChainEpoch) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -146,7 +152,7 @@ func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error { { - if err := t.HeaviestTipSetWeight.UnmarshalCBOR(br); err != nil { + if err := t.HeaviestTipSetWeight.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.HeaviestTipSetWeight: %w", err) } @@ -155,7 +161,7 @@ func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.GenesisHash: %w", err) } @@ -173,46 +179,52 @@ func (t *LatencyMessage) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write(lengthBufLatencyMessage); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write(lengthBufLatencyMessage); err != nil { return err } - scratch := make([]byte, 9) - // t.TArrival (int64) (int64) if t.TArrival >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TArrival)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TArrival)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TArrival-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.TArrival-1)); err != nil { return err } } // t.TSent (int64) (int64) if t.TSent >= 0 { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TSent)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.TSent)); err != nil { return err } } else { - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TSent-1)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.TSent-1)); err != nil { return err } } return nil } -func (t *LatencyMessage) UnmarshalCBOR(r io.Reader) error { +func (t *LatencyMessage) UnmarshalCBOR(r io.Reader) (err error) { *t = LatencyMessage{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajArray { return fmt.Errorf("cbor input should be of type array") } @@ -223,7 +235,7 @@ func (t *LatencyMessage) UnmarshalCBOR(r io.Reader) error { // t.TArrival (int64) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err @@ -248,7 +260,7 @@ func (t *LatencyMessage) UnmarshalCBOR(r io.Reader) error { } // t.TSent (int64) (int64) { - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() var extraI int64 if err != nil { return err diff --git a/paychmgr/cbor_gen.go b/paychmgr/cbor_gen.go index 428c09a9e..9f12b60a2 100644 --- a/paychmgr/cbor_gen.go +++ b/paychmgr/cbor_gen.go @@ -25,25 +25,26 @@ func (t *VoucherInfo) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{163}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{163}); err != nil { return err } - scratch := make([]byte, 9) - // t.Voucher (paych.SignedVoucher) (struct) if len("Voucher") > cbg.MaxLength { return xerrors.Errorf("Value in field \"Voucher\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Voucher"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Voucher"))); err != nil { return err } if _, err := io.WriteString(w, string("Voucher")); err != nil { return err } - if err := t.Voucher.MarshalCBOR(w); err != nil { + if err := t.Voucher.MarshalCBOR(cw); err != nil { return err } @@ -52,7 +53,7 @@ func (t *VoucherInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Proof\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Proof"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Proof"))); err != nil { return err } if _, err := io.WriteString(w, string("Proof")); err != nil { @@ -63,11 +64,11 @@ func (t *VoucherInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Byte array in field t.Proof was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Proof))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Proof))); err != nil { return err } - if _, err := w.Write(t.Proof[:]); err != nil { + if _, err := cw.Write(t.Proof[:]); err != nil { return err } @@ -76,7 +77,7 @@ func (t *VoucherInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Submitted\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Submitted"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Submitted"))); err != nil { return err } if _, err := io.WriteString(w, string("Submitted")); err != nil { @@ -89,16 +90,21 @@ func (t *VoucherInfo) MarshalCBOR(w io.Writer) error { return nil } -func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error { +func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) (err error) { *t = VoucherInfo{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -113,7 +119,7 @@ func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -127,16 +133,16 @@ func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Voucher = new(paych.SignedVoucher) - if err := t.Voucher.UnmarshalCBOR(br); err != nil { + if err := t.Voucher.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Voucher pointer: %w", err) } } @@ -145,7 +151,7 @@ func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error { // t.Proof ([]uint8) (slice) case "Proof": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -161,13 +167,13 @@ func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error { t.Proof = make([]uint8, extra) } - if _, err := io.ReadFull(br, t.Proof[:]); err != nil { + if _, err := io.ReadFull(cr, t.Proof[:]); err != nil { return err } // t.Submitted (bool) (bool) case "Submitted": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -196,18 +202,19 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{174}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{174}); err != nil { return err } - scratch := make([]byte, 9) - // t.ChannelID (string) (string) if len("ChannelID") > cbg.MaxLength { return xerrors.Errorf("Value in field \"ChannelID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ChannelID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ChannelID"))); err != nil { return err } if _, err := io.WriteString(w, string("ChannelID")); err != nil { @@ -218,7 +225,7 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.ChannelID was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.ChannelID))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChannelID))); err != nil { return err } if _, err := io.WriteString(w, string(t.ChannelID)); err != nil { @@ -230,14 +237,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Channel\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Channel"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Channel"))); err != nil { return err } if _, err := io.WriteString(w, string("Channel")); err != nil { return err } - if err := t.Channel.MarshalCBOR(w); err != nil { + if err := t.Channel.MarshalCBOR(cw); err != nil { return err } @@ -246,14 +253,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Control\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Control"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Control"))); err != nil { return err } if _, err := io.WriteString(w, string("Control")); err != nil { return err } - if err := t.Control.MarshalCBOR(w); err != nil { + if err := t.Control.MarshalCBOR(cw); err != nil { return err } @@ -262,14 +269,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Target\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Target"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Target"))); err != nil { return err } if _, err := io.WriteString(w, string("Target")); err != nil { return err } - if err := t.Target.MarshalCBOR(w); err != nil { + if err := t.Target.MarshalCBOR(cw); err != nil { return err } @@ -278,14 +285,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Direction\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Direction"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Direction"))); err != nil { return err } if _, err := io.WriteString(w, string("Direction")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Direction)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Direction)); err != nil { return err } @@ -294,7 +301,7 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Vouchers\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Vouchers"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Vouchers"))); err != nil { return err } if _, err := io.WriteString(w, string("Vouchers")); err != nil { @@ -305,11 +312,11 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Slice value in field t.Vouchers was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Vouchers))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Vouchers))); err != nil { return err } for _, v := range t.Vouchers { - if err := v.MarshalCBOR(w); err != nil { + if err := v.MarshalCBOR(cw); err != nil { return err } } @@ -319,14 +326,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"NextLane\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("NextLane"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("NextLane"))); err != nil { return err } if _, err := io.WriteString(w, string("NextLane")); err != nil { return err } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.NextLane)); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.NextLane)); err != nil { return err } @@ -335,14 +342,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Amount\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Amount"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Amount"))); err != nil { return err } if _, err := io.WriteString(w, string("Amount")); err != nil { return err } - if err := t.Amount.MarshalCBOR(w); err != nil { + if err := t.Amount.MarshalCBOR(cw); err != nil { return err } @@ -351,14 +358,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"AvailableAmount\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("AvailableAmount"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("AvailableAmount"))); err != nil { return err } if _, err := io.WriteString(w, string("AvailableAmount")); err != nil { return err } - if err := t.AvailableAmount.MarshalCBOR(w); err != nil { + if err := t.AvailableAmount.MarshalCBOR(cw); err != nil { return err } @@ -367,14 +374,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PendingAvailableAmount\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PendingAvailableAmount"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PendingAvailableAmount"))); err != nil { return err } if _, err := io.WriteString(w, string("PendingAvailableAmount")); err != nil { return err } - if err := t.PendingAvailableAmount.MarshalCBOR(w); err != nil { + if err := t.PendingAvailableAmount.MarshalCBOR(cw); err != nil { return err } @@ -383,14 +390,14 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"PendingAmount\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PendingAmount"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("PendingAmount"))); err != nil { return err } if _, err := io.WriteString(w, string("PendingAmount")); err != nil { return err } - if err := t.PendingAmount.MarshalCBOR(w); err != nil { + if err := t.PendingAmount.MarshalCBOR(cw); err != nil { return err } @@ -399,7 +406,7 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"CreateMsg\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CreateMsg"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("CreateMsg"))); err != nil { return err } if _, err := io.WriteString(w, string("CreateMsg")); err != nil { @@ -407,11 +414,11 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { } if t.CreateMsg == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.CreateMsg); err != nil { + if err := cbg.WriteCid(cw, *t.CreateMsg); err != nil { return xerrors.Errorf("failed to write cid field t.CreateMsg: %w", err) } } @@ -421,7 +428,7 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"AddFundsMsg\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("AddFundsMsg"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("AddFundsMsg"))); err != nil { return err } if _, err := io.WriteString(w, string("AddFundsMsg")); err != nil { @@ -429,11 +436,11 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { } if t.AddFundsMsg == nil { - if _, err := w.Write(cbg.CborNull); err != nil { + if _, err := cw.Write(cbg.CborNull); err != nil { return err } } else { - if err := cbg.WriteCidBuf(scratch, w, *t.AddFundsMsg); err != nil { + if err := cbg.WriteCid(cw, *t.AddFundsMsg); err != nil { return xerrors.Errorf("failed to write cid field t.AddFundsMsg: %w", err) } } @@ -443,7 +450,7 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Settling\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Settling"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Settling"))); err != nil { return err } if _, err := io.WriteString(w, string("Settling")); err != nil { @@ -456,16 +463,21 @@ func (t *ChannelInfo) MarshalCBOR(w io.Writer) error { return nil } -func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { +func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) (err error) { *t = ChannelInfo{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -480,7 +492,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -493,7 +505,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { case "ChannelID": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -505,16 +517,16 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } t.Channel = new(address.Address) - if err := t.Channel.UnmarshalCBOR(br); err != nil { + if err := t.Channel.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Channel pointer: %w", err) } } @@ -525,7 +537,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.Control.UnmarshalCBOR(br); err != nil { + if err := t.Control.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Control: %w", err) } @@ -535,7 +547,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.Target.UnmarshalCBOR(br); err != nil { + if err := t.Target.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Target: %w", err) } @@ -545,7 +557,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -558,7 +570,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { // t.Vouchers ([]*paychmgr.VoucherInfo) (slice) case "Vouchers": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -578,7 +590,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { for i := 0; i < int(extra); i++ { var v VoucherInfo - if err := v.UnmarshalCBOR(br); err != nil { + if err := v.UnmarshalCBOR(cr); err != nil { return err } @@ -590,7 +602,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -605,7 +617,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.Amount.UnmarshalCBOR(br); err != nil { + if err := t.Amount.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.Amount: %w", err) } @@ -615,7 +627,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.AvailableAmount.UnmarshalCBOR(br); err != nil { + if err := t.AvailableAmount.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.AvailableAmount: %w", err) } @@ -625,7 +637,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.PendingAvailableAmount.UnmarshalCBOR(br); err != nil { + if err := t.PendingAvailableAmount.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.PendingAvailableAmount: %w", err) } @@ -635,7 +647,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - if err := t.PendingAmount.UnmarshalCBOR(br); err != nil { + if err := t.PendingAmount.UnmarshalCBOR(cr); err != nil { return xerrors.Errorf("unmarshaling t.PendingAmount: %w", err) } @@ -645,16 +657,16 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.CreateMsg: %w", err) } @@ -668,16 +680,16 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { { - b, err := br.ReadByte() + b, err := cr.ReadByte() if err != nil { return err } if b != cbg.CborNull[0] { - if err := br.UnreadByte(); err != nil { + if err := cr.UnreadByte(); err != nil { return err } - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.AddFundsMsg: %w", err) } @@ -689,7 +701,7 @@ func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error { // t.Settling (bool) (bool) case "Settling": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -718,18 +730,19 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { _, err := w.Write(cbg.CborNull) return err } - if _, err := w.Write([]byte{164}); err != nil { + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{164}); err != nil { return err } - scratch := make([]byte, 9) - // t.ChannelID (string) (string) if len("ChannelID") > cbg.MaxLength { return xerrors.Errorf("Value in field \"ChannelID\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ChannelID"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ChannelID"))); err != nil { return err } if _, err := io.WriteString(w, string("ChannelID")); err != nil { @@ -740,7 +753,7 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.ChannelID was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.ChannelID))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChannelID))); err != nil { return err } if _, err := io.WriteString(w, string(t.ChannelID)); err != nil { @@ -752,14 +765,14 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"MsgCid\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("MsgCid"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MsgCid"))); err != nil { return err } if _, err := io.WriteString(w, string("MsgCid")); err != nil { return err } - if err := cbg.WriteCidBuf(scratch, w, t.MsgCid); err != nil { + if err := cbg.WriteCid(cw, t.MsgCid); err != nil { return xerrors.Errorf("failed to write cid field t.MsgCid: %w", err) } @@ -768,7 +781,7 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Received\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Received"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Received"))); err != nil { return err } if _, err := io.WriteString(w, string("Received")); err != nil { @@ -784,7 +797,7 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field \"Err\" was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Err"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Err"))); err != nil { return err } if _, err := io.WriteString(w, string("Err")); err != nil { @@ -795,7 +808,7 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { return xerrors.Errorf("Value in field t.Err was too long") } - if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Err))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Err))); err != nil { return err } if _, err := io.WriteString(w, string(t.Err)); err != nil { @@ -804,16 +817,21 @@ func (t *MsgInfo) MarshalCBOR(w io.Writer) error { return nil } -func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error { +func (t *MsgInfo) UnmarshalCBOR(r io.Reader) (err error) { *t = MsgInfo{} - br := cbg.GetPeeker(r) - scratch := make([]byte, 8) + cr := cbg.NewCborReader(r) - maj, extra, err := cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + if maj != cbg.MajMap { return fmt.Errorf("cbor input should be of type map") } @@ -828,7 +846,7 @@ func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error { for i := uint64(0); i < n; i++ { { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -841,7 +859,7 @@ func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error { case "ChannelID": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } @@ -853,7 +871,7 @@ func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error { { - c, err := cbg.ReadCid(br) + c, err := cbg.ReadCid(cr) if err != nil { return xerrors.Errorf("failed to read cid field t.MsgCid: %w", err) } @@ -864,7 +882,7 @@ func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error { // t.Received (bool) (bool) case "Received": - maj, extra, err = cbg.CborReadHeaderBuf(br, scratch) + maj, extra, err = cr.ReadHeader() if err != nil { return err } @@ -883,7 +901,7 @@ func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error { case "Err": { - sval, err := cbg.ReadStringBuf(br, scratch) + sval, err := cbg.ReadString(cr) if err != nil { return err } From bacaccc3788105eaea9ed01b03e0866ff737266b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Tue, 24 May 2022 15:07:53 +0200 Subject: [PATCH 32/37] feat: miner cli: sealing data-cid command --- cmd/lotus-miner/sealing.go | 69 +++++++++++++++++++++++++++++ documentation/en/cli-lotus-miner.md | 14 ++++++ 2 files changed, 83 insertions(+) diff --git a/cmd/lotus-miner/sealing.go b/cmd/lotus-miner/sealing.go index 4f048ad17..34deb60ab 100644 --- a/cmd/lotus-miner/sealing.go +++ b/cmd/lotus-miner/sealing.go @@ -11,11 +11,15 @@ import ( "text/tabwriter" "time" + "github.com/dustin/go-humanize" "github.com/fatih/color" "github.com/google/uuid" + "github.com/mitchellh/go-homedir" "github.com/urfave/cli/v2" "golang.org/x/xerrors" + "github.com/filecoin-project/go-padreader" + "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/lotus/extern/sector-storage/sealtasks" "github.com/filecoin-project/lotus/extern/sector-storage/storiface" @@ -31,6 +35,7 @@ var sealingCmd = &cli.Command{ workersCmd(true), sealingSchedDiagCmd, sealingAbortCmd, + sealingDataCidCmd, }, } @@ -349,3 +354,67 @@ var sealingAbortCmd = &cli.Command{ return nodeApi.SealingAbort(ctx, job.ID) }, } + +var sealingDataCidCmd = &cli.Command{ + Name: "data-cid", + Usage: "Compute data CID using workers", + ArgsUsage: "[file] ", + Action: func(cctx *cli.Context) error { + if cctx.Args().Len() < 1 || cctx.Args().Len() > 2 { + return xerrors.Errorf("expected 1 or 2 arguments") + } + + nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx) + if err != nil { + return err + } + defer closer() + + ctx := lcli.ReqContext(cctx) + + p, err := homedir.Expand(cctx.Args().First()) + if err != nil { + return xerrors.Errorf("expanding path: %w", err) + } + + f, err := os.OpenFile(p, os.O_RDONLY, 0) + if err != nil { + return xerrors.Errorf("opening source file: %w", err) + } + + st, err := f.Stat() + if err != nil { + return xerrors.Errorf("stat: %w", err) + } + + var psize abi.PaddedPieceSize + if cctx.Args().Len() == 2 { + rps, err := humanize.ParseBytes(cctx.Args().Get(1)) + if err != nil { + return xerrors.Errorf("parsing piece size: %w", err) + } + psize = abi.PaddedPieceSize(rps) + if err := psize.Validate(); err != nil { + return xerrors.Errorf("checking piece size: %w", err) + } + if st.Size() > int64(psize.Unpadded()) { + return xerrors.Errorf("file larger than the piece") + } + } else { + psize = padreader.PaddedSize(uint64(st.Size())).Padded() + } + + ir, err := padreader.NewInflator(f, uint64(st.Size()), psize.Unpadded()) + if err != nil { + return err + } + + pc, err := nodeApi.ComputeDataCid(ctx, psize.Unpadded(), ir) + if err != nil { + return xerrors.Errorf("computing data CID: %w", err) + } + + fmt.Println(pc.PieceCID, " ", pc.Size) + return nil + }, +} diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index 73c996348..941d8c525 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -2331,6 +2331,7 @@ COMMANDS: workers list workers sched-diag Dump internal scheduler state abort Abort a running job + data-cid Compute data CID help, h Shows a list of commands or help for one command OPTIONS: @@ -2393,3 +2394,16 @@ OPTIONS: --help, -h show help (default: false) ``` + +### lotus-miner sealing data-cid +``` +NAME: + lotus-miner sealing data-cid - Compute data CID + +USAGE: + lotus-miner sealing data-cid [command options] [file] + +OPTIONS: + --help, -h show help (default: false) + +``` From 6095aba4dd3ae1ab48389baf8564bb86e6392763 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Tue, 24 May 2022 15:47:23 +0200 Subject: [PATCH 33/37] lib: support http readers passing over jsonrpc --- lib/httpreader/httpreader.go | 47 ++++++++++++++++++++++++++++++++++++ lib/rpcenc/reader.go | 10 +++++++- 2 files changed, 56 insertions(+), 1 deletion(-) create mode 100644 lib/httpreader/httpreader.go diff --git a/lib/httpreader/httpreader.go b/lib/httpreader/httpreader.go new file mode 100644 index 000000000..62338e76e --- /dev/null +++ b/lib/httpreader/httpreader.go @@ -0,0 +1,47 @@ +package httpreader + +import ( + "io" + "net/http" + + "golang.org/x/xerrors" +) + +// HttpReader is a reader which will read a http resource with a simple get request. +// Before first Read it will be passed over JsonRPC as a URL. +type HttpReader struct { + URL string + + reader io.ReadCloser +} + +func (h *HttpReader) Close() error { + h.URL = "" + if h.reader != nil { + return h.reader.Close() + } + return nil +} + +func (h *HttpReader) Read(p []byte) (n int, err error) { + if h.reader == nil { + res, err := http.Get(h.URL) + if err != nil { + return 0, err + } + if res.StatusCode != http.StatusOK { + return 0, xerrors.Errorf("unexpected http status %d", res.StatusCode) + } + + // mark the reader as reading + h.URL = "" + h.reader = res.Body + } + if h.reader == nil { + return 0, xerrors.Errorf("http reader closed") + } + + return h.reader.Read(p) +} + +var _ io.ReadCloser = &HttpReader{} diff --git a/lib/rpcenc/reader.go b/lib/rpcenc/reader.go index 4e3ebb8c2..0f268aadf 100644 --- a/lib/rpcenc/reader.go +++ b/lib/rpcenc/reader.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "github.com/filecoin-project/lotus/lib/httpreader" "io" "io/ioutil" "net/http" @@ -34,6 +35,7 @@ type StreamType string const ( Null StreamType = "null" PushStream StreamType = "push" + HttpUrl StreamType = "http" // TODO: Data transfer handoff to workers? ) @@ -105,6 +107,9 @@ func ReaderParamEncoder(addr string) jsonrpc.Option { if r, ok := r.(*nullreader.NullReader); ok { return reflect.ValueOf(ReaderStream{Type: Null, Info: fmt.Sprint(r.N)}), nil } + if r, ok := r.(*httpreader.HttpReader); ok && r.URL != "" { + return reflect.ValueOf(ReaderStream{Type: HttpUrl, Info: r.URL}), nil + } reqID := uuid.New() u, err := url.Parse(addr) @@ -413,13 +418,16 @@ func ReaderParamDecoder() (http.HandlerFunc, jsonrpc.ServerOption) { return reflect.Value{}, xerrors.Errorf("unmarshaling reader id: %w", err) } - if rs.Type == Null { + switch rs.Type { + case Null: n, err := strconv.ParseInt(rs.Info, 10, 64) if err != nil { return reflect.Value{}, xerrors.Errorf("parsing null byte count: %w", err) } return reflect.ValueOf(nullreader.NewNullReader(abi.UnpaddedPieceSize(n))), nil + case HttpUrl: + return reflect.ValueOf(&httpreader.HttpReader{URL: rs.Info}), nil } u, err := uuid.Parse(rs.Info) From 3fa2ada9870981ef2d6d229aa3c5db06f3547490 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Tue, 24 May 2022 15:47:49 +0200 Subject: [PATCH 34/37] support http in lotus-miner sealing data-cid --- cmd/lotus-miner/sealing.go | 70 +++++++++++++++++++++++++++----------- 1 file changed, 50 insertions(+), 20 deletions(-) diff --git a/cmd/lotus-miner/sealing.go b/cmd/lotus-miner/sealing.go index 34deb60ab..8a8d6c18d 100644 --- a/cmd/lotus-miner/sealing.go +++ b/cmd/lotus-miner/sealing.go @@ -4,7 +4,10 @@ import ( "encoding/hex" "encoding/json" "fmt" + "github.com/filecoin-project/lotus/lib/httpreader" + "io" "math" + "net/http" "os" "sort" "strings" @@ -358,7 +361,13 @@ var sealingAbortCmd = &cli.Command{ var sealingDataCidCmd = &cli.Command{ Name: "data-cid", Usage: "Compute data CID using workers", - ArgsUsage: "[file] ", + ArgsUsage: "[file/url] ", + Flags: []cli.Flag{ + &cli.Uint64Flag{ + Name: "file-size", + Usage: "real file size", + }, + }, Action: func(cctx *cli.Context) error { if cctx.Args().Len() < 1 || cctx.Args().Len() > 2 { return xerrors.Errorf("expected 1 or 2 arguments") @@ -372,19 +381,45 @@ var sealingDataCidCmd = &cli.Command{ ctx := lcli.ReqContext(cctx) - p, err := homedir.Expand(cctx.Args().First()) - if err != nil { - return xerrors.Errorf("expanding path: %w", err) - } + var r io.Reader + sz := cctx.Uint64("file-size") - f, err := os.OpenFile(p, os.O_RDONLY, 0) - if err != nil { - return xerrors.Errorf("opening source file: %w", err) - } + if strings.HasPrefix(cctx.Args().First(), "http://") || strings.HasPrefix(cctx.Args().First(), "https://") { + r = &httpreader.HttpReader{ + URL: cctx.Args().First(), + } - st, err := f.Stat() - if err != nil { - return xerrors.Errorf("stat: %w", err) + if !cctx.IsSet("file-size") { + resp, err := http.Head(cctx.Args().First()) + if err != nil { + return xerrors.Errorf("http head: %w", err) + } + + if resp.ContentLength < 0 { + return xerrors.Errorf("head response didn't contain content length; specify --file-size") + } + sz = uint64(resp.ContentLength) + } + } else { + p, err := homedir.Expand(cctx.Args().First()) + if err != nil { + return xerrors.Errorf("expanding path: %w", err) + } + + f, err := os.OpenFile(p, os.O_RDONLY, 0) + if err != nil { + return xerrors.Errorf("opening source file: %w", err) + } + + if !cctx.IsSet("file-size") { + st, err := f.Stat() + if err != nil { + return xerrors.Errorf("stat: %w", err) + } + sz = uint64(st.Size()) + } + + r = f } var psize abi.PaddedPieceSize @@ -397,19 +432,14 @@ var sealingDataCidCmd = &cli.Command{ if err := psize.Validate(); err != nil { return xerrors.Errorf("checking piece size: %w", err) } - if st.Size() > int64(psize.Unpadded()) { + if sz > uint64(psize.Unpadded()) { return xerrors.Errorf("file larger than the piece") } } else { - psize = padreader.PaddedSize(uint64(st.Size())).Padded() + psize = padreader.PaddedSize(uint64(sz)).Padded() } - ir, err := padreader.NewInflator(f, uint64(st.Size()), psize.Unpadded()) - if err != nil { - return err - } - - pc, err := nodeApi.ComputeDataCid(ctx, psize.Unpadded(), ir) + pc, err := nodeApi.ComputeDataCid(ctx, psize.Unpadded(), r) if err != nil { return xerrors.Errorf("computing data CID: %w", err) } From 7054475c00af5a31a45604e47d6002ddb8940c9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Tue, 24 May 2022 15:59:11 +0200 Subject: [PATCH 35/37] ffiwrapper: Handle null padding in DataCid automatically --- cmd/lotus-miner/sealing.go | 2 +- .../sector-storage/ffiwrapper/sealer_cgo.go | 7 +++++++ itests/worker_test.go | 20 ++++++++++++------- 3 files changed, 21 insertions(+), 8 deletions(-) diff --git a/cmd/lotus-miner/sealing.go b/cmd/lotus-miner/sealing.go index 8a8d6c18d..3ce3ae88c 100644 --- a/cmd/lotus-miner/sealing.go +++ b/cmd/lotus-miner/sealing.go @@ -436,7 +436,7 @@ var sealingDataCidCmd = &cli.Command{ return xerrors.Errorf("file larger than the piece") } } else { - psize = padreader.PaddedSize(uint64(sz)).Padded() + psize = padreader.PaddedSize(sz).Padded() } pc, err := nodeApi.ComputeDataCid(ctx, psize.Unpadded(), r) diff --git a/extern/sector-storage/ffiwrapper/sealer_cgo.go b/extern/sector-storage/ffiwrapper/sealer_cgo.go index 79de4fdb9..d63e83c6e 100644 --- a/extern/sector-storage/ffiwrapper/sealer_cgo.go +++ b/extern/sector-storage/ffiwrapper/sealer_cgo.go @@ -32,6 +32,7 @@ import ( "github.com/filecoin-project/lotus/extern/sector-storage/partialfile" "github.com/filecoin-project/lotus/extern/sector-storage/storiface" nr "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/filecoin-project/lotus/lib/nullreader" ) var _ Storage = &Sealer{} @@ -53,6 +54,11 @@ func (sb *Sealer) NewSector(ctx context.Context, sector storage.SectorRef) error } func (sb *Sealer) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) { + pieceData = io.LimitReader(io.MultiReader( + pieceData, + nullreader.Reader{}, + ), int64(pieceSize)) + // TODO: allow tuning those: chunk := abi.PaddedPieceSize(4 << 20) parallel := runtime.NumCPU() @@ -73,6 +79,7 @@ func (sb *Sealer) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, for { var read int for rbuf := buf; len(rbuf) > 0; { + n, err := pieceData.Read(rbuf) if err != nil && err != io.EOF { return abi.PieceInfo{}, xerrors.Errorf("pr read error: %w", err) diff --git a/itests/worker_test.go b/itests/worker_test.go index c1fba2600..0d20c2f19 100644 --- a/itests/worker_test.go +++ b/itests/worker_test.go @@ -49,17 +49,23 @@ func TestWorkerDataCid(t *testing.T) { e, err := worker.Enabled(ctx) require.NoError(t, err) require.True(t, e) - /* - pi, err := miner.ComputeDataCid(ctx, 1016, strings.NewReader(strings.Repeat("a", 1016))) - require.NoError(t, err) - require.Equal(t, abi.PaddedPieceSize(1024), pi.Size) - require.Equal(t, "baga6ea4seaqlhznlutptgfwhffupyer6txswamerq5fc2jlwf2lys2mm5jtiaeq", pi.PieceCID.String()) - */ + + pi, err := miner.ComputeDataCid(ctx, 1016, strings.NewReader(strings.Repeat("a", 1016))) + require.NoError(t, err) + require.Equal(t, abi.PaddedPieceSize(1024), pi.Size) + require.Equal(t, "baga6ea4seaqlhznlutptgfwhffupyer6txswamerq5fc2jlwf2lys2mm5jtiaeq", pi.PieceCID.String()) + bigPiece := abi.PaddedPieceSize(16 << 20).Unpadded() - pi, err := miner.ComputeDataCid(ctx, bigPiece, strings.NewReader(strings.Repeat("a", int(bigPiece)))) + pi, err = miner.ComputeDataCid(ctx, bigPiece, strings.NewReader(strings.Repeat("a", int(bigPiece)))) require.NoError(t, err) require.Equal(t, bigPiece.Padded(), pi.Size) require.Equal(t, "baga6ea4seaqmhoxl2ybw5m2wyd3pt3h4zmp7j52yumzu2rar26twns3uocq7yfa", pi.PieceCID.String()) + + nonFullPiece := abi.PaddedPieceSize(10 << 20).Unpadded() + pi, err = miner.ComputeDataCid(ctx, bigPiece, strings.NewReader(strings.Repeat("a", int(nonFullPiece)))) + require.NoError(t, err) + require.Equal(t, bigPiece.Padded(), pi.Size) + require.Equal(t, "baga6ea4seaqbxib4pdxs5cqdn3fmtj4rcxk6rx6ztiqmrx7fcpo3ymuxbp2rodi", pi.PieceCID.String()) } func TestWinningPostWorker(t *testing.T) { From df7709c2e284f2758632a7c5d3871d1375bcd35e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Tue, 24 May 2022 16:01:54 +0200 Subject: [PATCH 36/37] cli docsgen --- documentation/en/cli-lotus-miner.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md index 941d8c525..4122026f8 100644 --- a/documentation/en/cli-lotus-miner.md +++ b/documentation/en/cli-lotus-miner.md @@ -2331,7 +2331,7 @@ COMMANDS: workers list workers sched-diag Dump internal scheduler state abort Abort a running job - data-cid Compute data CID + data-cid Compute data CID using workers help, h Shows a list of commands or help for one command OPTIONS: @@ -2398,12 +2398,13 @@ OPTIONS: ### lotus-miner sealing data-cid ``` NAME: - lotus-miner sealing data-cid - Compute data CID + lotus-miner sealing data-cid - Compute data CID using workers USAGE: - lotus-miner sealing data-cid [command options] [file] + lotus-miner sealing data-cid [command options] [file/url] OPTIONS: - --help, -h show help (default: false) + --file-size value real file size (default: 0) + --help, -h show help (default: false) ``` From b53db68bdaff359ccab3e9f4388ebf6487d118fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Tue, 24 May 2022 16:22:52 +0200 Subject: [PATCH 37/37] fix lint --- cmd/lotus-miner/sealing.go | 2 +- lib/rpcenc/reader.go | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/cmd/lotus-miner/sealing.go b/cmd/lotus-miner/sealing.go index 3ce3ae88c..df467e66a 100644 --- a/cmd/lotus-miner/sealing.go +++ b/cmd/lotus-miner/sealing.go @@ -4,7 +4,6 @@ import ( "encoding/hex" "encoding/json" "fmt" - "github.com/filecoin-project/lotus/lib/httpreader" "io" "math" "net/http" @@ -25,6 +24,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/lotus/extern/sector-storage/sealtasks" "github.com/filecoin-project/lotus/extern/sector-storage/storiface" + "github.com/filecoin-project/lotus/lib/httpreader" "github.com/filecoin-project/lotus/chain/types" lcli "github.com/filecoin-project/lotus/cli" diff --git a/lib/rpcenc/reader.go b/lib/rpcenc/reader.go index 0f268aadf..a4f16982e 100644 --- a/lib/rpcenc/reader.go +++ b/lib/rpcenc/reader.go @@ -5,7 +5,6 @@ import ( "encoding/json" "errors" "fmt" - "github.com/filecoin-project/lotus/lib/httpreader" "io" "io/ioutil" "net/http" @@ -24,6 +23,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader" + "github.com/filecoin-project/lotus/lib/httpreader" ) var log = logging.Logger("rpcenc") @@ -35,7 +35,7 @@ type StreamType string const ( Null StreamType = "null" PushStream StreamType = "push" - HttpUrl StreamType = "http" + HTTP StreamType = "http" // TODO: Data transfer handoff to workers? ) @@ -108,7 +108,7 @@ func ReaderParamEncoder(addr string) jsonrpc.Option { return reflect.ValueOf(ReaderStream{Type: Null, Info: fmt.Sprint(r.N)}), nil } if r, ok := r.(*httpreader.HttpReader); ok && r.URL != "" { - return reflect.ValueOf(ReaderStream{Type: HttpUrl, Info: r.URL}), nil + return reflect.ValueOf(ReaderStream{Type: HTTP, Info: r.URL}), nil } reqID := uuid.New() @@ -426,7 +426,7 @@ func ReaderParamDecoder() (http.HandlerFunc, jsonrpc.ServerOption) { } return reflect.ValueOf(nullreader.NewNullReader(abi.UnpaddedPieceSize(n))), nil - case HttpUrl: + case HTTP: return reflect.ValueOf(&httpreader.HttpReader{URL: rs.Info}), nil }