Bithack

blockstore/blockstore.go → blocks/blockstore/blockstore.go

@@ -15,6 +15,8 @@ import (
 var ValueTypeMismatch = errors.New("The retrieved value is not a Block")
 
 type Blockstore interface {
+	DeleteBlock(u.Key) error
+	Has(u.Key) (bool, error)
 	Get(u.Key) (*blocks.Block, error)
 	Put(*blocks.Block) error
 }
@@ -45,3 +47,11 @@ func (bs *blockstore) Get(k u.Key) (*blocks.Block, error) {
 func (bs *blockstore) Put(block *blocks.Block) error {
 	return bs.datastore.Put(block.Key().DsKey(), block.Data)
 }
+
+func (bs *blockstore) Has(k u.Key) (bool, error) {
+	return bs.datastore.Has(k.DsKey())
+}
+
+func (s *blockstore) DeleteBlock(k u.Key) error {
+	return s.datastore.Delete(k.DsKey())
+}

blocks/blocksutil/block_generator.go

@@ -0,0 +1,25 @@
+package blocksutil
+
+import "github.com/jbenet/go-ipfs/blocks"
+
+func NewBlockGenerator() BlockGenerator {
+	return BlockGenerator{}
+}
+
+type BlockGenerator struct {
+	seq int
+}
+
+func (bg *BlockGenerator) Next() *blocks.Block {
+	bg.seq++
+	return blocks.NewBlock([]byte(string(bg.seq)))
+}
+
+func (bg *BlockGenerator) Blocks(n int) []*blocks.Block {
+	blocks := make([]*blocks.Block, 0)
+	for i := 0; i < n; i++ {
+		b := bg.Next()
+		blocks = append(blocks, b)
+	}
+	return blocks
+}

blockservice/blocks_test.go

@@ -6,15 +6,22 @@ import (
 	"time"
 
 	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-
 	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
+	dssync "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
 	blocks "github.com/jbenet/go-ipfs/blocks"
+	blockstore "github.com/jbenet/go-ipfs/blocks/blockstore"
+	blocksutil "github.com/jbenet/go-ipfs/blocks/blocksutil"
+	bitswap "github.com/jbenet/go-ipfs/exchange/bitswap"
+	tn "github.com/jbenet/go-ipfs/exchange/bitswap/testnet"
+	offline "github.com/jbenet/go-ipfs/exchange/offline"
+	"github.com/jbenet/go-ipfs/routing/mock"
 	u "github.com/jbenet/go-ipfs/util"
 )
 
 func TestBlocks(t *testing.T) {
 	d := ds.NewMapDatastore()
-	bs, err := NewBlockService(d, nil)
+	tsds := dssync.MutexWrap(d)
+	bs, err := New(blockstore.NewBlockstore(tsds), offline.Exchange())
 	if err != nil {
 		t.Error("failed to construct block service", err)
 		return
@@ -55,3 +62,46 @@ func TestBlocks(t *testing.T) {
 		t.Error("Block data is not equal.")
 	}
 }
+
+func TestGetBlocksSequential(t *testing.T) {
+	net := tn.VirtualNetwork()
+	rs := mock.VirtualRoutingServer()
+	sg := bitswap.NewSessionGenerator(net, rs)
+	bg := blocksutil.NewBlockGenerator()
+
+	instances := sg.Instances(4)
+	blks := bg.Blocks(50)
+	// TODO: verify no duplicates
+
+	var servs []*BlockService
+	for _, i := range instances {
+		bserv, err := New(i.Blockstore, i.Exchange)
+		if err != nil {
+			t.Fatal(err)
+		}
+		servs = append(servs, bserv)
+	}
+
+	var keys []u.Key
+	for _, blk := range blks {
+		keys = append(keys, blk.Key())
+		servs[0].AddBlock(blk)
+	}
+
+	t.Log("one instance at a time, get blocks concurrently")
+
+	for i := 1; i < len(instances); i++ {
+		ctx, _ := context.WithTimeout(context.TODO(), time.Second*5)
+		out := servs[i].GetBlocks(ctx, keys)
+		gotten := make(map[u.Key]*blocks.Block)
+		for blk := range out {
+			if _, ok := gotten[blk.Key()]; ok {
+				t.Fatal("Got duplicate block!")
+			}
+			gotten[blk.Key()] = blk
+		}
+		if len(gotten) != len(blks) {
+			t.Fatalf("Didnt get enough blocks back: %d/%d", len(gotten), len(blks))
+		}
+	}
+}