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

   1 // +build gcc
   2
   3 package db
   4
   5 import (
   6         "fmt"
   7         "path"
   8
   9         "github.com/jmhodges/levigo"
  10
  11         . "github.com/tendermint/tmlibs/common"
  12 )
  13
  14 func init() {
  15         dbCreator := func(name string, dir string) (DB, error) {
  16                 return NewCLevelDB(name, dir)
  17         }
  18         registerDBCreator(LevelDBBackendStr, dbCreator, true)
  19         registerDBCreator(CLevelDBBackendStr, dbCreator, false)
  20 }
  21
  22 type CLevelDB struct {
  23         db     *levigo.DB
  24         ro     *levigo.ReadOptions
  25         wo     *levigo.WriteOptions
  26         woSync *levigo.WriteOptions
  27 }
  28
  29 func NewCLevelDB(name string, dir string) (*CLevelDB, error) {
  30         dbPath := path.Join(dir, name+".db")
  31
  32         opts := levigo.NewOptions()
  33         opts.SetCache(levigo.NewLRUCache(1 << 30))
  34         opts.SetCreateIfMissing(true)
  35         db, err := levigo.Open(dbPath, opts)
  36         if err != nil {
  37                 return nil, err
  38         }
  39         ro := levigo.NewReadOptions()
  40         wo := levigo.NewWriteOptions()
  41         woSync := levigo.NewWriteOptions()
  42         woSync.SetSync(true)
  43         database := &CLevelDB{
  44                 db:     db,
  45                 ro:     ro,
  46                 wo:     wo,
  47                 woSync: woSync,
  48         }
  49         return database, nil
  50 }
  51
  52 func (db *CLevelDB) Get(key []byte) []byte {
  53         res, err := db.db.Get(db.ro, key)
  54         if err != nil {
  55                 PanicCrisis(err)
  56         }
  57         return res
  58 }
  59
  60 func (db *CLevelDB) Set(key []byte, value []byte) {
  61         err := db.db.Put(db.wo, key, value)
  62         if err != nil {
  63                 PanicCrisis(err)
  64         }
  65 }
  66
  67 func (db *CLevelDB) SetSync(key []byte, value []byte) {
  68         err := db.db.Put(db.woSync, key, value)
  69         if err != nil {
  70                 PanicCrisis(err)
  71         }
  72 }
  73
  74 func (db *CLevelDB) Delete(key []byte) {
  75         err := db.db.Delete(db.wo, key)
  76         if err != nil {
  77                 PanicCrisis(err)
  78         }
  79 }
  80
  81 func (db *CLevelDB) DeleteSync(key []byte) {
  82         err := db.db.Delete(db.woSync, key)
  83         if err != nil {
  84                 PanicCrisis(err)
  85         }
  86 }
  87
  88 func (db *CLevelDB) DB() *levigo.DB {
  89         return db.db
  90 }
  91
  92 func (db *CLevelDB) Close() {
  93         db.db.Close()
  94         db.ro.Close()
  95         db.wo.Close()
  96         db.woSync.Close()
  97 }
  98
  99 func (db *CLevelDB) Print() {
 100         iter := db.db.NewIterator(db.ro)
 101         defer iter.Close()
 102         for iter.Seek(nil); iter.Valid(); iter.Next() {
 103                 key := iter.Key()
 104                 value := iter.Value()
 105                 fmt.Printf("[%X]:\t[%X]\n", key, value)
 106         }
 107 }
 108
 109 func (db *CLevelDB) Stats() map[string]string {
 110         // TODO: Find the available properties for the C LevelDB implementation
 111         keys := []string{}
 112
 113         stats := make(map[string]string)
 114         for _, key := range keys {
 115                 str, err := db.db.GetProperty(key)
 116                 if err == nil {
 117                         stats[key] = str
 118                 }
 119         }
 120         return stats
 121 }
 122
 123 func (db *CLevelDB) Iterator() Iterator {
 124         return db.db.NewIterator(nil, nil)
 125 }
 126
 127 func (db *CLevelDB) NewBatch() Batch {
 128         batch := levigo.NewWriteBatch()
 129         return &cLevelDBBatch{db, batch}
 130 }
 131
 132 //--------------------------------------------------------------------------------
 133
 134 type cLevelDBBatch struct {
 135         db    *CLevelDB
 136         batch *levigo.WriteBatch
 137 }
 138
 139 func (mBatch *cLevelDBBatch) Set(key, value []byte) {
 140         mBatch.batch.Put(key, value)
 141 }
 142
 143 func (mBatch *cLevelDBBatch) Delete(key []byte) {
 144         mBatch.batch.Delete(key)
 145 }
 146
 147 func (mBatch *cLevelDBBatch) Write() {
 148         err := mBatch.db.db.Write(mBatch.db.wo, mBatch.batch)
 149         if err != nil {
 150                 PanicCrisis(err)
 151         }
 152 }