func (self *RemotingServer) serve(l *StoppedListener) error {
for !self.isShutdown {
conn, err := l.Accept()
if nil != err {
log.Error("RemotingServer|serve|AcceptTCP|FAIL|%s\n", err)
continue
} else {
// log.Debug("RemotingServer|serve|AcceptTCP|SUCC|%s\n", conn.RemoteAddr())
//创建remotingClient对象
remoteClient := client.NewRemotingClient(conn, self.packetDispatcher, self.rc)
remoteClient.Start()
}
}
return nil
}
func init() {
rc := turbo.NewRemotingConfig(
"turbo-server:localhost:28888",
1000, 16*1024,
16*1024, 10000, 10000,
10*time.Second, 160000)
remoteServer = NewRemotionServer("localhost:28888", rc, packetDispatcher)
remoteServer.ListenAndServer()
conn, _ := dial("localhost:28888")
// //重连管理器
reconnManager := client.NewReconnectManager(false, -1, -1, handshake)
clientManager = client.NewClientManager(reconnManager)
rcc := turbo.NewRemotingConfig(
"turbo-client:localhost:28888",
1000, 16*1024,
16*1024, 10000, 10000,
10*time.Second, 160000)
remoteClient := client.NewRemotingClient(conn, clientPacketDispatcher, rcc)
remoteClient.Start()
auth := &client.GroupAuth{}
auth.GroupId = "a"
auth.SecretKey = "123"
clientManager.Auth(auth, remoteClient)
go func() {
for {
log.Println(clientf.Monitor())
time.Sleep(1 * time.Second)
}
}()
}
//当触发QServer地址发生变更
func (self *KiteClientManager) onQServerChanged(topic string, hosts []string) {
//重建一下topic下的kiteclient
clients := make([]*kiteClient, 0, 10)
for _, host := range hosts {
//如果能查到remoteClient 则直接复用
remoteClient := self.clientManager.FindRemoteClient(host)
if nil == remoteClient {
//这里就新建一个remote客户端连接
conn, err := dial(host)
if nil != err {
log.ErrorLog("kite_client", "KiteClientManager|onQServerChanged|Create REMOTE CLIENT|FAIL|%s|%s\n", err, host)
continue
}
remoteClient = c.NewRemotingClient(conn,
func(rc *c.RemotingClient, p *packet.Packet) {
event := pipe.NewPacketEvent(rc, p)
err := self.pipeline.FireWork(event)
if nil != err {
log.ErrorLog("kite_client", "KiteClientManager|onPacketRecieve|FAIL|%s|%t\n", err, p)
}
}, self.rc)
remoteClient.Start()
auth, err := handshake(self.ga, remoteClient)
if !auth || nil != err {
remoteClient.Shutdown()
log.ErrorLog("kite_client", "KiteClientManager|onQServerChanged|HANDSHAKE|FAIL|%s|%s\n", err, auth)
continue
}
self.clientManager.Auth(self.ga, remoteClient)
}
//创建kiteClient
kiteClient := newKitClient(remoteClient)
clients = append(clients, kiteClient)
}
log.InfoLog("kite_client", "KiteClientManager|onQServerChanged|SUCC|%s|%s\n", topic, hosts)
self.lock.Lock()
defer self.lock.Unlock()
//替换掉线的server
old, ok := self.kiteClients[topic]
self.kiteClients[topic] = clients
if ok {
del := make([]string, 0, 2)
outter:
for _, o := range old {
for _, c := range clients {
if c.remotec.RemoteAddr() == o.remotec.RemoteAddr() {
continue outter
}
}
del = append(del, o.remotec.RemoteAddr())
}
if len(del) > 0 {
self.clientManager.DeleteClients(del...)
}
}
}
func main() {
go func() {
http.ListenAndServe(":13801", nil)
}()
// 重连管理器
reconnManager := client.NewReconnectManager(false, -1, -1, handshake)
clientManager := client.NewClientManager(reconnManager)
rcc := turbo.NewRemotingConfig(
"turbo-client:localhost:28888",
1000, 16*1024,
16*1024, 20000, 20000,
10*time.Second, 160000)
go func() {
for {
log.Println(rcc.FlowStat.Stat())
time.Sleep(1 * time.Second)
}
}()
//创建物理连接
conn, _ := func(hostport string) (*net.TCPConn, error) {
//连接
remoteAddr, err_r := net.ResolveTCPAddr("tcp4", hostport)
if nil != err_r {
log.Printf("KiteClientManager|RECONNECT|RESOLVE ADDR |FAIL|remote:%s\n", err_r)
return nil, err_r
}
conn, err := net.DialTCP("tcp4", nil, remoteAddr)
if nil != err {
log.Printf("KiteClientManager|RECONNECT|%s|FAIL|%s\n", hostport, err)
return nil, err
}
return conn, nil
}("localhost:28888")
remoteClient := client.NewRemotingClient(conn, clientPacketDispatcher, rcc)
remoteClient.Start()
auth := &client.GroupAuth{}
auth.GroupId = "a"
auth.SecretKey = "123"
clientManager.Auth(auth, remoteClient)
//echo command
p := packet.NewPacket(1, []byte("echo"))
//find a client
tmp := clientManager.FindRemoteClients([]string{"a"}, func(groupid string, c *client.RemotingClient) bool {
return false
})
for i := 0; i < 1; i++ {
go func() {
for {
//write command and wait for response
_, err := tmp["a"][0].WriteAndGet(*p, 100*time.Millisecond)
if nil != err {
log.Printf("WAIT RESPONSE FAIL|%s\n", err)
break
} else {
// log.Printf("WAIT RESPONSE SUCC|%s\n", string(resp.([]byte)))
}
}
}()
}
select {}
}