func createUdsClients() {
socket, err := thrift.NewTSocketTimeout(hostUds, 1*time.Second)
if err != nil {
log.Fatal("uds socket error:", err)
}
transport := thrift.NewTBufferedTransport(socket, 10240)
inputProtocol := thrift.NewTBinaryProtocolTransport(transport)
outputProtocol := thrift.NewTMultiplexedProtocol(inputProtocol, "userManager")
userManagerClient := services.NewUserManagerClientProtocol(transport, inputProtocol, outputProtocol)
if err := transport.Open(); err != nil {
log.Fatal("uds transport open error[userManager]:", err)
}
userManagerClients <- userManagerClient
socket, err = thrift.NewTSocketTimeout(hostUds, 1*time.Second)
if err != nil {
log.Fatal("uds socket error:", err)
}
transport = thrift.NewTBufferedTransport(socket, 10240)
inputProtocol = thrift.NewTBinaryProtocolTransport(transport)
outputProtocol = thrift.NewTMultiplexedProtocol(inputProtocol, "groupManager")
groupManagerClient := services.NewGroupManagerClientProtocol(transport, inputProtocol, outputProtocol)
if err := transport.Open(); err != nil {
log.Fatal("uds transport open error[groupManager]:", err)
}
groupManagerClients <- groupManagerClient
}
func main() {
socket, err := thrift.NewTSocket("localhost:8090")
if err != nil {
fmt.Printf("There was an error creating your socket! Here it is %v", err)
os.Exit(1)
}
transport := thrift.NewTBufferedTransport(socket, 1024)
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
client := service.NewMakeTagsClientFactory(transport, protocolFactory)
pwd, _ := os.Getwd()
fileName := pwd + "/img.png"
fileName, _ = filepath.Abs(fileName)
imgBytes, err := ioutil.ReadFile(fileName)
if err != nil {
fmt.Printf("There was an err reading the file! Here it is %v", err)
os.Exit(1)
}
socket.Open()
tags, err := client.Generate(service.Image(imgBytes))
if err != nil {
fmt.Printf("There was an err getting the tags! Here it is %v ", err)
os.Exit(1)
}
fmt.Printf("These are the tags for your image %v", tags)
socket.Close()
}
func main() {
fmt.Println("Hello World!")
log.SetFlags(log.Ldate | log.Lmicroseconds)
for i := 0; i < cap(clientsPool); i++ {
socket, err := thrift.NewTSocketTimeout(hostUds, 1*time.Second)
if err != nil {
log.Fatal("uds socket error:", err)
}
transport := thrift.NewTBufferedTransport(socket, 10240)
inputProtocol := thrift.NewTBinaryProtocolTransport(transport)
outputProtocol := thrift.NewTMultiplexedProtocol(inputProtocol, "userManager")
userManagerClient := services.NewUserManagerClientProtocol(transport, inputProtocol, outputProtocol)
if err := transport.Open(); err != nil {
log.Fatal("uds transport open error[userManager]:", err)
}
clientsPool <- userManagerClient
}
log.Print("start...")
times := 100000
ret := make(chan int, times)
for i := 0; i < times; i++ {
go func() {
fromInfo := entity.NewFromInfo()
fromInfo.Ctx = getUdsCtx()
fromInfo.FromUid = 1000501
fromInfo.FromIid = IID
fromInfo.FromNjs = NJS
userManagerClient := <-clientsPool
// _, err := userManagerClient.GetUserByPhone("15201218403")
// _, err := userManagerClient.GetUserById(1000501, entity.DBQueryStatus_NORMAL)
err := userManagerClient.GetUserById(fromInfo.FromUid, fromInfo)
clientsPool <- userManagerClient
if err != nil {
log.Fatal(err)
}
// log.Print(u.GetBasic().Uid)
ret <- 1
}()
}
for i := 0; i < times; i++ {
<-ret
}
log.Print("end...")
}
// Transport上的Buffer是低频需求，不需要优化
func NewTBufferedFramedTransportMaxLength(transport thrift.TTransport,
maxInterval time.Duration, maxBuffered int,
maxLength int) *TBufferedFramedTransport {
return &TBufferedFramedTransport{
TBufferedTransport: thrift.NewTBufferedTransport(transport, 64*1024),
maxLength: maxLength,
Buffer: bytes.NewBuffer(make([]byte, 0, 1024)),
MaxInterval: int64(maxInterval),
MaxBuffered: maxBuffered,
}
}
func Connect(host string, thriftPort string) (*elasticsearch.RestClient, error) {
binaryProtocol := thrift.NewTBinaryProtocolFactoryDefault()
socket, err := thrift.NewTSocket(net.JoinHostPort(host, thriftPort))
if err != nil {
return nil, err
}
bufferedTransport := thrift.NewTBufferedTransport(socket, BUFFER_SIZE)
client := elasticsearch.NewRestClientFactory(bufferedTransport, binaryProtocol)
if err := bufferedTransport.Open(); err != nil {
return nil, err
}
return client, nil
}
// ThriftClientFactory is an thrift Client factory which creates a connection
// that uses a thrift codec.
func ThriftClientFactory(addr string) func() (io.Closer, error) {
return func() (io.Closer, error) {
var transport thrift.TTransport
socketTransport, err := thrift.NewTSocketTimeout(addr, defaultTimeout)
if err != nil {
return nil, err
}
transport = thrift.NewTFramedTransport(
thrift.NewTBufferedTransport(socketTransport, defaultBufferSize))
protocol := thrift.NewTBinaryProtocolFactoryDefault()
if err := transport.Open(); err != nil {
return nil, err
}
client := NewHbaseClientFactory(transport, protocol)
return &clientCloser{
mu: &sync.Mutex{},
conn: socketTransport,
HbaseClient: client,
}, nil
}
}
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))
}
