Add file entry implementation (#242)

pkg/collection/collection.go

+// Copyright 2020 The Swarm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package collection provides high-level abstractions for collections of files
+package collection
+
+import (
+	"github.com/ethersphere/bee/pkg/swarm"
+)
+
+// Collection provides a specific ordering of a collection of binary data vectors
+// stored in bee.
+type Collection interface {
+	Addresses() []swarm.Address
+}
+
+// Entry encapsulates data defining a single file entry.
+// It may contain any number of data blobs providing context to the
+// given data vector concealed by Reference.
+type Entry interface {
+	Reference() swarm.Address
+	Metadata() swarm.Address
+}

pkg/collection/entry/entry.go

+// Copyright 2020 The Swarm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package entry
+
+import (
+	"errors"
+
+	"github.com/ethersphere/bee/pkg/collection"
+	"github.com/ethersphere/bee/pkg/swarm"
+)
+
+var (
+	_                  = collection.Entry(&Entry{})
+	serializedDataSize = swarm.SectionSize * 2
+)
+
+// Entry provides addition of metadata to a data reference.
+// Implements collection.Entry.
+type Entry struct {
+	reference swarm.Address
+	metadata  swarm.Address
+}
+
+// New creates a new Entry.
+func New(reference, metadata swarm.Address) *Entry {
+	return &Entry{
+		reference: reference,
+		metadata:  metadata,
+	}
+}
+
+// Reference implements collection.Entry
+func (e *Entry) Reference() swarm.Address {
+	return e.reference
+}
+
+// Metadata implements collection.Entry
+func (e *Entry) Metadata() swarm.Address {
+	return e.metadata
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler
+func (e *Entry) MarshalBinary() ([]byte, error) {
+	br := e.reference.Bytes()
+	bm := e.metadata.Bytes()
+	b := append(br, bm...)
+	return b, nil
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler
+func (e *Entry) UnmarshalBinary(b []byte) error {
+	if len(b) != serializedDataSize {
+		return errors.New("invalid data length")
+	}
+	e.reference = swarm.NewAddress(b[:swarm.SectionSize])
+	e.metadata = swarm.NewAddress(b[swarm.SectionSize:])
+	return nil
+}

pkg/collection/entry/entry_test.go

+// Copyright 2020 The Swarm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package entry_test
+
+import (
+	"testing"
+
+	"github.com/ethersphere/bee/pkg/collection/entry"
+	"github.com/ethersphere/bee/pkg/swarm/test"
+)
+
+// TestEntrySerialize verifies integrity of serialization.
+func TestEntrySerialize(t *testing.T) {
+	referenceAddress := test.RandomAddress()
+	metadataAddress := test.RandomAddress()
+	e := entry.New(referenceAddress, metadataAddress)
+	entrySerialized, err := e.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	entryRecovered := &entry.Entry{}
+	err = entryRecovered.UnmarshalBinary(entrySerialized)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !referenceAddress.Equal(entryRecovered.Reference()) {
+		t.Fatalf("expected reference %s, got %s", referenceAddress, entryRecovered.Reference())
+	}
+
+	metadataAddressRecovered := entryRecovered.Metadata()
+	if !metadataAddress.Equal(metadataAddressRecovered) {
+		t.Fatalf("expected metadata %s, got %s", metadataAddress, metadataAddressRecovered)
+	}
+}

pkg/collection/entry/metadata.go

+// Copyright 2020 The Swarm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package entry
+
+import (
+	"encoding/json"
+)
+
+// Metadata provides mime type and filename to file entry.
+type Metadata struct {
+	MimeType string `json:"mimetype"`
+	Filename string `json:"filename"`
+}
+
+// NewMetadata creates a new Metadata.
+func NewMetadata(fileName string) *Metadata {
+	return &Metadata{
+		Filename: fileName,
+	}
+}
+
+func (m *Metadata) String() string {
+	j, _ := json.Marshal(m)
+	return string(j)
+}

pkg/file/io.go

@@ -11,12 +11,13 @@ import (
 	"io"
 )
 
-// simpleJoinerReadCloser wraps a byte slice in a io.ReadCloser implementation.
+// simpleReadCloser wraps a byte slice in a io.ReadCloser implementation.
 type simpleReadCloser struct {
 	buffer io.Reader
 	closed bool
 }
 
+// NewSimpleReadCloser creates a new simpleReadCloser.
 func NewSimpleReadCloser(buffer []byte) io.ReadCloser {
 	return &simpleReadCloser{
 		buffer: bytes.NewBuffer(buffer),

pkg/kademlia/kademlia_test.go

@@ -27,8 +27,8 @@ import (
 	p2pmock "github.com/ethersphere/bee/pkg/p2p/mock"
 	mockstate "github.com/ethersphere/bee/pkg/statestore/mock"
 	"github.com/ethersphere/bee/pkg/swarm"
+	"github.com/ethersphere/bee/pkg/swarm/test"
 	"github.com/ethersphere/bee/pkg/topology"
-	"github.com/ethersphere/bee/pkg/topology/test"
 )
 
 func init() {

pkg/kademlia/pslice/pslice_test.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/ethersphere/bee/pkg/kademlia/pslice"
 	"github.com/ethersphere/bee/pkg/swarm"
-	"github.com/ethersphere/bee/pkg/topology/test"
+	"github.com/ethersphere/bee/pkg/swarm/test"
 )
 
 // TestShallowestEmpty tests that ShallowestEmpty functionality works correctly.

pkg/topology/test/helper_test.go → pkg/swarm/test/helper_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 
 	"github.com/ethersphere/bee/pkg/swarm"
-	"github.com/ethersphere/bee/pkg/topology/test"
+	"github.com/ethersphere/bee/pkg/swarm/test"
 )
 
 // TestRandomAddressAt checks that RandomAddressAt generates a correct random address