func (self convertor) Convert2Params(entity *store.MessageEntity) []interface{} {
val := reflect.ValueOf(*entity)
fvs := make([]interface{}, 0, len(self.columns))
for _, v := range self.columns {
var fv interface{}
if v.columnName == "body" {
if entity.MsgType == protocol.CMD_STRING_MESSAGE {
fv = []byte(entity.GetBody().(string))
} else if entity.MsgType == protocol.CMD_BYTES_MESSAGE {
fv = entity.GetBody().([]byte)
} else {
log.ErrorLog("kite_store", "convertor|Convert2Params|UnSupport MESSAGE TYPE|%s\n", entity.MsgType)
}
} else {
f := val.FieldByName(v.fieldName)
// log.Debug("convertor|Convert2Params|%s|%s\n", v.fieldName, f)
switch f.Kind() {
case reflect.Ptr:
header, ok := f.Interface().(*protocol.Header)
if ok {
//头部用Pb序列化
data, err := protocol.MarshalPbMessage(header)
if err != nil {
log.ErrorLog("kite_store", "convertor|Convert2Params|Marshal|HEAD|FAIL|%s|%s\n", err, f.Addr().Interface())
return nil
}
fv = data
} else {
log.ErrorLog("kite_store", "convertor|Convert2Params|Not protocol.Header PRT |FAIL|%s\n", f.Addr())
return nil
}
case reflect.Slice, reflect.Array:
if f.Type().Elem().Kind() == reflect.String {
data, err := json.Marshal(f.Interface())
if nil != err {
log.ErrorLog("kite_store", "convertor|Convert2Params|Marshal|Slice|FAIL||%s\n", err)
return nil
}
fv = string(data)
} else {
fv = f.Interface()
}
default:
fv = f.Interface()
}
}
fvs = append(fvs, &fv)
}
return fvs
}
func (self *kiteClient) sendMessage(message *protocol.QMessage) error {
data, err := protocol.MarshalPbMessage(message.GetPbMessage())
if nil != err {
return err
}
timeout := 3 * time.Second
return self.innerSendMessage(message.GetMsgType(), data, timeout)
}
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
}