block service

blocks/blocks.go

@@ -1,14 +1,63 @@
 package blocks
 
 import (
-  "github.com/jbenet/go-ipfs/bitswap"
-  "github.com/jbenet/go-ipfs/storage"
+	"fmt"
+	ds "github.com/jbenet/datastore.go"
+	u "github.com/jbenet/go-ipfs/util"
+	mh "github.com/jbenet/go-multihash"
 )
 
 // Blocks is the ipfs blocks service. It is the way
 // to retrieve blocks by the higher level ipfs modules
 
-type BlockService struct {
-  Local *storage.Storage
-  Remote *bitswap.BitSwap
+type Block struct {
+	Multihash mh.Multihash
+	Data      []byte
+}
+
+func NewBlock(data []byte) (*Block, error) {
+	h, err := u.Hash(data)
+	if err != nil {
+		return nil, err
+	}
+	return &Block{Data: data, Multihash: h}, nil
+}
+
+func (b *Block) Key() u.Key {
+	return u.Key(b.Multihash)
+}
+
+type BlockService struct {
+	Datastore ds.Datastore
+	// Remote *bitswap.BitSwap // eventually.
+}
+
+func NewBlockService(d ds.Datastore) (*BlockService, error) {
+	if d == nil {
+		return nil, fmt.Errorf("BlockService requires valid datastore")
+	}
+	return &BlockService{Datastore: d}, nil
+}
+
+func (s *BlockService) AddBlock(b *Block) error {
+	dsk := ds.NewKey(string(b.Key()))
+	return s.Datastore.Put(dsk, b.Data)
+}
+
+func (s *BlockService) GetBlock(k u.Key) (*Block, error) {
+	dsk := ds.NewKey(string(k))
+	datai, err := s.Datastore.Get(dsk)
+	if err != nil {
+		return nil, err
+	}
+
+	data, ok := datai.([]byte)
+	if !ok {
+		return nil, fmt.Errorf("data associated with %s is not a []byte", k)
+	}
+
+	return &Block{
+		Multihash: mh.Multihash(k),
+		Data:      data,
+	}, nil
 }

blocks/blocks_test.go

@@ -0,0 +1,62 @@
+package blocks
+
+import (
+	"bytes"
+	"fmt"
+	ds "github.com/jbenet/datastore.go"
+	u "github.com/jbenet/go-ipfs/util"
+	"testing"
+)
+
+func TestBlocks(t *testing.T) {
+
+	d := ds.NewMapDatastore()
+	bs, err := NewBlockService(d)
+	if err != nil {
+		t.Error("failed to construct block service", err)
+		return
+	}
+
+	b, err := NewBlock([]byte("beep boop"))
+	if err != nil {
+		t.Error("failed to construct block", err)
+		return
+	}
+
+	h, err := u.Hash([]byte("beep boop"))
+	if err != nil {
+		t.Error("failed to hash data", err)
+		return
+	}
+
+	if !bytes.Equal(b.Multihash, h) {
+		t.Error("Block Multihash and data multihash not equal")
+	}
+
+	if b.Key() != u.Key(h) {
+		t.Error("Block key and data multihash key not equal")
+	}
+
+	err = bs.AddBlock(b)
+	if err != nil {
+		t.Error("failed to add block to BlockService", err)
+		return
+	}
+
+	b2, err := bs.GetBlock(b.Key())
+	if err != nil {
+		t.Error("failed to retrieve block from BlockService", err)
+		return
+	}
+
+	if b.Key() != b2.Key() {
+		t.Error("Block keys not equal.")
+	}
+
+	if !bytes.Equal(b.Data, b2.Data) {
+		t.Error("Block data is not equal.")
+	}
+
+	fmt.Printf("key: %s\n", b.Key())
+	fmt.Printf("data: %v\n", b.Data)
+}