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)
}
}
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))
}