func TestLuaEval(t *T) {
c1, err := redis.Dial("tcp", "127.0.0.1:6379")
require.Nil(t, err)
c2, err := cluster.New("127.0.0.1:7000")
require.Nil(t, err)
cs := []Cmder{c1, c2}
for _, c := range cs {
script, key, val := randTestScript()
s, err := LuaEval(c, script, 1, key, val).Str()
require.Nil(t, err)
assert.Equal(t, "OK", s)
// The second time the command will be hashed
script, key, val = randTestScript()
s, err = LuaEval(c, script, 1, key, val).Str()
require.Nil(t, err)
assert.Equal(t, "OK", s)
s, err = c.Cmd("GET", key).Str()
require.Nil(t, err)
assert.Equal(t, val, s)
}
}
func main() {
c, err := cluster.New("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 main() {
fromInfo := entity.NewFromInfo()
fromInfo.Ctx = 1
fromInfo.FromUid = 1012616
fromInfo.FromIid = "Qereodsjfeefjdfsfsd"
fromInfo.FromNjs = "node-01"
client, _ := cluster.New(hostRedis)
for {
str, _ := client.Cmd("lrange", "op_1012623_xxxxxxxxxxxxxxxxsdsdsdxxx", 0, -1).Str()
fmt.Println("--: " + str)
}
}
// Similar to TestScan, but scans over a whole cluster
func TestClusterScan(t *T) {
cluster, err := cluster.New("127.0.0.1:7000")
require.Nil(t, err)
prefix := "scanTestPrefix"
fullMap := map[string]bool{}
for i := 0; i < 100; i++ {
key := prefix + ":" + strconv.Itoa(i)
fullMap[key] = true
require.Nil(t, cluster.Cmd("SET", key, "1").Err)
}
// make sure we get all results when scanning with an existing prefix
ch := make(chan string)
go func() {
err = Scan(cluster, ch, "SCAN", "", prefix+":*")
}()
testMap := map[string]bool{}
for key := range ch {
testMap[key] = true
}
require.Nil(t, err)
assert.Equal(t, fullMap, testMap)
// make sure we don't get any results when scanning with a non-existing
// prefix
ch = make(chan string)
go func() {
err = Scan(cluster, ch, "SCAN", "", prefix+"DNE:*")
}()
testMap = map[string]bool{}
for key := range ch {
testMap[key] = true
}
require.Nil(t, err)
assert.Equal(t, map[string]bool{}, testMap)
}
// Similar to TestScanner, but scans over a whole cluster
func TestScannerCluster(t *T) {
cluster, err := cluster.New("127.0.0.1:7000")
require.Nil(t, err)
prefix, fullMap := randPrefix(t, cluster, 100)
// make sure we get all results when scanning with an existing prefix
testMap := map[string]bool{}
sc := NewScanner(cluster, ScanOpts{Command: "SCAN", Pattern: prefix + ":*"})
for sc.HasNext() {
testMap[sc.Next()] = true
}
require.Nil(t, sc.Err())
assert.Equal(t, fullMap, testMap)
// make sure we don't get any results when scanning with a non-existing
// prefix
testMap = map[string]bool{}
sc = NewScanner(cluster, ScanOpts{Command: "SCAN", Pattern: prefix + "DNE:*"})
for sc.HasNext() {
testMap[sc.Next()] = true
}
require.Nil(t, sc.Err())
assert.Empty(t, testMap)
}
func main() {
// redis
redisClient, _ := cluster.New(hostRedis)
go func() {
for {
// str, err := redisClient.Cmd("rpop", fmt.Sprintf("%d_%s", UID, IID)).Str()
// if err != nil {
// log.Println("noti redis error:", err)
// }
// if str != "" {
// fmt.Println("--: " + str)
// }
str, _ := redisClient.Cmd("rpop", fmt.Sprintf("op_%d_%s", UID, IID)).Str()
// if err != nil {
// log.Println("op redis error:", err)
// }
if str != "" {
fmt.Println("--: " + str)
}
// dec := json.NewDecoder(strings.NewReader(str))
// dec.UseNumber()
// udsResult := &UdsResult{}
// dec.Decode(udsResult)
// ctx := udsResult.Ctx
// context, ok := udsCallCtxs[ctx]
// if !ok {
// fmt.Println(ctx, "is nil. mn: ", udsResult.Mn)
// continue
// }
// clientResult := &ClientResult{}
// clientResult.Ctx = context.ClientContextId
// code, _ := strconv.ParseInt(udsResult.Code, 10, 32)
// clientResult.Code = int(code)
// clientResult.Mn = context.ClientMn + "_result"
// clientResult.Body = udsResult.Body
// b, _ := json.Marshal(clientResult)
// so := context.So
// (*so).Emit("videbonjs10", string(b))
// delete(udsCallCtxs, ctx)
}
}()
// uds
socket, _ := thrift.NewTSocketTimeout(hostUds, 3*time.Second)
transport := thrift.NewTBufferedTransport(socket, 10240)
protocol := thrift.NewTBinaryProtocolTransport(transport)
//mprotocol := thrift.NewTMultiplexedProtocol(protocol, "userManager")
//userManagerClient = service.NewUserManagerClientProtocol(transport, protocol, mprotocol)
mprotocol := thrift.NewTMultiplexedProtocol(protocol, "chatManager")
chatManagerClient := service.NewChatManagerClientProtocol(transport, protocol, mprotocol)
err := transport.Open()
if err != nil {
log.Fatal("transport open error:", err)
}
fromInfo := entity.NewFromInfo()
fromInfo.Ctx = getUdsCtx()
fromInfo.FromUid = UID
fromInfo.FromIid = IID
fromInfo.FromNjs = NJS
// context := Context{}
// context.So = so
// context.ClientContextId = msg.Ctx
// context.ClientMn = msg.Mn
//udsCallCtxs[fromInfo.Ctx] = context
var index int64 = 0
for i := 0; i < 100; i++ {
func() {
index++
log.Println(index)
message := &entity.ChatMessage{
Uid: 1000501,
Gid: 803,
Cmt: 1,
Content: fmt.Sprintf("message testing %d", index),
}
mid, err := chatManagerClient.SendChatMessage(message, fromInfo)
if err != nil {
log.Fatal("SendChatMessage error:", err)
//delete(udsCallCtxs, fromInfo.Ctx)
}
log.Println("mid:", mid)
}()
// err = transport.Close()
// if err != nil {
// log.Fatal("transport close error:", err)
// }
}
time.Sleep(10 * time.Second)
// // socketio
// server, err := socketio.NewServer(nil)
// if err != nil {
// log.Fatal(err)
// }
// server.On("connection", func(so socketio.Socket) {
// log.Println("on connection")
// so.Join("chat")
// so.On("videboc10", func(msg ClientMessage) {
// log.Println("on videboc10:", msg)
// handleClientMessage(msg, &so)
// })
// so.On("disconnection", func(reason string) {
// log.Println("on disconnection. reason: " + reason)
// })
// so.On("error", func(error string) {
// log.Println("on error. error:", error)
// })
// })
// server.On("error", func(so socketio.Socket, err error) {
// log.Println("error:", err)
// })
// http.Handle("/socket.io/", server)
// http.Handle("/", http.FileServer(http.Dir("./asset")))
// log.Println("Serving at localhost:5000...")
// log.Fatal(http.ListenAndServe(":5000", nil))
}
func main() {
socket, _ := thrift.NewTSocketTimeout(hostUds, 30000000)
transport := thrift.NewTBufferedTransport(socket, 10240)
protocol := thrift.NewTBinaryProtocolTransport(transport)
mprotocol := thrift.NewTMultiplexedProtocol(protocol, "userManager")
userManagerClient := service.NewUserManagerClientProtocol(transport, protocol, mprotocol)
_ = transport.Open()
fromInfo := entity.NewFromInfo()
fromInfo.Ctx = 1
fromInfo.FromUid = UID
fromInfo.FromIid = IID
fromInfo.FromNjs = NJS
redisClusterClient, _ := cluster.New(hostRedis)
count := 0
go func() {
for {
udsResult, _ := redisClusterClient.Cmd("rpop", fromInfo.FromNjs).Str()
if udsResult != "" {
fmt.Println(udsResult)
count++
fmt.Println(count)
result := &UdsResult{}
dec := json.NewDecoder(strings.NewReader(udsResult))
dec.UseNumber()
if err := dec.Decode(result); err != nil {
log.Fatal(err)
}
// fmt.Println(result)
// b, _ := json.Marshal(result)
// fmt.Println(string(b))
}
}
}()
// socketio
server, err := socketio.NewServer(nil)
if err != nil {
log.Fatal(err)
}
server.On("connection", func(so socketio.Socket) {
log.Println("on connection")
so.Join("chat")
so.On("videboc10", func(msg map[string]interface{}) {
log.Println("on videboc10:", msg)
dec := json.NewDecoder(strings.NewReader(msg))
dec.UseNumber()
clientMessage := &ClientMessage{}
if err := dec.Decode(clientMessage); err != nil {
log.Fatal(err)
}
log.Println(clientMessage.Mn)
if "login" == clientMessage.Mn {
_loginName := clientMessage.Body["login_name"]
_phoneInfo := clientMessage.Body["phone_info"]
_encryptMode := clientMessage.Body["encryptMode"]
_isSecreted := clientMessage.Body["isSecreted"]
_iid := clientMessage.Body["iid"]
loginName, _ := _loginName.(string)
phoneInfo, _ := _phoneInfo.(string)
encryptMode, _ := _encryptMode.(string) // AES
isSecreted, _ := _isSecreted.(bool) // TRUE
iid, _ := _iid.(string)
fmt.Println(loginName)
fmt.Println(phoneInfo)
fmt.Println(encryptMode)
fmt.Println(isSecreted)
fmt.Println(iid)
reUid := regexp.MustCompile(`^\d{0,10}$`)
rePhone := regexp.MustCompile(`^\d{11,12}$`)
if reUid.MatchString(loginName) {
uid, _ := strconv.ParseInt(loginName, 10, 32)
err := userManagerClient.GetUserById(uid, fromInfo)
if err != nil {
fmt.Println(err)
}
} else if rePhone.MatchString(loginName) {
} else {
}
}
})
so.On("disconnection", func(reason string) {
log.Println("on disconnection. reason:", reason)
})
})
server.On("error", func(so socketio.Socket, err error) {
log.Println("error:", err)
})
http.Handle("/socket.io/", server)
http.Handle("/", http.FileServer(http.Dir("./asset")))
log.Println("Serving at localhost:5000...")
log.Fatal(http.ListenAndServe(":5000", nil))
}