vendor/github.com/tendermint/tmlibs/db/go_level_db.go

   1 package db
   2
   3 import (
   4         "fmt"
   5         "path"
   6
   7         "github.com/syndtr/goleveldb/leveldb"
   8         "github.com/syndtr/goleveldb/leveldb/errors"
   9         "github.com/syndtr/goleveldb/leveldb/iterator"
  10         "github.com/syndtr/goleveldb/leveldb/opt"
  11         "github.com/syndtr/goleveldb/leveldb/util"
  12
  13         . "github.com/tendermint/tmlibs/common"
  14 )
  15
  16 func init() {
  17         dbCreator := func(name string, dir string) (DB, error) {
  18                 return NewGoLevelDB(name, dir)
  19         }
  20         registerDBCreator(LevelDBBackendStr, dbCreator, false)
  21         registerDBCreator(GoLevelDBBackendStr, dbCreator, false)
  22 }
  23
  24 type GoLevelDB struct {
  25         db *leveldb.DB
  26 }
  27
  28 func NewGoLevelDB(name string, dir string) (*GoLevelDB, error) {
  29         dbPath := path.Join(dir, name+".db")
  30         db, err := leveldb.OpenFile(dbPath, nil)
  31         if err != nil {
  32                 return nil, err
  33         }
  34         database := &GoLevelDB{db: db}
  35         return database, nil
  36 }
  37
  38 func (db *GoLevelDB) Get(key []byte) []byte {
  39         res, err := db.db.Get(key, nil)
  40         if err != nil {
  41                 if err == errors.ErrNotFound {
  42                         return nil
  43                 } else {
  44                         PanicCrisis(err)
  45                 }
  46         }
  47         return res
  48 }
  49
  50 func (db *GoLevelDB) Set(key []byte, value []byte) {
  51         err := db.db.Put(key, value, nil)
  52         if err != nil {
  53                 PanicCrisis(err)
  54         }
  55 }
  56
  57 func (db *GoLevelDB) SetSync(key []byte, value []byte) {
  58         err := db.db.Put(key, value, &opt.WriteOptions{Sync: true})
  59         if err != nil {
  60                 PanicCrisis(err)
  61         }
  62 }
  63
  64 func (db *GoLevelDB) Delete(key []byte) {
  65         err := db.db.Delete(key, nil)
  66         if err != nil {
  67                 PanicCrisis(err)
  68         }
  69 }
  70
  71 func (db *GoLevelDB) DeleteSync(key []byte) {
  72         err := db.db.Delete(key, &opt.WriteOptions{Sync: true})
  73         if err != nil {
  74                 PanicCrisis(err)
  75         }
  76 }
  77
  78 func (db *GoLevelDB) DB() *leveldb.DB {
  79         return db.db
  80 }
  81
  82 func (db *GoLevelDB) Close() {
  83         db.db.Close()
  84 }
  85
  86 func (db *GoLevelDB) Print() {
  87         str, _ := db.db.GetProperty("leveldb.stats")
  88         fmt.Printf("%v\n", str)
  89
  90         iter := db.db.NewIterator(nil, nil)
  91         for iter.Next() {
  92                 key := iter.Key()
  93                 value := iter.Value()
  94                 fmt.Printf("[%X]:\t[%X]\n", key, value)
  95         }
  96 }
  97
  98 func (db *GoLevelDB) Stats() map[string]string {
  99         keys := []string{
 100                 "leveldb.num-files-at-level{n}",
 101                 "leveldb.stats",
 102                 "leveldb.sstables",
 103                 "leveldb.blockpool",
 104                 "leveldb.cachedblock",
 105                 "leveldb.openedtables",
 106                 "leveldb.alivesnaps",
 107                 "leveldb.aliveiters",
 108         }
 109
 110         stats := make(map[string]string)
 111         for _, key := range keys {
 112                 str, err := db.db.GetProperty(key)
 113                 if err == nil {
 114                         stats[key] = str
 115                 }
 116         }
 117         return stats
 118 }
 119
 120 type goLevelDBIterator struct {
 121         source iterator.Iterator
 122 }
 123
 124 // Key returns a copy of the current key.
 125 func (it *goLevelDBIterator) Key() []byte {
 126         key := it.source.Key()
 127         k := make([]byte, len(key))
 128         copy(k, key)
 129
 130         return k
 131 }
 132
 133 // Value returns a copy of the current value.
 134 func (it *goLevelDBIterator) Value() []byte {
 135         val := it.source.Value()
 136         v := make([]byte, len(val))
 137         copy(v, val)
 138
 139         return v
 140 }
 141
 142 func (it *goLevelDBIterator) Error() error {
 143         return it.source.Error()
 144 }
 145
 146 func (it *goLevelDBIterator) Next() bool {
 147         return it.source.Next()
 148 }
 149
 150 func (it *goLevelDBIterator) Release() {
 151         it.source.Release()
 152 }
 153
 154 func (db *GoLevelDB) Iterator() Iterator {
 155         return &goLevelDBIterator{db.db.NewIterator(nil, nil)}
 156 }
 157
 158 func (db *GoLevelDB) IteratorPrefix(prefix []byte) Iterator {
 159         return &goLevelDBIterator{db.db.NewIterator(util.BytesPrefix(prefix), nil)}
 160 }
 161
 162 func (db *GoLevelDB) NewBatch() Batch {
 163         batch := new(leveldb.Batch)
 164         return &goLevelDBBatch{db, batch}
 165 }
 166
 167 //--------------------------------------------------------------------------------
 168
 169 type goLevelDBBatch struct {
 170         db    *GoLevelDB
 171         batch *leveldb.Batch
 172 }
 173
 174 func (mBatch *goLevelDBBatch) Set(key, value []byte) {
 175         mBatch.batch.Put(key, value)
 176 }
 177
 178 func (mBatch *goLevelDBBatch) Delete(key []byte) {
 179         mBatch.batch.Delete(key)
 180 }
 181
 182 func (mBatch *goLevelDBBatch) Write() {
 183         err := mBatch.db.db.Write(mBatch.batch, nil)
 184         if err != nil {
 185                 PanicCrisis(err)
 186         }
 187 }