Merge pull request #3 from bk2204/expose-fs

Add a storage abstraction

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)
+}

errors/errors.go

@@ -0,0 +1,28 @@
+package errors
+
+import (
+	"fmt"
+)
+
+// noSuchObject is an error type that occurs when no object with a given object
+// ID is available.
+type noSuchObject struct {
+	oid []byte
+}
+
+// Error implements the error.Error() function.
+func (e *noSuchObject) Error() string {
+	return fmt.Sprintf("gitobj: no such object: %x", e.oid)
+}
+
+// NoSuchObject creates a new error representing a missing object with a given
+// object ID.
+func NoSuchObject(oid []byte) error {
+	return &noSuchObject{oid: oid}
+}
+
+// IsNoSuchObject indicates whether an error is a noSuchObject and is non-nil.
+func IsNoSuchObject(e error) bool {
+	err, ok := e.(*noSuchObject)
+	return ok && err != nil
+}

errors/errors_test.go

@@ -0,0 +1,24 @@
+package errors
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNoSuchObjectTypeErrFormatting(t *testing.T) {
+	sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	oid, err := hex.DecodeString(sha)
+	assert.NoError(t, err)
+
+	err = NoSuchObject(oid)
+
+	assert.Equal(t, "gitobj: no such object: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", err.Error())
+	assert.Equal(t, IsNoSuchObject(err), true)
+}
+
+func TestIsNoSuchObjectNilHandling(t *testing.T) {
+	assert.Equal(t, IsNoSuchObject((*noSuchObject)(nil)), false)
+	assert.Equal(t, IsNoSuchObject(nil), false)
+}

file_storer.go

@@ -7,6 +7,8 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+
+	"github.com/git-lfs/gitobj/errors"
 )
 
 // fileStorer implements the storer interface by writing to the .git/objects
@@ -27,14 +29,18 @@ func newFileStorer(root, tmp string) *fileStorer {
 	}
 }
 
-// Open implements the storer.Open function, and returns a io.ReadWriteCloser
+// Open implements the storer.Open function, and returns a io.ReadCloser
 // for the given SHA. If the file does not exist, or if there was any other
 // error in opening the file, an error will be returned.
 //
 // It is the caller's responsibility to close the given file "f" after its use
 // is complete.
-func (fs *fileStorer) Open(sha []byte) (f io.ReadWriteCloser, err error) {
-	return fs.open(fs.path(sha), os.O_RDONLY)
+func (fs *fileStorer) Open(sha []byte) (f io.ReadCloser, err error) {
+	f, err = fs.open(fs.path(sha), os.O_RDONLY)
+	if os.IsNotExist(err) {
+		return nil, errors.NoSuchObject(sha)
+	}
+	return f, err
 }
 
 // Store implements the storer.Store function and returns the number of bytes
@@ -90,6 +96,16 @@ func (fs *fileStorer) Root() string {
 	return fs.root
 }
 
+// Close closes the file storer.
+func (fs *fileStorer) Close() error {
+	return nil
+}
+
+// IsCompressed returns true, because the file storer returns compressed data.
+func (fs *fileStorer) IsCompressed() bool {
+	return true
+}
+
 // open opens a given file.
 func (fs *fileStorer) open(path string, flag int) (*os.File, error) {
 	return os.OpenFile(path, flag, 0)

memory_storer.go

@@ -4,8 +4,9 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"os"
 	"sync"
+
+	"github.com/git-lfs/gitobj/errors"
 )
 
 // memoryStorer is an implementation of the storer interface that holds data for
@@ -51,17 +52,27 @@ func (ms *memoryStorer) Store(sha []byte, r io.Reader) (n int64, err error) {
 // Open implements the storer.Open function, and returns a io.ReadWriteCloser
 // for the given SHA. If a reader for the given SHA does not exist an error will
 // be returned.
-func (ms *memoryStorer) Open(sha []byte) (f io.ReadWriteCloser, err error) {
+func (ms *memoryStorer) Open(sha []byte) (f io.ReadCloser, err error) {
 	ms.mu.Lock()
 	defer ms.mu.Unlock()
 
 	key := fmt.Sprintf("%x", sha)
 	if _, ok := ms.fs[key]; !ok {
-		return nil, os.ErrNotExist
+		return nil, errors.NoSuchObject(sha)
 	}
 	return ms.fs[key], nil
 }
 
+// Close closes the memory storer.
+func (ms *memoryStorer) Close() error {
+	return nil
+}
+
+// IsCompressed returns true, because the memory storer returns compressed data.
+func (ms *memoryStorer) IsCompressed() bool {
+	return true
+}
+
 // bufCloser wraps a type satisfying the io.ReadWriter interface with a no-op
 // Close() function, thus implementing the io.ReadWriteCloser composite
 // interface.

memory_storer_test.go

@@ -5,10 +5,10 @@ import (
 	"encoding/hex"
 	"io"
 	"io/ioutil"
-	"os"
 	"strings"
 	"testing"
 
+	"github.com/git-lfs/gitobj/errors"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -35,6 +35,7 @@ func TestMemoryStorerAcceptsNilEntries(t *testing.T) {
 
 	assert.NotNil(t, ms)
 	assert.Equal(t, 0, len(ms.fs))
+	assert.NoError(t, ms.Close())
 }
 
 func TestMemoryStorerDoesntOpenMissingEntries(t *testing.T) {
@@ -46,7 +47,7 @@ func TestMemoryStorerDoesntOpenMissingEntries(t *testing.T) {
 	ms := newMemoryStorer(nil)
 
 	f, err := ms.Open(hex)
-	assert.Equal(t, os.ErrNotExist, err)
+	assert.Equal(t, errors.NoSuchObject(hex), err)
 	assert.Nil(t, f)
 }