示例#1
0
文件: main.go 项目: lei-yu/GOPATH
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
}
示例#2
0
func Benchmark_CallEchoService(b *testing.B) {
	socket, err := thrift.NewTSocketTimeout(net.JoinHostPort("127.0.0.1", "8080"), TIMEOUT)
	if err != nil {
		t.Fatal("Unable to new client socket", err)
	}

	transport := thrift.NewTFramedTransport(socket)
	var protocol thrift.TProtocol = thrift.NewTBinaryProtocolTransport(transport)
	protocol = thrift.NewTMultiplexedProtocol(protocol, "EchoService")
	client := rpc.NewEchoServiceClientProtocol(transport, protocol, protocol)

	err = transport.Open()
	if err != nil {
		t.Fatal("Unable to open client socket", err)
	}
	defer transport.Close()

	for i := 0; i < b.N; i++ { //use b.N for looping
		_, err2 := client.Echo(currentTimeMillis(), "hello world")
		if err2 != nil {
			exception := thrift.NewTTransportExceptionFromError(err2)
			t.Fatal("test TestCallEchoService failed", exception.TypeId(), exception.Err())
		}
	}
}
示例#3
0
文件: main.go 项目: lei-yu/GOPATH
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...")

}
示例#4
0
文件: main.go 项目: lei-yu/GOPATH
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))
}
示例#5
0
文件: main.go 项目: lei-yu/GOPATH
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))
}