add vendor

vendor/github.com/siddontang/ledisdb/store/goleveldb/batch.go

@@ -0,0 +1,39 @@
+package goleveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+type WriteBatch struct {
+	db     *DB
+	wbatch *leveldb.Batch
+}
+
+func (w *WriteBatch) Put(key, value []byte) {
+	w.wbatch.Put(key, value)
+}
+
+func (w *WriteBatch) Delete(key []byte) {
+	w.wbatch.Delete(key)
+}
+
+func (w *WriteBatch) Commit() error {
+	return w.db.db.Write(w.wbatch, nil)
+}
+
+func (w *WriteBatch) SyncCommit() error {
+	return w.db.db.Write(w.wbatch, w.db.syncOpts)
+}
+
+func (w *WriteBatch) Rollback() error {
+	w.wbatch.Reset()
+	return nil
+}
+
+func (w *WriteBatch) Close() {
+	w.wbatch.Reset()
+}
+
+func (w *WriteBatch) Data() []byte {
+	return w.wbatch.Dump()
+}

vendor/github.com/siddontang/ledisdb/store/goleveldb/const.go

@@ -0,0 +1,4 @@
+package goleveldb
+
+const DBName = "goleveldb"
+const MemDBName = "memory"

vendor/github.com/siddontang/ledisdb/store/goleveldb/db.go

@@ -0,0 +1,204 @@
+package goleveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/cache"
+	"github.com/syndtr/goleveldb/leveldb/filter"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+
+	"github.com/siddontang/ledisdb/config"
+	"github.com/siddontang/ledisdb/store/driver"
+
+	"os"
+)
+
+const defaultFilterBits int = 10
+
+type Store struct {
+}
+
+func (s Store) String() string {
+	return DBName
+}
+
+type MemStore struct {
+}
+
+func (s MemStore) String() string {
+	return MemDBName
+}
+
+type DB struct {
+	path string
+
+	cfg *config.LevelDBConfig
+
+	db *leveldb.DB
+
+	opts *opt.Options
+
+	iteratorOpts *opt.ReadOptions
+
+	syncOpts *opt.WriteOptions
+
+	cache cache.Cache
+
+	filter filter.Filter
+}
+
+func (s Store) Open(path string, cfg *config.Config) (driver.IDB, error) {
+	if err := os.MkdirAll(path, 0755); err != nil {
+		return nil, err
+	}
+
+	db := new(DB)
+	db.path = path
+	db.cfg = &cfg.LevelDB
+
+	db.initOpts()
+
+	var err error
+	db.db, err = leveldb.OpenFile(db.path, db.opts)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+func (s Store) Repair(path string, cfg *config.Config) error {
+	db, err := leveldb.RecoverFile(path, newOptions(&cfg.LevelDB))
+	if err != nil {
+		return err
+	}
+
+	db.Close()
+	return nil
+}
+
+func (s MemStore) Open(path string, cfg *config.Config) (driver.IDB, error) {
+	db := new(DB)
+	db.path = path
+	db.cfg = &cfg.LevelDB
+
+	db.initOpts()
+
+	var err error
+	db.db, err = leveldb.Open(storage.NewMemStorage(), db.opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+func (s MemStore) Repair(path string, cfg *config.Config) error {
+	return nil
+}
+
+func (db *DB) initOpts() {
+	db.opts = newOptions(db.cfg)
+
+	db.iteratorOpts = &opt.ReadOptions{}
+	db.iteratorOpts.DontFillCache = true
+
+	db.syncOpts = &opt.WriteOptions{}
+	db.syncOpts.Sync = true
+}
+
+func newOptions(cfg *config.LevelDBConfig) *opt.Options {
+	opts := &opt.Options{}
+	opts.ErrorIfMissing = false
+
+	opts.BlockCacheCapacity = cfg.CacheSize
+
+	//we must use bloomfilter
+	opts.Filter = filter.NewBloomFilter(defaultFilterBits)
+
+	if !cfg.Compression {
+		opts.Compression = opt.NoCompression
+	} else {
+		opts.Compression = opt.SnappyCompression
+	}
+
+	opts.BlockSize = cfg.BlockSize
+	opts.WriteBuffer = cfg.WriteBufferSize
+	opts.OpenFilesCacheCapacity = cfg.MaxOpenFiles
+
+	//here we use default value, later add config support
+	opts.CompactionTableSize = 32 * 1024 * 1024
+	opts.WriteL0SlowdownTrigger = 16
+	opts.WriteL0PauseTrigger = 64
+
+	return opts
+}
+
+func (db *DB) Close() error {
+	return db.db.Close()
+}
+
+func (db *DB) Put(key, value []byte) error {
+	return db.db.Put(key, value, nil)
+}
+
+func (db *DB) Get(key []byte) ([]byte, error) {
+	v, err := db.db.Get(key, nil)
+	if err == leveldb.ErrNotFound {
+		return nil, nil
+	}
+	return v, nil
+}
+
+func (db *DB) Delete(key []byte) error {
+	return db.db.Delete(key, nil)
+}
+
+func (db *DB) SyncPut(key []byte, value []byte) error {
+	return db.db.Put(key, value, db.syncOpts)
+}
+
+func (db *DB) SyncDelete(key []byte) error {
+	return db.db.Delete(key, db.syncOpts)
+}
+
+func (db *DB) NewWriteBatch() driver.IWriteBatch {
+	wb := &WriteBatch{
+		db:     db,
+		wbatch: new(leveldb.Batch),
+	}
+	return wb
+}
+
+func (db *DB) NewIterator() driver.IIterator {
+	it := &Iterator{
+		db.db.NewIterator(nil, db.iteratorOpts),
+	}
+
+	return it
+}
+
+func (db *DB) NewSnapshot() (driver.ISnapshot, error) {
+	snapshot, err := db.db.GetSnapshot()
+	if err != nil {
+		return nil, err
+	}
+
+	s := &Snapshot{
+		db:  db,
+		snp: snapshot,
+	}
+
+	return s, nil
+}
+
+func (db *DB) Compact() error {
+	return db.db.CompactRange(util.Range{nil, nil})
+}
+
+func init() {
+	driver.Register(Store{})
+	driver.Register(MemStore{})
+}

vendor/github.com/siddontang/ledisdb/store/goleveldb/iterator.go

@@ -0,0 +1,49 @@
+package goleveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+)
+
+type Iterator struct {
+	it iterator.Iterator
+}
+
+func (it *Iterator) Key() []byte {
+	return it.it.Key()
+}
+
+func (it *Iterator) Value() []byte {
+	return it.it.Value()
+}
+
+func (it *Iterator) Close() error {
+	if it.it != nil {
+		it.it.Release()
+		it.it = nil
+	}
+	return nil
+}
+
+func (it *Iterator) Valid() bool {
+	return it.it.Valid()
+}
+
+func (it *Iterator) Next() {
+	it.it.Next()
+}
+
+func (it *Iterator) Prev() {
+	it.it.Prev()
+}
+
+func (it *Iterator) First() {
+	it.it.First()
+}
+
+func (it *Iterator) Last() {
+	it.it.Last()
+}
+
+func (it *Iterator) Seek(key []byte) {
+	it.it.Seek(key)
+}

vendor/github.com/siddontang/ledisdb/store/goleveldb/snapshot.go

@@ -0,0 +1,26 @@
+package goleveldb
+
+import (
+	"github.com/siddontang/ledisdb/store/driver"
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+type Snapshot struct {
+	db  *DB
+	snp *leveldb.Snapshot
+}
+
+func (s *Snapshot) Get(key []byte) ([]byte, error) {
+	return s.snp.Get(key, s.db.iteratorOpts)
+}
+
+func (s *Snapshot) NewIterator() driver.IIterator {
+	it := &Iterator{
+		s.snp.NewIterator(nil, s.db.iteratorOpts),
+	}
+	return it
+}
+
+func (s *Snapshot) Close() {
+	s.snp.Release()
+}