func (self *AcceptHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
// log.Printf("AcceptHandler|Process|%s|%t\n", self.GetName(), event)
acceptEvent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
switch acceptEvent.msgType {
case protocol.CMD_TX_ACK:
//回调事务完成的监听器
// log.Printf("AcceptHandler|Check Message|%t\n", acceptEvent.Msg)
txPacket := acceptEvent.msg.(*protocol.TxACKPacket)
header := txPacket.GetHeader()
tx := protocol.NewTxResponse(header)
err := self.listener.OnMessageCheck(tx)
if nil != err {
tx.Unknown(err.Error())
}
//发起一个向后的处理时间发送出去
//填充条件
tx.ConvertTxAckPacket(txPacket)
txData, _ := protocol.MarshalPbMessage(txPacket)
txResp := packet.NewRespPacket(acceptEvent.opaque, acceptEvent.msgType, txData)
//发送提交结果确认的Packet
remotingEvent := NewRemotingEvent(txResp, []string{acceptEvent.remoteClient.RemoteAddr()})
ctx.SendForward(remotingEvent)
// log.Printf("AcceptHandler|Recieve TXMessage|%t\n", acceptEvent.Msg)
case protocol.CMD_STRING_MESSAGE, protocol.CMD_BYTES_MESSAGE:
//这里应该回调消息监听器然后发送处理结果
// log.Printf("AcceptHandler|Recieve Message|%t\n", acceptEvent.Msg)
message := protocol.NewQMessage(acceptEvent.msg)
succ := self.listener.OnMessage(message)
dpacket := protocol.MarshalDeliverAckPacket(message.GetHeader(), succ)
respPacket := packet.NewRespPacket(acceptEvent.opaque, protocol.CMD_DELIVER_ACK, dpacket)
remotingEvent := NewRemotingEvent(respPacket, []string{acceptEvent.remoteClient.RemoteAddr()})
ctx.SendForward(remotingEvent)
default:
return INVALID_MSG_TYPE_ERROR
}
return nil
}
func (self *AccessHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
// log.Debug("accessEvent|Process|%s|%t\n", self.GetName(), event)
aevent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
//做权限校验.............
if false {
log.Warn("accessEvent|Process|INVALID AUTH|%s|%s\n", aevent.groupId, aevent.secretKey)
}
// 权限验证通过 保存到clientmanager
self.clientManager.Auth(client.NewGroupAuth(aevent.groupId, aevent.secretKey), aevent.remoteClient)
// log.Info("accessEvent|Process|NEW CONNECTION|AUTH SUCC|%s|%s|%s\n", aevent.groupId, aevent.secretKey, aevent.remoteClient.RemoteAddr())
cmd := protocol.MarshalConnAuthAck(true, "授权成功")
//响应包
packet := packet.NewRespPacket(aevent.opaque, protocol.CMD_CONN_AUTH, cmd)
//向当前连接写入当前包
remoteEvent := NewRemotingEvent(packet, []string{aevent.remoteClient.RemoteAddr()})
//向后走网络传输
ctx.SendForward(remoteEvent)
return nil
}
func packetDispatcher(rclient *client.RemotingClient, p *packet.Packet) {
resp := packet.NewRespPacket(p.Header.Opaque, p.Header.CmdType, p.Data)
//直接回写回去
rclient.Write(*resp)
// log.Printf("packetDispatcher|WriteResponse|%s\n", string(resp.Data))
}
func packetDispatcher(rclient *client.RemotingClient, p *packet.Packet) {
flow.ReadFlow.Incr(1)
flow.DispatcherFlow.Incr(1)
resp := packet.NewRespPacket(p.Opaque, p.CmdType, p.Data)
//直接回写回去
rclient.Write(*resp)
flow.WriteFlow.Incr(1)
}
func (self *HeartbeatHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
hevent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
//处理本地的pong
hevent.RemoteClient.Pong(hevent.Opaque, hevent.Version)
//发起一个ping对应的响应
packet := packet.NewRespPacket(hevent.Opaque, protocol.CMD_HEARTBEAT, protocol.MarshalHeartbeatPacket(hevent.Version))
//发起一个网络请求
remoteEvent := NewRemotingEvent(packet, []string{hevent.RemoteClient.RemoteAddr()})
// log.InfoLog("kite_handler", "HeartbeatHandler|%s|Process|Recieve|Ping|%s|%d\n", self.GetName(), hevent.RemoteClient.RemoteAddr(), hevent.Version)
ctx.SendForward(remoteEvent)
return nil
}
func storeAck(opaque int32, messageid string, succ bool, feedback string) *packet.Packet {
storeAck := protocol.MarshalMessageStoreAck(messageid, succ, feedback)
//响应包
return packet.NewRespPacket(opaque, protocol.CMD_MESSAGE_STORE_ACK, storeAck)
}
