storage: implement a wrapper for multiple storage implementations

Some storage backends need to wrap multiple storage implementations,
such as the file backend: we need to read from both loose objects and
packs.  In order to make these two backends appear to be one unified
implementation, add a wrapper implementation that reads from whichever
implementation provides the object.  Implement automatic decompression,
since we may end up with some implementations which decompress
automatically and others which do not.

Author: bk2204

storage/decompressing_readcloser.go

@@ -0,0 +1,35 @@
+package storage
+
+import (
+	"compress/zlib"
+	"io"
+)
+
+// decompressingReadCloser wraps zlib.NewReader to ensure that both the zlib
+// reader and its underlying type are closed.
+type decompressingReadCloser struct {
+	r  io.ReadCloser
+	zr io.ReadCloser
+}
+
+// newDecompressingReadCloser creates a new wrapped zlib reader
+func newDecompressingReadCloser(r io.ReadCloser) (io.ReadCloser, error) {
+	zr, err := zlib.NewReader(r)
+	if err != nil {
+		return nil, err
+	}
+	return &decompressingReadCloser{r: r, zr: zr}, nil
+}
+
+// Read implements io.ReadCloser.
+func (d *decompressingReadCloser) Read(b []byte) (int, error) {
+	return d.zr.Read(b)
+}
+
+// Close implements io.ReadCloser.
+func (d *decompressingReadCloser) Close() error {
+	if err := d.zr.Close(); err != nil {
+		return err
+	}
+	return d.r.Close()
+}

storage/multi_storage.go

@@ -0,0 +1,55 @@
+package storage
+
+import (
+	"io"
+
+	"github.com/git-lfs/gitobj/errors"
+)
+
+// Storage implements an interface for reading, but not writing, objects in an
+// object database.
+type multiStorage struct {
+	impls []Storage
+}
+
+func MultiStorage(args ...Storage) Storage {
+	return &multiStorage{impls: args}
+}
+
+// Open returns a handle on an existing object keyed by the given object
+// ID.  It returns an error if that file does not already exist.
+func (m *multiStorage) Open(oid []byte) (f io.ReadCloser, err error) {
+	for _, s := range m.impls {
+		f, err := s.Open(oid)
+		if err != nil {
+			if errors.IsNoSuchObject(err) {
+				continue
+			}
+			return nil, err
+		}
+		if s.IsCompressed() {
+			return newDecompressingReadCloser(f)
+		}
+		return f, nil
+	}
+	return nil, errors.NoSuchObject(oid)
+}
+
+// Close closes the filesystem, after which no more operations are
+// allowed.
+func (m *multiStorage) Close() error {
+	for _, s := range m.impls {
+		if err := s.Close(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Compressed indicates whether data read from this storage source will
+// be zlib-compressed.
+func (m *multiStorage) IsCompressed() bool {
+	// To ensure we can read from any Storage type, we automatically
+	// decompress items if they need it.
+	return false
+}