storage: transactional, new storage with transactional capabilities

Signed-off-by: Máximo Cuadros <mcuadros@gmail.com>

Author: mcuadros

plumbing/storer/reference.go

@@ -159,8 +159,6 @@ func forEachReferenceIter(iter bareReferenceIterator, cb func(*plumbing.Referenc
 			return err
 		}
 	}
-
-	return nil
 }
 
 // Close releases any resources used by the iterator.

storage/transactional/config.go

@@ -22,6 +22,14 @@ func (c *ConfigStorage) SetConfig(cfg *config.Config) error {
 	return nil
 }
 
+func (c *ConfigStorage) Config() (*config.Config, error) {
+	if !c.set {
+		return c.ConfigStorer.Config()
+	}
+
+	return c.temporal.Config()
+}
+
 func (c *ConfigStorage) Commit() error {
 	if !c.set {
 		return nil

storage/transactional/config_test.go

@@ -1,20 +1,32 @@
 package transactional
 
 import (
-	"testing"
-
 	. "gopkg.in/check.v1"
 	"gopkg.in/src-d/go-git.v4/config"
 	"gopkg.in/src-d/go-git.v4/storage/memory"
 )
 
-func Test(t *testing.T) { TestingT(t) }
-
 var _ = Suite(&ConfigSuite{})
 
 type ConfigSuite struct{}
 
-func (s *ConfigSuite) TestSetConfig(c *C) {
+func (s *ConfigSuite) TestSetConfigBase(c *C) {
+	cfg := config.NewConfig()
+	cfg.Core.Worktree = "foo"
+
+	base := memory.NewStorage()
+	err := base.SetConfig(cfg)
+	c.Assert(err, IsNil)
+
+	temporal := memory.NewStorage()
+	cs := NewConfigStorage(base, temporal)
+
+	cfg, err = cs.Config()
+	c.Assert(err, IsNil)
+	c.Assert(cfg.Core.Worktree, Equals, "foo")
+}
+
+func (s *ConfigSuite) TestSetConfigTemporal(c *C) {
 	cfg := config.NewConfig()
 	cfg.Core.Worktree = "foo"
 

storage/transactional/index.go

@@ -0,0 +1,50 @@
+package transactional
+
+import (
+	"gopkg.in/src-d/go-git.v4/plumbing/format/index"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+)
+
+type IndexStorage struct {
+	storer.IndexStorer
+	temporal storer.IndexStorer
+
+	set bool
+}
+
+func NewIndexStorage(s, temporal storer.IndexStorer) *IndexStorage {
+	return &IndexStorage{
+		IndexStorer: s,
+		temporal:    temporal,
+	}
+}
+
+func (s *IndexStorage) SetIndex(idx *index.Index) (err error) {
+	if err := s.temporal.SetIndex(idx); err != nil {
+		return err
+	}
+
+	s.set = true
+	return nil
+}
+
+func (s *IndexStorage) Index() (*index.Index, error) {
+	if !s.set {
+		return s.IndexStorer.Index()
+	}
+
+	return s.temporal.Index()
+}
+
+func (c *IndexStorage) Commit() error {
+	if !c.set {
+		return nil
+	}
+
+	idx, err := c.temporal.Index()
+	if err != nil {
+		return err
+	}
+
+	return c.IndexStorer.SetIndex(idx)
+}

storage/transactional/index_test.go

@@ -0,0 +1,52 @@
+package transactional
+
+import (
+	. "gopkg.in/check.v1"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/index"
+	"gopkg.in/src-d/go-git.v4/storage/memory"
+)
+
+var _ = Suite(&IndexSuite{})
+
+type IndexSuite struct{}
+
+func (s *IndexSuite) TestSetIndexBase(c *C) {
+	idx := &index.Index{}
+	idx.Version = 2
+
+	base := memory.NewStorage()
+	err := base.SetIndex(idx)
+	c.Assert(err, IsNil)
+
+	temporal := memory.NewStorage()
+	cs := NewIndexStorage(base, temporal)
+
+	idx, err = cs.Index()
+	c.Assert(err, IsNil)
+	c.Assert(idx.Version, Equals, uint32(2))
+}
+
+func (s *IndexSuite) TestCommit(c *C) {
+	idx := &index.Index{}
+	idx.Version = 2
+
+	base := memory.NewStorage()
+	err := base.SetIndex(idx)
+	c.Assert(err, IsNil)
+
+	temporal := memory.NewStorage()
+
+	idx = &index.Index{}
+	idx.Version = 3
+
+	is := NewIndexStorage(base, temporal)
+	err = is.SetIndex(idx)
+	c.Assert(err, IsNil)
+
+	err = is.Commit()
+	c.Assert(err, IsNil)
+
+	baseIndex, err := base.Index()
+	c.Assert(err, IsNil)
+	c.Assert(baseIndex.Version, Equals, uint32(3))
+}

storage/transactional/module.go

@@ -0,0 +1 @@
+package transactional

storage/transactional/object.go

@@ -61,3 +61,15 @@ func (o *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.Encode
 		temporalIter,
 	}), nil
 }
+
+func (o *ObjectStorage) Commit() error {
+	iter, err := o.temporal.IterEncodedObjects(plumbing.AnyObject)
+	if err != nil {
+		return err
+	}
+
+	return iter.ForEach(func(obj plumbing.EncodedObject) error {
+		_, err := o.EncodedObjectStorer.SetEncodedObject(obj)
+		return err
+	})
+}

storage/transactional/object_test.go

@@ -117,3 +117,37 @@ func (s *ObjectSuite) TestIterEncodedObjects(c *C) {
 	c.Assert(hashes[0], Equals, ch)
 	c.Assert(hashes[1], Equals, th)
 }
+
+func (s *ObjectSuite) TestCommit(c *C) {
+	base := memory.NewStorage()
+	temporal := memory.NewStorage()
+
+	os := NewObjectStorage(base, temporal)
+
+	commit := base.NewEncodedObject()
+	commit.SetType(plumbing.CommitObject)
+
+	_, err := os.SetEncodedObject(commit)
+	c.Assert(err, IsNil)
+
+	tree := base.NewEncodedObject()
+	tree.SetType(plumbing.TreeObject)
+
+	_, err = os.SetEncodedObject(tree)
+	c.Assert(err, IsNil)
+
+	err = os.Commit()
+	c.Assert(err, IsNil)
+
+	iter, err := base.IterEncodedObjects(plumbing.AnyObject)
+	c.Assert(err, IsNil)
+
+	var hashes []plumbing.Hash
+	err = iter.ForEach(func(obj plumbing.EncodedObject) error {
+		hashes = append(hashes, obj.Hash())
+		return nil
+	})
+
+	c.Assert(err, IsNil)
+	c.Assert(hashes, HasLen, 2)
+}

storage/transactional/reference.go

@@ -0,0 +1,126 @@
+package transactional
+
+import (
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+	"gopkg.in/src-d/go-git.v4/storage"
+)
+
+type ReferenceStorage struct {
+	storer.ReferenceStorer
+	temporal storer.ReferenceStorer
+
+	// deleted, remaining references at this maps are going to be deleted when
+	// commit is requested, the entries are added when RemoveReference is called
+	// and deleted if SetReference is called.
+	deleted map[plumbing.ReferenceName]struct{}
+	// packRefs if true PackRefs is going to be called in the based storer when
+	// commit is called.
+	packRefs bool
+}
+
+func NewReferenceStorage(s, temporal storer.ReferenceStorer) *ReferenceStorage {
+	return &ReferenceStorage{
+		ReferenceStorer: s,
+		temporal:        temporal,
+
+		deleted: make(map[plumbing.ReferenceName]struct{}, 0),
+	}
+}
+
+func (r *ReferenceStorage) SetReference(ref *plumbing.Reference) error {
+	delete(r.deleted, ref.Name())
+	return r.temporal.SetReference(ref)
+}
+
+func (r *ReferenceStorage) CheckAndSetReference(ref, old *plumbing.Reference) error {
+	if old == nil {
+		return r.SetReference(ref)
+	}
+
+	tmp, err := r.temporal.Reference(old.Name())
+	if err == plumbing.ErrReferenceNotFound {
+		tmp, err = r.ReferenceStorer.Reference(old.Name())
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if tmp.Hash() != old.Hash() {
+		return storage.ErrReferenceHasChanged
+	}
+
+	return r.SetReference(ref)
+}
+
+func (r ReferenceStorage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
+	if _, deleted := r.deleted[n]; deleted {
+		return nil, plumbing.ErrReferenceNotFound
+	}
+
+	ref, err := r.temporal.Reference(n)
+	if err == plumbing.ErrReferenceNotFound {
+		return r.ReferenceStorer.Reference(n)
+	}
+
+	return ref, err
+}
+
+func (r ReferenceStorage) IterReferences() (storer.ReferenceIter, error) {
+	baseIter, err := r.ReferenceStorer.IterReferences()
+	if err != nil {
+		return nil, err
+	}
+
+	temporalIter, err := r.temporal.IterReferences()
+	if err != nil {
+		return nil, err
+	}
+
+	return storer.NewMultiReferenceIter([]storer.ReferenceIter{
+		baseIter,
+		temporalIter,
+	}), nil
+}
+
+func (r ReferenceStorage) CountLooseRefs() (int, error) {
+	tc, err := r.temporal.CountLooseRefs()
+	if err != nil {
+		return -1, err
+	}
+
+	bc, err := r.ReferenceStorer.CountLooseRefs()
+	if err != nil {
+		return -1, err
+	}
+
+	return tc + bc, nil
+}
+
+func (r ReferenceStorage) PackRefs() error {
+	r.packRefs = true
+	return nil
+}
+
+func (r ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error {
+	r.deleted[n] = struct{}{}
+	return r.temporal.RemoveReference(n)
+}
+
+func (r ReferenceStorage) Commit() error {
+	for name := range r.deleted {
+		if err := r.ReferenceStorer.RemoveReference(name); err != nil {
+			return err
+		}
+	}
+
+	iter, err := r.temporal.IterReferences()
+	if err != nil {
+		return err
+	}
+
+	return iter.ForEach(func(ref *plumbing.Reference) error {
+		return r.ReferenceStorer.SetReference(ref)
+	})
+}