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 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())
}
}
}
//
// 确保Socket成功连接到后端服务器
//
func (bc *BackendConn) ensureConn() (transport thrift.TTransport, err error) {
// 1. 创建连接(只要IP没有问题， err一般就是空)
timeout := time.Second * 5
if strings.Contains(bc.addr, ":") {
transport, err = thrift.NewTSocketTimeout(bc.addr, timeout)
} else {
transport, err = NewTUnixDomainTimeout(bc.addr, timeout)
}
log.Printf(Cyan("[%s]Create Socket To: %s"), bc.service, bc.addr)
if err != nil {
log.ErrorErrorf(err, "[%s]Create Socket Failed: %v, Addr: %s", err, bc.service, bc.addr)
// 连接不上，失败
return nil, err
}
// 2. 只要服务存在，一般不会出现err
sleepInterval := 1
err = transport.Open()
for err != nil && !bc.IsMarkOffline.Get() {
log.ErrorErrorf(err, "[%s]Socket Open Failed: %v, Addr: %s", bc.service, err, bc.addr)
// Sleep: 1, 2, 4这几个间隔
time.Sleep(time.Duration(sleepInterval) * time.Second)
if sleepInterval < 4 {
sleepInterval *= 2
}
err = transport.Open()
}
return transport, err
}
func (self *FlumeClient) Connect() error {
var tsocket *thrift.TSocket
var err error
//创建一个物理连接
tsocket, err = thrift.NewTSocketTimeout(net.JoinHostPort(self.host, strconv.Itoa(self.port)), 10*time.Second)
if nil != err {
log.Printf("FLUME_CLIENT|CREATE TSOCKET|FAIL|%s|%s\n", self.HostPort(), err)
return err
}
self.tsocket = tsocket
transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
//TLV 方式传输
protocolFactory := thrift.NewTCompactProtocolFactory()
//使用非阻塞io来传输
self.transport = transportFactory.GetTransport(tsocket)
self.thriftclient = flume.NewThriftSourceProtocolClientFactory(self.transport, protocolFactory)
if err := self.transport.Open(); nil != err {
log.Printf("FLUME_CLIENT|CREATE THRIFT CLIENT|FAIL|%s|%s", self.HostPort(), err)
return err
}
self.status = STATUS_READY
go self.checkAlive()
return nil
}
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...")
}
func NewThriftRequestExec(tFac thrift.TTransportFactory, clientExec ThriftClientExecutor, timeout time.Duration, hosts ...string) bender.RequestExecutor {
return func(_ int64, request interface{}) (interface{}, error) {
addr := hosts[rand.Intn(len(hosts))]
socket, err := thrift.NewTSocketTimeout(addr, timeout)
if err != nil {
return nil, err
}
defer socket.Close()
transport := tFac.GetTransport(socket)
if err := transport.Open(); err != nil {
return nil, err
}
defer transport.Close()
return clientExec(request, transport)
}
}
func (self *connection) Connect() error {
log.Debug("Connecting to %v...", self.addr)
// Creating connection
var err error
self.transportFactory = thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
self.protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
self.socket, err = thrift.NewTSocketTimeout(self.addr, self.timeout)
if err != nil {
return fmt.Errorf("socket error: %v", err.Error())
}
self.transport = self.transportFactory.GetTransport(self.socket)
err = self.transport.Open()
if err != nil {
return fmt.Errorf("transport open error: %v", err.Error())
}
self.renderClient = gopnikrpc.NewRenderClientFactory(self.transport, self.protocolFactory)
return nil
}
func (c *Client) ensureConnected() error {
if c.ttransport != nil {
return nil
}
transport, err := thrift.NewTSocketTimeout(c.server, c.Timeout)
if err == nil {
err = transport.Open()
if err == nil {
c.ttransport = thrift.NewTFramedTransport(transport)
c.tclient = NewKestrelClientFactory(c.ttransport, thrift.NewTBinaryProtocolFactoryDefault())
return nil
} else {
return err
}
} else {
return err
}
}
func (self *RenderSelector) connect(addr string) (*thriftConn, error) {
var err error
conn := &thriftConn{
Addr: addr,
}
conn.Socket, err = thrift.NewTSocketTimeout(addr, self.timeout)
if err != nil {
return nil, err
}
conn.Transport = self.transportFactory.GetTransport(conn.Socket)
err = conn.Transport.Open()
if err != nil {
return nil, err
}
conn.Client = gopnikrpc.NewRenderClientFactory(conn.Transport, self.protocolFactory)
return conn, nil
}
func (self *FlumeClient) Connect() error {
var tsocket *thrift.TSocket
var err error
//创建一个物理连接
tsocket, err = thrift.NewTSocketTimeout(net.JoinHostPort(self.host, strconv.Itoa(self.port)), 10*time.Second)
if nil != err {
log.Printf("FLUME_CLIENT|CREATE TSOCKET|FAIL|%s|%s\n", self.HostPort(), err)
return err
}
self.tsocket = tsocket
self.transportFactory = thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
//TLV 方式传输
self.protocolFactory = thrift.NewTCompactProtocolFactory()
self.clientConn()
self.status = STATUS_READY
go self.checkAlive()
return 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))
}
func Init(hbaseAddr string, hbaseTimeout time.Duration, hbaseMaxIdle, hbaseMaxActive int) error {
// init hbase thrift pool
hbasePool = New(func() (c *HbaseConn, err error) {
var trans thrift.TTransport
trans, err = thrift.NewTSocketTimeout(hbaseAddr, hbaseTimeout)
if err != nil {
log.Error("thrift.NewTSocketTimeout error(%v)", err)
return
}
trans = thrift.NewTFramedTransport(trans)
c = new(HbaseConn)
c.conn = hbasethrift.NewTHBaseServiceClientFactory(trans, thrift.NewTBinaryProtocolFactoryDefault())
if err = trans.Open(); err != nil {
log.Error("trans.Open error(%v)", err)
return
}
c.tput.ColumnValues = []*hbasethrift.TColumnValue{
// vid
&hbasethrift.TColumnValue{
Family: familyBasic,
Qualifier: columnVid,
Value: c.vbuf[:],
},
// cookie
&hbasethrift.TColumnValue{
Family: familyBasic,
Qualifier: columnCookie,
Value: c.cbuf[:],
},
// insert_time
&hbasethrift.TColumnValue{
Family: familyBasic,
Qualifier: columnInsertTime,
Value: c.ibuf[:],
},
}
c.tdel.Columns = []*hbasethrift.TColumn{
// vid
&hbasethrift.TColumn{
Family: familyBasic,
Qualifier: columnVid,
},
// cookie
&hbasethrift.TColumn{
Family: familyBasic,
Qualifier: columnCookie,
},
// insert_time
&hbasethrift.TColumn{
Family: familyBasic,
Qualifier: columnInsertTime,
},
}
return
}, func(c *HbaseConn) error {
client := c.conn
if client != nil && client.Transport != nil {
client.Transport.Close()
}
return nil
}, hbaseMaxIdle)
hbasePool.MaxActive = hbaseMaxActive
hbasePool.IdleTimeout = lvsTimeout
return nil
}