CacheDB (#67)

* Add CacheDB & SimpleMap
* Generic memBatch; Fix cLevelDB tests
* CacheWrap() for CacheDB and MemDB
* Change Iterator to match LeviGo Iterator
* Fixes from review
* cacheWrapWriteMutex and some race fixes
* Use tmlibs/common
* NewCWWMutex is exposed.  DB can be CacheWrap'd
* Remove GetOK, not needed
* Fsdb (#72)
* Add FSDB
* Review fixes from Anton
* Review changes
* Fixes from review

db/c_level_db.go

@@ -7,8 +7,6 @@ import (
 	"path"
 
 	"github.com/jmhodges/levigo"
-
-	. "github.com/tendermint/tmlibs/common"
 )
 
 func init() {
@@ -24,6 +22,8 @@ type CLevelDB struct {
 	ro     *levigo.ReadOptions
 	wo     *levigo.WriteOptions
 	woSync *levigo.WriteOptions
+
+	cwwMutex
 }
 
 func NewCLevelDB(name string, dir string) (*CLevelDB, error) {
@@ -45,6 +45,8 @@ func NewCLevelDB(name string, dir string) (*CLevelDB, error) {
 		ro:     ro,
 		wo:     wo,
 		woSync: woSync,
+
+		cwwMutex: NewCWWMutex(),
 	}
 	return database, nil
 }
@@ -52,7 +54,7 @@ func NewCLevelDB(name string, dir string) (*CLevelDB, error) {
 func (db *CLevelDB) Get(key []byte) []byte {
 	res, err := db.db.Get(db.ro, key)
 	if err != nil {
-		PanicCrisis(err)
+		panic(err)
 	}
 	return res
 }
@@ -60,28 +62,28 @@ func (db *CLevelDB) Get(key []byte) []byte {
 func (db *CLevelDB) Set(key []byte, value []byte) {
 	err := db.db.Put(db.wo, key, value)
 	if err != nil {
-		PanicCrisis(err)
+		panic(err)
 	}
 }
 
 func (db *CLevelDB) SetSync(key []byte, value []byte) {
 	err := db.db.Put(db.woSync, key, value)
 	if err != nil {
-		PanicCrisis(err)
+		panic(err)
 	}
 }
 
 func (db *CLevelDB) Delete(key []byte) {
 	err := db.db.Delete(db.wo, key)
 	if err != nil {
-		PanicCrisis(err)
+		panic(err)
 	}
 }
 
 func (db *CLevelDB) DeleteSync(key []byte) {
 	err := db.db.Delete(db.woSync, key)
 	if err != nil {
-		PanicCrisis(err)
+		panic(err)
 	}
 }
 
@@ -97,11 +99,11 @@ func (db *CLevelDB) Close() {
 }
 
 func (db *CLevelDB) Print() {
-	iter := db.db.NewIterator(db.ro)
-	defer iter.Close()
-	for iter.Seek(nil); iter.Valid(); iter.Next() {
-		key := iter.Key()
-		value := iter.Value()
+	itr := db.Iterator()
+	defer itr.Close()
+	for itr.Seek(nil); itr.Valid(); itr.Next() {
+		key := itr.Key()
+		value := itr.Value()
 		fmt.Printf("[%X]:\t[%X]\n", key, value)
 	}
 }
@@ -112,25 +114,24 @@ func (db *CLevelDB) Stats() map[string]string {
 
 	stats := make(map[string]string)
 	for _, key := range keys {
-		str, err := db.db.GetProperty(key)
-		if err == nil {
-			stats[key] = str
-		}
+		str := db.db.PropertyValue(key)
+		stats[key] = str
 	}
 	return stats
 }
 
-func (db *CLevelDB) Iterator() Iterator {
-	return db.db.NewIterator(nil, nil)
+func (db *CLevelDB) CacheWrap() interface{} {
+	return NewCacheDB(db, db.GetWriteLockVersion())
 }
 
+//----------------------------------------
+// Batch
+
 func (db *CLevelDB) NewBatch() Batch {
 	batch := levigo.NewWriteBatch()
 	return &cLevelDBBatch{db, batch}
 }
 
-//--------------------------------------------------------------------------------
-
 type cLevelDBBatch struct {
 	db    *CLevelDB
 	batch *levigo.WriteBatch
@@ -147,6 +148,66 @@ func (mBatch *cLevelDBBatch) Delete(key []byte) {
 func (mBatch *cLevelDBBatch) Write() {
 	err := mBatch.db.db.Write(mBatch.db.wo, mBatch.batch)
 	if err != nil {
-		PanicCrisis(err)
+		panic(err)
 	}
 }
+
+//----------------------------------------
+// Iterator
+
+func (db *CLevelDB) Iterator() Iterator {
+	itr := db.db.NewIterator(db.ro)
+	itr.Seek([]byte{0x00})
+	return cLevelDBIterator{itr}
+}
+
+type cLevelDBIterator struct {
+	itr *levigo.Iterator
+}
+
+func (c cLevelDBIterator) Seek(key []byte) {
+	if key == nil {
+		key = []byte{0x00}
+	}
+	c.itr.Seek(key)
+}
+
+func (c cLevelDBIterator) Valid() bool {
+	return c.itr.Valid()
+}
+
+func (c cLevelDBIterator) Key() []byte {
+	if !c.itr.Valid() {
+		panic("cLevelDBIterator Key() called when invalid")
+	}
+	return c.itr.Key()
+}
+
+func (c cLevelDBIterator) Value() []byte {
+	if !c.itr.Valid() {
+		panic("cLevelDBIterator Value() called when invalid")
+	}
+	return c.itr.Value()
+}
+
+func (c cLevelDBIterator) Next() {
+	if !c.itr.Valid() {
+		panic("cLevelDBIterator Next() called when invalid")
+	}
+	c.itr.Next()
+}
+
+func (c cLevelDBIterator) Prev() {
+	if !c.itr.Valid() {
+		panic("cLevelDBIterator Prev() called when invalid")
+	}
+	c.itr.Prev()
+}
+
+func (c cLevelDBIterator) Close() {
+	c.itr.Close()
+}
+
+func (c cLevelDBIterator) GetError() error {
+	return c.itr.GetError()
+}