Merge pull request #58 from ipfs/migrate-block-format

Migrate `go-block-format`

blocks/blocks.go

@@ -0,0 +1,82 @@
+// Package blocks contains the lowest level of IPLD data structures.
+// A block is raw data accompanied by a CID. The CID contains the multihash
+// corresponding to the block.
+package blocks
+
+import (
+ "errors"
+ "fmt"
+
+ cid "github.com/ipfs/go-cid"
+ u "github.com/ipfs/go-ipfs-util"
+ mh "github.com/multiformats/go-multihash"
+)
+
+// ErrWrongHash is returned when the Cid of a block is not the expected
+// according to the contents. It is currently used only when debugging.
+var ErrWrongHash = errors.New("data did not match given hash")
+
+// Block provides abstraction for blocks implementations.
+type Block interface {
+ RawData() []byte
+ Cid() cid.Cid
+ String() string
+ Loggable() map[string]interface{}
+}
+
+// A BasicBlock is a singular block of data in ipfs. It implements the Block
+// interface.
+type BasicBlock struct {
+ cid cid.Cid
+ data []byte
+}
+
+// NewBlock creates a Block object from opaque data. It will hash the data.
+func NewBlock(data []byte) *BasicBlock {
+ // TODO: fix assumptions
+ return &BasicBlock{data: data, cid: cid.NewCidV0(u.Hash(data))}
+}
+
+// NewBlockWithCid creates a new block when the hash of the data
+// is already known, this is used to save time in situations where
+// we are able to be confident that the data is correct.
+func NewBlockWithCid(data []byte, c cid.Cid) (*BasicBlock, error) {
+ if u.Debug {
+ chkc, err := c.Prefix().Sum(data)
+ if err != nil {
+ return nil, err
+ }
+
+ if !chkc.Equals(c) {
+ return nil, ErrWrongHash
+ }
+ }
+ return &BasicBlock{data: data, cid: c}, nil
+}
+
+// Multihash returns the hash contained in the block CID.
+func (b *BasicBlock) Multihash() mh.Multihash {
+ return b.cid.Hash()
+}
+
+// RawData returns the block raw contents as a byte slice.
+func (b *BasicBlock) RawData() []byte {
+ return b.data
+}
+
+// Cid returns the content identifier of the block.
+func (b *BasicBlock) Cid() cid.Cid {
+ return b.cid
+}
+
+// String provides a human-readable representation of the block CID.
+func (b *BasicBlock) String() string {
+ return fmt.Sprintf("[Block %s]", b.Cid())
+}
+
+// Loggable returns a go-log loggable item.
+func (b *BasicBlock) Loggable() map[string]interface{} {
+ return map[string]interface{}{
+ "block": b.Cid().String(),
+ }
+}

blocks/blocks_test.go

@@ -0,0 +1,98 @@
+package blocks
+
+import (
+ "bytes"
+ "testing"
+
+ cid "github.com/ipfs/go-cid"
+ u "github.com/ipfs/go-ipfs-util"
+ mh "github.com/multiformats/go-multihash"
+)
+
+func TestBlocksBasic(t *testing.T) {
+
+ // Test empty data
+ empty := []byte{}
+ NewBlock(empty)
+
+ // Test nil case
+ NewBlock(nil)
+
+ // Test some data
+ NewBlock([]byte("Hello world!"))
+}
+
+func TestData(t *testing.T) {
+ data := []byte("some data")
+ block := NewBlock(data)
+
+ if !bytes.Equal(block.RawData(), data) {
+ t.Error("data is wrong")
+ }
+}
+
+func TestHash(t *testing.T) {
+ data := []byte("some other data")
+ block := NewBlock(data)
+
+ hash, err := mh.Sum(data, mh.SHA2_256, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if !bytes.Equal(block.Multihash(), hash) {
+ t.Error("wrong multihash")
+ }
+}
+
+func TestCid(t *testing.T) {
+ data := []byte("yet another data")
+ block := NewBlock(data)
+ c := block.Cid()
+
+ if !bytes.Equal(block.Multihash(), c.Hash()) {
+ t.Error("key contains wrong data")
+ }
+}
+
+func TestManualHash(t *testing.T) {
+ oldDebugState := u.Debug
+ defer (func() {
+ u.Debug = oldDebugState
+ })()
+
+ data := []byte("I can't figure out more names .. data")
+ hash, err := mh.Sum(data, mh.SHA2_256, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ c := cid.NewCidV0(hash)
+
+ u.Debug = false
+ block, err := NewBlockWithCid(data, c)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if !bytes.Equal(block.Multihash(), hash) {
+ t.Error("wrong multihash")
+ }
+
+ data[5] = byte((uint32(data[5]) + 5) % 256) // Transfrom hash to be different
+ block, err = NewBlockWithCid(data, c)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if !bytes.Equal(block.Multihash(), hash) {
+ t.Error("wrong multihash")
+ }
+
+ u.Debug = true
+
+ _, err = NewBlockWithCid(data, c)
+ if err != ErrWrongHash {
+ t.Fatal(err)
+ }
+}

go.mod

@@ -7,6 +7,7 @@ require (
  github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3
  github.com/gorilla/mux v1.8.0
  github.com/ipfs/go-cid v0.3.2
+ github.com/ipfs/go-ipfs-util v0.0.2
  github.com/ipfs/go-ipns v0.3.0
  github.com/ipfs/go-log/v2 v2.5.1
  github.com/libp2p/go-libp2p v0.23.4
@@ -24,7 +25,6 @@ require (
  github.com/davecgh/go-spew v1.1.1 // indirect
  github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
  github.com/gogo/protobuf v1.3.2 // indirect
- github.com/ipfs/go-ipfs-util v0.0.2 // indirect
  github.com/ipld/go-ipld-prime v0.9.0 // indirect
  github.com/klauspost/cpuid/v2 v2.1.1 // indirect
  github.com/libp2p/go-buffer-pool v0.1.0 // indirect

version.json

@@ -1,3 +1,3 @@
 {
- "version": "v0.2.0"
+ "version": "v0.3.0"
 }