Beispiel #1
0
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
}
Beispiel #2
0
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()
}
Beispiel #3
0
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,
	}
}
Beispiel #5
0
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
}
Beispiel #6
0
// 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
	}
}
Beispiel #7
0
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))
}
Beispiel #8
0
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))
}