block service

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 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 {
- Local *storage.Storage
- Remote *bitswap.BitSwap
+ 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_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)
+}