//内部处理
func (self *DeliverPreHandler) send0(ctx *DefaultPipelineContext, pevent *deliverPreEvent) {
//如果没有entity则直接查询一下db
entity := pevent.entity
if nil == entity {
//查询消息
entity = self.kitestore.Query(pevent.messageId)
if nil == entity {
self.kitestore.Expired(pevent.messageId)
// log.Error("DeliverPreHandler|send0|Query|FAIL|%s\n", pevent.messageId)
return
}
}
//check entity need to deliver
if !self.checkValid(entity) {
self.kitestore.Expired(entity.MessageId)
return
}
//统计数据
//对该消息类型进行统计
flow, ok := self.flowstat.TopicsFlows[pevent.header.GetTopic()]
if ok {
flow.Incr(1)
}
// log.Debug("DeliverPreHandler|send0|Query|%s", entity.Header)
data := protocol.MarshalMessage(entity.Header, entity.MsgType, entity.GetBody())
//构造deliverEvent
deliverEvent := newDeliverEvent(pevent.messageId, pevent.header.GetTopic(),
pevent.header.GetMessageType(), entity.PublishTime, pevent.attemptDeliver)
//创建不同的packet
switch entity.MsgType {
case protocol.CMD_BYTES_MESSAGE:
deliverEvent.packet = packet.NewPacket(protocol.CMD_BYTES_MESSAGE, data)
case protocol.CMD_STRING_MESSAGE:
deliverEvent.packet = packet.NewPacket(protocol.CMD_STRING_MESSAGE, data)
}
//填充订阅分组
self.fillGroupIds(deliverEvent, entity)
self.fillDeliverExt(deliverEvent, entity)
//向后投递发送
ctx.SendForward(deliverEvent)
}
func (self *ValidateHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
aevent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
remoteClient := aevent.getClient()
//做权限校验.............
isAuth := self.clientManager.Validate(remoteClient)
// log.DebugLog("kite_handler", "ValidateHandler|CONNETION|%s|%s\n", remoteClient.RemoteAddr(), isAuth)
if isAuth {
ctx.SendForward(event)
} else {
log.Warn("ValidateHandler|UnAuth CONNETION|%s\n", remoteClient.RemoteAddr())
cmd := protocol.MarshalConnAuthAck(false, "未授权的访问,连接关闭!")
//响应包
p := packet.NewPacket(protocol.CMD_CONN_AUTH, cmd)
//直接写出去授权失败
remoteClient.Write(*p)
//断开连接
remoteClient.Shutdown()
}
return nil
}
//握手包
func handshake(ga *c.GroupAuth, remoteClient *c.RemotingClient) (bool, error) {
for i := 0; i < 3; i++ {
p := protocol.MarshalConnMeta(ga.GroupId, ga.SecretKey)
rpacket := packet.NewPacket(protocol.CMD_CONN_META, p)
resp, err := remoteClient.WriteAndGet(*rpacket, 5*time.Second)
if nil != err {
//两秒后重试
time.Sleep(2 * time.Second)
log.Warn("kiteClient|handShake|FAIL|%s|%s\n", ga.GroupId, err)
} else {
authAck, ok := resp.(*protocol.ConnAuthAck)
if !ok {
return false, errors.New("Unmatches Handshake Ack Type! ")
} else {
if authAck.GetStatus() {
log.Info("kiteClient|handShake|SUCC|%s|%s\n", ga.GroupId, authAck.GetFeedback())
return true, nil
} else {
log.Warn("kiteClient|handShake|FAIL|%s|%s\n", ga.GroupId, authAck.GetFeedback())
return false, errors.New("Auth FAIL![" + authAck.GetFeedback() + "]")
}
}
}
}
return false, errors.New("handshake fail! [" + remoteClient.RemoteAddr() + "]")
}
func BenchmarkRemoteClient(t *testing.B) {
t.SetParallelism(4)
t.RunParallel(func(pb *testing.PB) {
for pb.Next() {
for i := 0; i < t.N; i++ {
p := packet.NewPacket(1, []byte("echo"))
tmp := clientManager.FindRemoteClients([]string{"a"}, func(groupid string, c *client.RemotingClient) bool {
return false
})
_, err := tmp["a"][0].WriteAndGet(*p, 500*time.Millisecond)
clientf.WriteFlow.Incr(1)
if nil != err {
t.Fail()
log.Printf("WAIT RESPONSE FAIL|%s\n", err)
} else {
// log.Printf("WAIT RESPONSE SUCC|%s\n", string(resp.([]byte)))
}
}
}
})
}
//发送事务ack信息
func (self *RecoverManager) txAck(entity *store.MessageEntity) {
txack := protocol.MarshalTxACKPacket(entity.Header, protocol.TX_UNKNOWN, "Server Check")
p := packet.NewPacket(protocol.CMD_TX_ACK, txack)
//向头部的发送分组发送txack消息
groupId := entity.PublishGroup
event := NewRemotingEvent(p, nil, groupId)
self.pipeline.FireWork(event)
}
func (self *HeartbeatHandler) keepAlive() {
for {
select {
case <-time.After(self.heartbeatPeriod):
//心跳检测
func() {
id := time.Now().Unix()
clients := self.clientMangager.ClientsClone()
p := protocol.MarshalHeartbeatPacket(id)
for h, c := range clients {
i := 0
//关闭的时候发起重连
if c.IsClosed() {
i = 3
} else {
//如果是空闲的则发起心跳
if c.Idle() {
for ; i < 3; i++ {
hp := packet.NewPacket(protocol.CMD_HEARTBEAT, p)
err := c.Ping(hp, time.Duration(self.heartbeatTimeout))
//如果有错误则需要记录
if nil != err {
log.Warn("HeartbeatHandler|KeepAlive|FAIL|%s|local:%s|remote:%s|%d\n", err, c.LocalAddr(), h, id)
continue
} else {
log.Info("HeartbeatHandler|KeepAlive|SUCC|local:%s|remote:%s|%d|%d ...\n", c.LocalAddr(), h, id, i)
break
}
}
}
}
if i >= 3 {
//说明连接有问题需要重连
c.Shutdown()
self.clientMangager.SubmitReconnect(c)
log.Warn("HeartbeatHandler|SubmitReconnect|%s\n", c.RemoteAddr())
}
}
}()
}
}
}
func (self *kiteClient) innerSendMessage(cmdType uint8, p []byte, timeout time.Duration) error {
msgpacket := packet.NewPacket(cmdType, p)
//如果是需要等待结果的则等待
if timeout <= 0 {
_, err := self.remotec.Write(*msgpacket)
return err
} else {
resp, err := self.remotec.WriteAndGet(*msgpacket, timeout)
if nil != err {
return err
} else {
storeAck, ok := resp.(*protocol.MessageStoreAck)
if !ok || !storeAck.GetStatus() {
return errors.New(fmt.Sprintf("kiteClient|SendMessage|FAIL|%s\n", resp))
} else {
//log.DebugLog("kite_client","kiteClient|SendMessage|SUCC|%s|%s\n", storeAck.GetMessageId(), storeAck.GetFeedback())
return nil
}
}
}
}
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 {}
}
