add log init and restore

Author: Hongchao Deng

db/backend.go

@@ -1,6 +1,9 @@
 package db
 
 import (
+	"fmt"
+	"io/ioutil"
+	"os"
 	"strings"
 
 	"github.com/go-distributed/xtree/db/log"
@@ -9,23 +12,46 @@ import (
 )
 
 type backend struct {
-	bt    *btree.BTree
-	cache *cache
-	rev   int
-	log   *log.Log
+	bt     *btree.BTree
+	cache  *cache
+	rev    int
+	log    *log.Log
+	config *DBConfig
 }
 
 func newBackend() *backend {
-	bt := btree.New(10)
-	log, err := log.Create()
+	dataDir, err := ioutil.TempDir("", "backend")
+	if err != nil {
+		panic("not implemented")
+	}
+
+	config := &DBConfig{
+		DataDir: dataDir,
+	}
+	b, err := newBackendWithConfig(config)
 	if err != nil {
-		panic("Not implemented")
+		panic("not implemented")
 	}
-	return &backend{
-		bt:    bt,
-		cache: newCache(),
-		log:   log,
+	return b
+}
+
+func newBackendWithConfig(config *DBConfig) (b *backend, err error) {
+	bt := btree.New(10)
+	b = &backend{
+		bt:     bt,
+		cache:  newCache(),
+		config: config,
 	}
+	haveLog := log.Exist(config.DataDir)
+	switch haveLog {
+	case false:
+		fmt.Println("didn't have log file. Init...")
+		err = b.init(config)
+	case true:
+		fmt.Println("had log file. Restore...")
+		err = b.restore(config)
+	}
+	return
 }
 
 func (b *backend) getData(offset int64) []byte {
@@ -102,5 +128,26 @@ func (b *backend) Ls(pathname string) (paths []Path) {
 		paths = append(paths, *p)
 		return true
 	})
+
 	return
 }
+
+// init() creates a new log file
+func (b *backend) init(config *DBConfig) (err error) {
+	b.log, err = log.Create(config.DataDir)
+	return
+}
+
+// restore() restores database from the log file.
+func (b *backend) restore(config *DBConfig) (err error) {
+	panic("not implemented")
+}
+
+func (b *backend) testableCrash() (err error) {
+	panic("not implemented")
+}
+
+// clean up resource after testing
+func (b *backend) testableCleanupResource() (err error) {
+	return os.RemoveAll(b.config.DataDir)
+}

db/backend_test.go

@@ -27,6 +27,8 @@ func TestPut(t *testing.T) {
 			t.Errorf("#%d: data = %s, want %s", i, v.data, tt.data)
 		}
 	}
+
+	b.testableCleanupResource()
 }
 
 func TestPutOnExistingPath(t *testing.T) {
@@ -61,6 +63,7 @@ func TestPutOnExistingPath(t *testing.T) {
 			t.Errorf("#%d 2: data = %s, want %s", i, v.data, tt.data2)
 		}
 	}
+	b.testableCleanupResource()
 }
 
 func TestGetMVCC(t *testing.T) {
@@ -96,15 +99,16 @@ func TestGetMVCC(t *testing.T) {
 			t.Errorf("#%d: data = %s, want %s", i, v.data, tt.data)
 		}
 	}
+	b.testableCleanupResource()
 }
 
 func TestLs(t *testing.T) {
-	back := newBackend()
+	b := newBackend()
 	d := []byte("somedata")
-	back.Put(1, *newPath("/a"), d)
-	back.Put(2, *newPath("/a/b"), d)
-	back.Put(3, *newPath("/a/c"), d)
-	back.Put(4, *newPath("/b"), d)
+	b.Put(1, *newPath("/a"), d)
+	b.Put(2, *newPath("/a/b"), d)
+	b.Put(3, *newPath("/a/c"), d)
+	b.Put(4, *newPath("/b"), d)
 
 	tests := []struct {
 		p   string
@@ -118,7 +122,7 @@ func TestLs(t *testing.T) {
 		{"/c", []string{}},
 	}
 	for i, tt := range tests {
-		ps := back.Ls(tt.p)
+		ps := b.Ls(tt.p)
 		if len(ps) != len(tt.wps) {
 			t.Fatalf("#%d: len(ps) = %d, want %d", i, len(ps), len(tt.wps))
 		}
@@ -128,6 +132,10 @@ func TestLs(t *testing.T) {
 			}
 		}
 	}
+	b.testableCleanupResource()
+}
+
+func TestRestore(t *testing.T) {
 }
 
 func BenchmarkPut(b *testing.B) {
@@ -143,6 +151,7 @@ func BenchmarkPut(b *testing.B) {
 	for i := 1; i < b.N; i++ {
 		back.Put(i, path[i], d)
 	}
+	back.testableCleanupResource()
 }
 
 func BenchmarkGetWithCache(b *testing.B) {
@@ -163,6 +172,7 @@ func BenchmarkGetWithCache(b *testing.B) {
 			back.Get(i, path[i])
 		}
 	}
+	back.testableCleanupResource()
 }
 
 func BenchmarkGetWithOutCache(b *testing.B) {
@@ -184,4 +194,5 @@ func BenchmarkGetWithOutCache(b *testing.B) {
 			back.Get(i, path[i])
 		}
 	}
+	back.testableCleanupResource()
 }

db/config.go

@@ -0,0 +1,5 @@
+package db
+
+type DBConfig struct {
+	DataDir string
+}

db/log/log.go

@@ -1,49 +1,64 @@
 package log
 
 import (
-	"io/ioutil"
 	"os"
+	"path"
 
 	"github.com/go-distributed/xtree/db/message"
 )
 
+const (
+	logFilename = "records.log"
+)
+
 type Log struct {
-	f *os.File
+	writeFile, readFile *os.File
+	encoder             *encoder
 }
 
-func Create() (*Log, error) {
-	f, err := ioutil.TempFile("", "backend")
-	if err != nil {
-		return nil, err
+func Create(dataDir string) (l *Log, err error) {
+	p := path.Join(dataDir, logFilename)
+
+	var writeFile, readFile *os.File
+	if writeFile, err = os.OpenFile(p,
+		os.O_WRONLY|os.O_APPEND|os.O_SYNC|os.O_CREATE,
+		0600); err != nil {
+		return
 	}
-	return &Log{f}, nil
+	if readFile, err = os.Open(p); err != nil {
+		return
+	}
+	l = &Log{
+		writeFile: writeFile,
+		readFile:  readFile,
+		encoder:   newEncoder(writeFile),
+	}
+	return
 }
 
-func (l *Log) Destroy() error {
-	if err := l.f.Close(); err != nil {
-		return err
-	}
-	return os.Remove(l.f.Name())
+func Exist(dataDir string) bool {
+	p := path.Join(dataDir, logFilename)
+	_, err := os.Stat(p)
+	return err == nil
 }
 
 func (l *Log) GetRecord(offset int64) (r *message.Record, err error) {
-	if _, err = l.f.Seek(offset, 0); err != nil {
+	if _, err = l.readFile.Seek(offset, 0); err != nil {
 		return
 	}
-	decoder := newDecoder(l.f)
+	decoder := newDecoder(l.readFile)
 	r = &message.Record{}
 	err = decoder.decode(r)
 	return
 }
 
 func (l *Log) Append(r *message.Record) (offset int64, err error) {
-	if offset, err = l.f.Seek(0, 2); err != nil {
+	if offset, err = l.writeFile.Seek(0, os.SEEK_CUR); err != nil {
 		return
 	}
-	encoder := newEncoder(l.f)
-	if err = encoder.encode(r); err != nil {
+	if err = l.encoder.encode(r); err != nil {
 		return
 	}
-	err = encoder.flush()
+	err = l.encoder.flush()
 	return offset, err
 }

db/log/log_test.go

@@ -1,6 +1,8 @@
 package log
 
 import (
+	"io/ioutil"
+	"os"
 	"reflect"
 	"testing"
 
@@ -10,11 +12,17 @@ import (
 func TestAppendAndGetRecord(t *testing.T) {
 	var err error
 	var log *Log
-	if log, err = Create(); err != nil {
-		t.Errorf("Create failed: %v", err)
+	var dataDir string
+
+	if dataDir, err = ioutil.TempDir("", "logtest"); err != nil {
+		t.Errorf("ioutil.TempDir failed: %v", err)
 	}
 
-	defer log.Destroy()
+	defer os.RemoveAll(dataDir)
+
+	if log, err = Create(dataDir); err != nil {
+		t.Errorf("Create failed: %v", err)
+	}
 
 	tests := []struct {
 		offset int64