func main() {
c, err := cluster.NewCluster("localhost:7000")
if err != nil {
log.Fatal(err)
}
oldKeys := make(chan string, 1000)
doRand := time.Tick(100 * time.Millisecond)
doOldRand := time.Tick(1 * time.Second)
for {
select {
case <-doRand:
key := randString()
doGetSet(c, key)
select {
case oldKeys <- key:
default:
}
case <-doOldRand:
select {
case key := <-oldKeys:
doGetSet(c, key)
default:
}
}
}
}
func PushCluster(settings *yaml.Yaml, message Message) {
debug := settings.Get("debug").(bool)
redis_connection := settings.Get("redis_connection").(string)
redis_list := settings.Get("redis_list").(string)
redis_db := settings.Get("redis_db").(int)
t := time.Now()
ts := t.Format("Mon Jan 2 15:04:05 -0700 MST 2006")
rc, err := cluster.NewCluster(redis_connection)
if err != nil {
fmt.Printf("[%s] ERROR Error received: %s\n", ts, err)
}
if debug {
fmt.Printf("[%s] INFO Connection made to Redis server %s\n", ts, redis_connection)
}
r := rc.Cmd("SELECT", 0)
if r.Err != nil {
fmt.Printf("[%s] ERROR Error received: %s\n", ts, r.Err)
} else {
if debug {
fmt.Printf("[%s] INFO Redis database selected: %d\n", ts, redis_db)
}
}
j, errj := json.Marshal(message)
if errj != nil {
fmt.Printf("[%s] ERROR Error received: %s\n", ts, errj)
}
r = rc.Cmd("LPUSH", redis_list, j)
rc.Close()
}
func (s *server) init() {
// snappy
if env := os.Getenv(ENV_SNAPPY); env != "" {
s.enable_snappy = true
}
// read redis host
redis_host := DEFAULT_REDIS_HOST
if env := os.Getenv(ENV_REDIS_HOST); env != "" {
redis_host = env
}
// start connection to redis cluster
client, err := cluster.NewCluster(redis_host)
if err != nil {
log.Critical(err)
os.Exit(-1)
}
//存放redis client 句柄
s.redis_client = client
// read mongodb host
mongodb_url := DEFAULT_MONGODB_URL
if env := os.Getenv(ENV_MONGODB_URL); env != "" {
mongodb_url = env
}
// start connection to mongodb
sess, err := mgo.Dial(mongodb_url)
if err != nil {
log.Critical(err)
os.Exit(-1)
}
s.db = sess.DB("")
// wait chan
s.wait = make(chan string, BUFSIZ)
go s.loader_task()
}
func TestBgSave(t *testing.T) {
//连接mongodb
client, err := cluster.NewCluster(DEFAULT_REDIS_HOST)
if err != nil {
t.Fatal(err)
}
//序列化数据
bin, _ := msgpack.Marshal(&TestStruct{3721, "hello", 18, 999, 1.1, 2.2, []byte("world")})
//压缩
if env := os.Getenv(ENV_SNAPPY); env != "" {
if enc, err := snappy.Encode(nil, bin); err == nil {
bin = enc
} else {
t.Fatal(err)
}
}
//存入
reply := client.Cmd("set", test_key, bin)
if reply.Err != nil {
t.Fatal(err)
}
//调用bg save
conn, err := grpc.Dial(address)
if err != nil {
t.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewBgSaveServiceClient(conn)
//传入需要落地的key
_, err = c.MarkDirty(context.Background(), &pb.BgSave_Key{Name: test_key})
if err != nil {
t.Fatalf("could not query: %v", err)
}
}
func TestBgSave(t *testing.T) {
//t.Skip()
// start connection to redis cluster
client, err := cluster.NewCluster(DEFAULT_REDIS_HOST)
if err != nil {
t.Fatal(err)
}
// mset data into redis
bin, _ := msgpack.Marshal(&TestStruct{3721, "hello", 18, 999, 1.1, 2.2, []byte("world")})
// snappy
if env := os.Getenv(ENV_SNAPPY); env != "" {
if enc, err := snappy.Encode(nil, bin); err == nil {
bin = enc
} else {
t.Fatal(err)
}
}
reply := client.Cmd("set", test_key, bin)
if reply.Err != nil {
t.Fatal(reply.Err)
}
// Set up a connection to the server.
conn, err := grpc.Dial(address)
if err != nil {
t.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewBgSaveServiceClient(conn)
// Contact the server and print out its response.
_, err = c.MarkDirty(context.Background(), &pb.BgSave_Key{Name: test_key})
if err != nil {
t.Fatalf("could not query: %v", err)
}
}
func pull(rtm *slack.RTM, o Opts) {
/*
Using a FIFO queue
*/
t := time.Now()
ts := t.Format("Mon Jan 2 15:04:05 -0700 MST 2006")
rc, err := cluster.NewCluster(o.redis_connection)
if err != nil {
fmt.Printf("[%s] ERROR Redis connection error: %s\n", ts, err)
os.Exit(1)
}
r := rc.Cmd("SELECT", o.redis_db)
for {
t = time.Now()
ts = t.Format("Mon Jan 2 15:04:05 -0700 MST 2006")
r = rc.Cmd("RPOP", o.redis_list)
switch r.Type {
case redis.ErrorReply:
fmt.Printf("[%s] ERROR ErrorReply received: %s\n", ts, r.Err.Error())
case redis.NilReply:
if o.debug {
fmt.Printf("[%s] INFO NilReply reply received\n", ts)
}
case redis.StatusReply:
if o.debug {
fmt.Printf("[%s] INFO StatusReply reply received: not processing\n", ts)
}
case redis.BulkReply:
// Send to Slack
data, err := r.Bytes()
if err != nil {
fmt.Printf("[%s] ERROR Error received: %s\n", ts, err)
} else {
if o.json {
type Message struct {
Name string
Source string
Detail string
}
var message Message
err := json.Unmarshal(data, &message)
if err != nil {
fmt.Printf("[%s] ERROR Error received: %s\n", ts, err)
}
params := slack.PostMessageParameters{
Username: "******",
}
attachment := slack.Attachment{
Pretext: message.Source,
Text: message.Detail,
}
params.Attachments = []slack.Attachment{attachment}
channelID, timestamp, err := rtm.PostMessage(o.slack_channel, string(message.Name), params)
if err != nil {
fmt.Printf("[%s] ERROR Error received: %s\n", ts, err)
return
}
if o.debug {
fmt.Printf("[%s] INFO Message %+v successfully sent to channel %s at %s", ts, message, channelID, timestamp)
}
} else {
if o.debug {
fmt.Printf("[%s] INFO BulkReply reply received: %s\n", ts, data)
}
rtm.SendMessage(rtm.NewOutgoingMessage(string(data), o.slack_channel))
}
}
case redis.MultiReply:
if o.debug {
fmt.Printf("[%s] INFO MultiReply reply received: not processing\n", ts)
}
case redis.IntegerReply:
if o.debug {
fmt.Printf("[%s] INFO IntegerReply reply received: not processing\n", ts)
}
default:
if o.debug {
fmt.Printf("[%s] INFO Unknown reply received: not processing\n", ts)
}
}
time.Sleep(time.Duration(o.watch_interval) * time.Millisecond)
}
}
