storage: filesystem, add support for git alternates

This change adds a new method `Alternates()` in `DotGit` to check and
query alternate source.
```
func (d *DotGit) Alternates() (string, error)
```
This is used by `ObjectStorage.EncodedObject` to check for alternates
and get the queried object from the alternate source.

Author: darkowlzz

storage/filesystem/internal/dotgit/dotgit.go

@@ -3,6 +3,7 @@ package dotgit
 
 import (
 	"bufio"
+	"bytes"
 	"errors"
 	"fmt"
 	stdioutil "io/ioutil"
@@ -502,11 +503,29 @@ func (d *DotGit) readReferenceFile(path, name string) (ref *plumbing.Reference,
 	return plumbing.NewReferenceFromStrings(name, line), nil
 }
 
-// Module return a billy.Filesystem poiting to the module folder
+// Module return a billy.Filesystem pointing to the module folder
 func (d *DotGit) Module(name string) (billy.Filesystem, error) {
 	return d.fs.Chroot(d.fs.Join(modulePath, name))
 }
 
+// Alternates returns the content of objects/info/alternates if available.
+// This can be used to checks if it's a shared repository.
+func (d *DotGit) Alternates() (string, error) {
+	altpath := d.fs.Join("objects", "info", "alternates")
+	f, err := d.fs.Open(altpath)
+	if os.IsNotExist(err) {
+		return "", err
+	}
+
+	buf := new(bytes.Buffer)
+	_, err = buf.ReadFrom(f)
+	if err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
 func isHex(s string) bool {
 	for _, b := range []byte(s) {
 		if isNum(b) {

storage/filesystem/internal/dotgit/dotgit_test.go

@@ -487,3 +487,30 @@ func (s *SuiteDotGit) TestSubmodules(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(strings.HasSuffix(m.Root(), m.Join(".git", "modules", "basic")), Equals, true)
 }
+
+func (s *SuiteDotGit) TestAlternates(c *C) {
+	tmp, err := ioutil.TempDir("", "dot-git")
+	c.Assert(err, IsNil)
+	defer os.RemoveAll(tmp)
+
+	// Create a new billy fs.
+	fs := osfs.New(tmp)
+
+	// Create a new dotgit object and initialize.
+	dir := New(fs)
+	err = dir.Initialize()
+	c.Assert(err, IsNil)
+
+	// Create alternates file.
+	altpath := filepath.Join("objects", "info", "alternates")
+	f, err := fs.Create(altpath)
+	c.Assert(err, IsNil)
+
+	content := []byte("/Users/username/rep1//.git/objects")
+	f.Write(content)
+	f.Close()
+
+	alt, err := dir.Alternates()
+	c.Assert(err, IsNil)
+	c.Assert(alt, Equals, "/Users/username/rep1//.git/objects")
+}

storage/filesystem/object.go

@@ -3,6 +3,7 @@ package filesystem
 import (
 	"io"
 	"os"
+	"path/filepath"
 
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/cache"
@@ -15,6 +16,7 @@ import (
 	"gopkg.in/src-d/go-git.v4/utils/ioutil"
 
 	"gopkg.in/src-d/go-billy.v4"
+	"gopkg.in/src-d/go-billy.v4/osfs"
 )
 
 const DefaultMaxDeltaBaseCacheSize = 92 * cache.MiByte
@@ -133,6 +135,23 @@ func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (p
 		obj, err = s.getFromPackfile(h, false)
 	}
 
+	// If the error is still object not found, check if it's a shared object
+	// repository.
+	if err == plumbing.ErrObjectNotFound {
+		alt, e := s.dir.Alternates()
+		if e == nil {
+			// Create a new object storage pointing to the path in the
+			// alternates file.
+			fs := osfs.New(filepath.Dir(alt))
+			dir := dotgit.New(fs)
+			o, oe := newObjectStorage(dir)
+			if oe != nil {
+				return nil, oe
+			}
+			return o.EncodedObject(t, h)
+		}
+	}
+
 	if err != nil {
 		return nil, err
 	}