format: packfile based on ObjectStorage and CRC32 calculation

2 files changed, 34 insertions, 27 deletions

diff --git a/storage/filesystem/internal/dotgit/dotgit.go b/storage/filesystem/internal/dotgit/dotgit.go
index 3a985d5..d21b754 100644
--- a/storage/filesystem/internal/dotgit/dotgit.go
+++ b/storage/filesystem/internal/dotgit/dotgit.go
@@ -194,34 +194,34 @@ func isHexAlpha(b byte) bool {
 }
 
 type PackWriter struct {
-	fs         fs.Filesystem
-	file       fs.File
-	writer     io.Writer
-	pipeReader io.ReadCloser
-	pipeWriter io.WriteCloser
-	hash       core.Hash
-	index      index.Index
-	result     chan error
+	fs     fs.Filesystem
+	sr     io.ReadCloser
+	sw     io.WriteCloser
+	fw     fs.File
+	mw     io.Writer
+	hash   core.Hash
+	index  index.Index
+	result chan error
 }
 
 func newPackWrite(fs fs.Filesystem) (*PackWriter, error) {
-	r, w := io.Pipe()
-
 	temp := sha1.Sum([]byte(time.Now().String()))
 	filename := fmt.Sprintf(".%x", temp)
 
-	file, err := fs.Create(fs.Join(objectsPath, packPath, filename))
+	fw, err := fs.Create(fs.Join(objectsPath, packPath, filename))
 	if err != nil {
 		return nil, err
 	}
 
+	sr, sw := io.Pipe()
+
 	writer := &PackWriter{
-		fs:         fs,
-		file:       file,
-		writer:     io.MultiWriter(w, file),
-		pipeReader: r,
-		pipeWriter: w,
-		result:     make(chan error),
+		fs:     fs,
+		fw:     fw,
+		sr:     sr,
+		sw:     sw,
+		mw:     io.MultiWriter(sw, fw),
+		result: make(chan error),
 	}
 
 	go writer.buildIndex()
@@ -229,16 +229,19 @@ func newPackWrite(fs fs.Filesystem) (*PackWriter, error) {
 }
 
 func (w *PackWriter) buildIndex() {
-	defer w.pipeReader.Close()
-	index, hash, err := index.NewFromPackfile(w.pipeReader)
+	defer w.sr.Close()
+	index, hash, err := index.NewFromPackfile(w.sr)
+
 	w.index = index
 	w.hash = hash
 
+	fmt.Println(hash, w.index)
+
 	w.result <- err
 }
 
 func (w *PackWriter) Write(p []byte) (int, error) {
-	return w.writer.Write(p)
+	return w.mw.Write(p)
 }
 
 func (w *PackWriter) Close() error {
@@ -246,11 +249,11 @@ func (w *PackWriter) Close() error {
 		close(w.result)
 	}()
 
-	if err := w.file.Close(); err != nil {
+	if err := w.fw.Close(); err != nil {
 		return err
 	}
 
-	if err := w.pipeWriter.Close(); err != nil {
+	if err := w.sw.Close(); err != nil {
 		return err
 	}
 
@@ -266,5 +269,5 @@ func (w *PackWriter) save() error {
 
 	//idx, err := w.fs.Create(fmt.Sprintf("%s.idx", base))
 
-	return w.fs.Rename(w.file.Filename(), fmt.Sprintf("%s.pack", base))
+	return w.fs.Rename(w.fw.Filename(), fmt.Sprintf("%s.pack", base))
 }
diff --git a/storage/filesystem/internal/index/index.go b/storage/filesystem/internal/index/index.go
index 2fd2a55..412b78f 100644
--- a/storage/filesystem/internal/index/index.go
+++ b/storage/filesystem/internal/index/index.go
@@ -1,11 +1,13 @@
 package index
 
 import (
+	"fmt"
 	"io"
 
 	"gopkg.in/src-d/go-git.v4/core"
 	"gopkg.in/src-d/go-git.v4/formats/idxfile"
 	"gopkg.in/src-d/go-git.v4/formats/packfile"
+	"gopkg.in/src-d/go-git.v4/storage/memory"
 )
 
 // Index is a database of objects and their offset in a packfile.
@@ -25,6 +27,7 @@ func (i *Index) Decode(r io.Reader) error {
 	}
 
 	for _, e := range idx.Entries {
+		fmt.Println(e.CRC32)
 		(*i)[e.Hash] = int64(e.Offset)
 	}
 
@@ -33,16 +36,17 @@ func (i *Index) Decode(r io.Reader) error {
 
 // NewFrompackfile returns a new index from a packfile reader.
 func NewFromPackfile(r io.Reader) (Index, core.Hash, error) {
-	p := packfile.NewScannerFromReader(r)
-	d := packfile.NewDecoder(p, nil)
+	o := memory.NewStorage().ObjectStorage()
+	s := packfile.NewScannerFromReader(r)
+	d := packfile.NewDecoder(s, o)
 
 	checksum, err := d.Decode()
 	if err != nil {
 		return nil, core.ZeroHash, err
 	}
 
-	index := Index(d.Index())
-	return index, checksum, p.Close()
+	index := Index(d.Offsets())
+	return index, checksum, d.Close()
 }
 
 // Get returns the offset that an object has the packfile.