backend: add standard backend types for filesystem and memory

Add two basic concrete backend types, one based on the filesystem using
fileStorer and pack.Storage, and the other based on memory using
memoryStorer.  This provides a standard set of backends that we can use
for reading and writing actual Git repositories or for testing using
memory locations.

Note that this code cannot live in the storage package, where one would
logically expect it to be, because the concrete types implementing it
are private to the package.

Author: bk2204

backend.go

@@ -0,0 +1,44 @@
+package gitobj
+
+import (
+	"io"
+
+	"github.com/git-lfs/gitobj/pack"
+	"github.com/git-lfs/gitobj/storage"
+)
+
+// NewFilesystemBackend initializes a new filesystem-based backend.
+func NewFilesystemBackend(root, tmp string) (storage.Backend, error) {
+	fsobj := newFileStorer(root, tmp)
+	packs, err := pack.NewStorage(root)
+	if err != nil {
+		return nil, err
+	}
+
+	return &filesystemBackend{fs: fsobj, packs: packs}, nil
+}
+
+// NewMemoryBackend initializes a new memory-based backend.
+//
+// A value of "nil" is acceptable and indicates that no entries should be added
+// to the memory backend at construction time.
+func NewMemoryBackend(m map[string]io.ReadWriter) (storage.Backend, error) {
+	return &memoryBackend{ms: newMemoryStorer(m)}, nil
+}
+
+type filesystemBackend struct {
+	fs    *fileStorer
+	packs *pack.Storage
+}
+
+func (b *filesystemBackend) Storage() (storage.Storage, storage.WritableStorage) {
+	return storage.MultiStorage(b.fs, b.packs), b.fs
+}
+
+type memoryBackend struct {
+	ms *memoryStorer
+}
+
+func (b *memoryBackend) Storage() (storage.Storage, storage.WritableStorage) {
+	return b.ms, b.ms
+}

backend_test.go

@@ -0,0 +1,64 @@
+package gitobj
+
+import (
+	"bytes"
+	"encoding/hex"
+	"io"
+	"io/ioutil"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewMemoryBackend(t *testing.T) {
+	backend, err := NewMemoryBackend(nil)
+	assert.NoError(t, err)
+
+	ro, rw := backend.Storage()
+	assert.Equal(t, ro, rw)
+	assert.NotNil(t, ro.(*memoryStorer))
+}
+
+func TestNewMemoryBackendWithReadOnlyData(t *testing.T) {
+	sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	oid, err := hex.DecodeString(sha)
+
+	assert.Nil(t, err)
+
+	m := map[string]io.ReadWriter{
+		sha: bytes.NewBuffer([]byte{0x1}),
+	}
+
+	backend, err := NewMemoryBackend(m)
+	assert.NoError(t, err)
+
+	ro, _ := backend.Storage()
+	reader, err := ro.Open(oid)
+	assert.NoError(t, err)
+
+	contents, err := ioutil.ReadAll(reader)
+	assert.NoError(t, err)
+	assert.Equal(t, []byte{0x1}, contents)
+}
+
+func TestNewMemoryBackendWithWritableData(t *testing.T) {
+	sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	oid, err := hex.DecodeString(sha)
+
+	assert.Nil(t, err)
+
+	backend, err := NewMemoryBackend(make(map[string]io.ReadWriter))
+	assert.NoError(t, err)
+
+	buf := bytes.NewBuffer([]byte{0x1})
+
+	ro, rw := backend.Storage()
+	rw.Store(oid, buf)
+
+	reader, err := ro.Open(oid)
+	assert.NoError(t, err)
+
+	contents, err := ioutil.ReadAll(reader)
+	assert.NoError(t, err)
+	assert.Equal(t, []byte{0x1}, contents)
+}