forked from xiaonanln/goworld
/
kvdb_redis.go
121 lines (101 loc) · 2.42 KB
/
kvdb_redis.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package kvdbredis
import (
"io"
"github.com/garyburd/redigo/redis"
"github.com/pkg/errors"
"github.com/xiaonanln/goworld/engine/kvdb/types"
)
const (
keyPrefix = "_KV_"
)
type redisKVDB struct {
c redis.Conn
}
// OpenRedisKVDB opens Redis for KVDB backend
func OpenRedisKVDB(url string, dbindex int) (kvdbtypes.KVDBEngine, error) {
c, err := redis.DialURL(url)
if err != nil {
return nil, errors.Wrap(err, "redis dail failed")
}
db := &redisKVDB{
c: c,
}
if err := db.initialize(dbindex); err != nil {
panic(errors.Wrap(err, "redis kvdb initialize failed"))
}
return db, nil
}
func (db *redisKVDB) initialize(dbindex int) error {
if dbindex >= 0 {
if _, err := db.c.Do("SELECT", dbindex); err != nil {
return err
}
}
//keyMatch := keyPrefix + "*"
//r, err := redis.Values(db.c.Do("SCAN", "0", "MATCH", keyMatch, "COUNT", 10000))
//if err != nil {
// return err
//}
//for {
// nextCursor := r[0]
// keys, err := redis.Strings(r[1], nil)
// if err != nil {
// return err
// }
// for _, key := range keys {
// key := key[len(keyPrefix):]
// db.keyTree.ReplaceOrInsert(keyTreeItem{key})
// }
//
// if db.isZeroCursor(nextCursor) {
// break
// }
// r, err = redis.Values(db.c.Do("SCAN", nextCursor, "MATCH", keyMatch, "COUNT", 10000))
// if err != nil {
// return err
// }
//}
return nil
}
func (db *redisKVDB) isZeroCursor(c interface{}) bool {
return string(c.([]byte)) == "0"
}
func (db *redisKVDB) Get(key string) (val string, err error) {
r, err := db.c.Do("GET", keyPrefix+key)
if err != nil {
return "", err
}
if r == nil {
return "", nil
}
return string(r.([]byte)), err
}
func (db *redisKVDB) Put(key string, val string) error {
_, err := db.c.Do("SET", keyPrefix+key, val)
return err
}
type redisKVDBIterator struct {
db *redisKVDB
leftKeys []string
}
func (it *redisKVDBIterator) Next() (kvdbtypes.KVItem, error) {
if len(it.leftKeys) == 0 {
return kvdbtypes.KVItem{}, io.EOF
}
key := it.leftKeys[0]
it.leftKeys = it.leftKeys[1:]
val, err := it.db.Get(key)
if err != nil {
return kvdbtypes.KVItem{}, err
}
return kvdbtypes.KVItem{key, val}, nil
}
func (db *redisKVDB) Find(beginKey string, endKey string) (kvdbtypes.Iterator, error) {
return nil, errors.Errorf("operation not supported on redis")
}
func (db *redisKVDB) Close() {
db.c.Close()
}
func (db *redisKVDB) IsConnectionError(err error) bool {
return err == io.EOF || err == io.ErrUnexpectedEOF
}