func reinit() {
if testbl != nil {
testbl.Close()
testbl = nil
}
const path = "/tmp/testdb-rocksdb"
if err := os.RemoveAll(path); err != nil {
log.PanicErrorf(err, "remove '%s' failed", path)
} else {
conf := rocksdb.NewDefaultConfig()
if testdb, err := rocksdb.Open(path, conf, true, false); err != nil {
log.PanicError(err, "open rocksdb failed")
} else {
testbl = rpdb.New(testdb)
}
}
}
func init() {
const path = "/tmp/testdb2-rocksdb"
if err := os.RemoveAll(path); err != nil {
log.PanicErrorf(err, "remove '%s' failed", path)
} else {
conf := rocksdb.NewDefaultConfig()
if testdb, err := rocksdb.Open(path, conf, true, false); err != nil {
log.PanicError(err, "open rocksdb failed")
} else {
testbl2 = rpdb.New(testdb)
}
}
l, err := net.Listen("tcp", ":0")
if err != nil {
log.PanicError(err, "open listen port failed")
}
port = l.Addr().(*net.TCPAddr).Port
go func() {
server := redis.MustServer(&Handler{})
for {
c, err := l.Accept()
if err != nil {
log.PanicError(err, "accept socket failed")
}
go func() {
defer c.Close()
r, w := bufio.NewReader(c), bufio.NewWriter(c)
s := &fakeSession2{}
for {
if req, err := redis.Decode(r); err != nil {
return
} else {
if rsp, err := server.Dispatch(s, req); err != nil {
return
} else if rsp != nil {
if err := redis.Encode(w, rsp); err != nil {
return
}
}
}
}
}()
}
}()
}
func main() {
usage := `
Usage:
rpdb [--config=CONF] [--create|--repair] [--ncpu=N]
Options:
-n N, --ncpu=N set runtime.GOMAXPROCS to N
-c CONF, --config=CONF specify the config file
--create create if not exists
--repair repair database
`
d, err := docopt.Parse(usage, nil, true, "", false)
if err != nil {
log.PanicErrorf(err, "parse arguments failed")
}
if s, ok := d["--ncpu"].(string); ok && len(s) != 0 {
if n, err := strconv.ParseInt(s, 10, 64); err != nil {
log.PanicErrorf(err, "parse --ncpu failed")
} else if n <= 0 || n > 64 {
log.Panicf("parse --ncpu = %d, only accept [1,64]", n)
} else {
runtime.GOMAXPROCS(int(n))
}
}
args.config, _ = d["--config"].(string)
args.create, _ = d["--create"].(bool)
args.repair, _ = d["--repair"].(bool)
conf := &Config{
DBType: "rocksdb",
DBPath: "testdb-rocksdb",
LevelDB: leveldb.NewDefaultConfig(),
RocksDB: rocksdb.NewDefaultConfig(),
Service: service.NewDefaultConfig(),
}
if args.config != "" {
if err := conf.LoadFromFile(args.config); err != nil {
log.PanicErrorf(err, "load config failed")
}
}
log.Infof("load config\n%s\n\n", conf)
var db store.Database
switch t := strings.ToLower(conf.DBType); t {
default:
log.Panicf("unknown db type = '%s'", conf.DBType)
case "leveldb":
db, err = leveldb.Open(conf.DBPath, conf.LevelDB, args.create, args.repair)
case "rocksdb":
db, err = rocksdb.Open(conf.DBPath, conf.RocksDB, args.create, args.repair)
case "boltdb":
db, err = boltdb.Open(conf.DBPath, conf.BoltDB, args.create, args.repair)
}
if err != nil {
log.PanicErrorf(err, "open database failed")
}
bl := rpdb.New(db)
defer bl.Close()
if args.repair {
return
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
for _ = range c {
log.Infof("interrupt and shutdown")
bl.Close()
os.Exit(0)
}
}()
if err := service.Serve(conf.Service, bl); err != nil {
log.ErrorErrorf(err, "service failed")
}
}