pull buffered blockstore into the lib folder

chain/buf_bstore.go

@@ -1,117 +0,0 @@
-package chain
-
-import (
-	"context"
-
-	block "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ds "github.com/ipfs/go-datastore"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-)
-
-type BufferedBS struct {
-	read  bstore.Blockstore
-	write bstore.Blockstore
-}
-
-func NewBufferedBstore(base bstore.Blockstore) *BufferedBS {
-	buf := bstore.NewBlockstore(ds.NewMapDatastore())
-	return &BufferedBS{
-		read:  base,
-		write: buf,
-	}
-}
-
-var _ (bstore.Blockstore) = &BufferedBS{}
-
-func (bs *BufferedBS) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	a, err := bs.read.AllKeysChan(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	b, err := bs.write.AllKeysChan(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	out := make(chan cid.Cid)
-	go func() {
-		defer close(out)
-		for a != nil || b != nil {
-			select {
-			case val, ok := <-a:
-				if !ok {
-					a = nil
-				} else {
-					select {
-					case out <- val:
-					case <-ctx.Done():
-						return
-					}
-				}
-			case val, ok := <-b:
-				if !ok {
-					b = nil
-				} else {
-					select {
-					case out <- val:
-					case <-ctx.Done():
-						return
-					}
-				}
-			}
-		}
-	}()
-
-	return out, nil
-}
-
-func (bs *BufferedBS) DeleteBlock(c cid.Cid) error {
-	if err := bs.read.DeleteBlock(c); err != nil {
-		return err
-	}
-
-	return bs.write.DeleteBlock(c)
-}
-
-func (bs *BufferedBS) Get(c cid.Cid) (block.Block, error) {
-	if out, err := bs.read.Get(c); err != nil {
-		if err != bstore.ErrNotFound {
-			return nil, err
-		}
-	} else {
-		return out, nil
-	}
-
-	return bs.write.Get(c)
-}
-
-func (bs *BufferedBS) GetSize(c cid.Cid) (int, error) {
-	panic("nyi")
-}
-
-func (bs *BufferedBS) Put(blk block.Block) error {
-	return bs.write.Put(blk)
-}
-
-func (bs *BufferedBS) Has(c cid.Cid) (bool, error) {
-	has, err := bs.read.Has(c)
-	if err != nil {
-		return false, err
-	}
-	if has {
-		return true, nil
-	}
-
-	return bs.write.Has(c)
-}
-
-func (bs *BufferedBS) HashOnRead(hor bool) {
-	bs.read.HashOnRead(hor)
-	bs.write.HashOnRead(hor)
-}
-
-func (bs *BufferedBS) PutMany(blks []block.Block) error {
-	return bs.write.PutMany(blks)
-}

chain/vm.go

@@ -6,6 +6,7 @@ import (
 	"math/big"
 
 	"github.com/filecoin-project/go-lotus/chain/address"
+	"github.com/filecoin-project/go-lotus/lib/bufbstore"
 
 	bserv "github.com/ipfs/go-blockservice"
 	cid "github.com/ipfs/go-cid"
@@ -64,13 +65,13 @@ type VM struct {
 	cstate      *StateTree
 	base        cid.Cid
 	cs          *ChainStore
-	buf         *BufferedBS
+	buf         *bufbstore.BufferedBS
 	blockHeight uint64
 	blockMiner  address.Address
 }
 
 func NewVM(base cid.Cid, height uint64, maddr address.Address, cs *ChainStore) (*VM, error) {
-	buf := NewBufferedBstore(cs.bs)
+	buf := bufbstore.NewBufferedBstore(cs.bs)
 	cst := hamt.CSTFromBstore(buf)
 	state, err := LoadStateTree(cst, base)
 	if err != nil {
@@ -166,7 +167,7 @@ func (vm *VM) ApplyMessage(msg *Message) (*MessageReceipt, error) {
 
 func (vm *VM) Flush(ctx context.Context) (cid.Cid, error) {
 	from := dag.NewDAGService(bserv.New(vm.buf, nil))
-	to := dag.NewDAGService(bserv.New(vm.buf.read, nil))
+	to := dag.NewDAGService(bserv.New(vm.buf.Read(), nil))
 
 	root, err := vm.cstate.Flush()
 	if err != nil {