func TestTxBytesMessage(t *testing.T) {
bm := buildBytesMessage(false)
// 发送数据
err := manager.SendTxMessage(protocol.NewQMessage(bm),
func(message *protocol.QMessage) (bool, error) {
return true, nil
})
if nil != err {
log.Println("SEND TxBytesMESSAGE |FAIL|", err)
} else {
log.Println("SEND TxBytesMESSAGE |SUCCESS")
}
select {
case mid := <-rc:
if mid != bm.GetHeader().GetMessageId() {
t.Fail()
}
log.Println("RECIEVE TxBytesMESSAGE |SUCCESS")
case txid := <-txc:
if txid != bm.GetHeader().GetMessageId() {
t.Fail()
log.Println("SEND TxBytesMESSAGE |RECIEVE TXACK SUCC")
}
case <-time.After(10 * time.Second):
log.Println("WAIT TxBytesMESSAGE |TIMEOUT")
t.Fail()
}
}
func (self *MockKiteStore) PageQueryEntity(hashKey string, kiteServer string, nextDeliveryTime int64, startIdx, limit int) (bool, []*MessageEntity) {
recoverMessage := buildStringMessage(MessageId())
entity := NewMessageEntity(protocol.NewQMessage(recoverMessage))
entity.DeliverCount = 10
entity.SuccGroups = []string{"a", "b"}
entity.FailGroups = []string{"c", "d"}
return false, []*MessageEntity{entity}
}
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 TestFileStoreUpdate(t *testing.T) {
cleanSnapshot("./snapshot/")
fs := NewKiteFileStore(".", 5000000, 1*time.Second)
fs.Start()
for i := 0; i < 100; i++ {
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String(fmt.Sprintf("%x", i) + "26c03f00665862591f696a980b5ac"),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(true),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
// log.Printf("------------%s", entity.Header)
succ := fs.Save(entity)
if !succ {
t.Fail()
}
}
//commit and check
for i := 0; i < 100; i++ {
id := fmt.Sprintf("%x", i) + "26c03f00665862591f696a980b5ac"
//创建消息
msg := &store.MessageEntity{
MessageId: id,
DeliverCount: 1,
SuccGroups: []string{},
FailGroups: []string{"s-mts-test"}}
succ := fs.UpdateEntity(msg)
if !succ {
t.Fail()
}
//check entity
entity := fs.Query(id)
// log.Printf("++++++++++++++|%s|%s", entity.Header, string(entity.GetBody().([]byte)))
if nil == entity {
t.Fail()
} else if !entity.Commit && entity.DeliverCount != 1 &&
entity.FailGroups[0] != "s-mts-test" {
t.Fail()
// log.Println(entity)
}
}
fs.Stop()
// cleanSnapshot("./snapshot/")
}
func TestConvert2Entity(t *testing.T) {
options := MysqlOptions{
Addr: "localhost:3306",
Username: "******",
Password: "",
ShardNum: 4,
BatchUpSize: 1000,
BatchDelSize: 1000,
FlushPeriod: 1 * time.Minute,
MaxIdleConn: 2,
MaxOpenConn: 4}
hs := newDbShard(options)
c := convertor{}
sqlwrapper := newSqlwrapper("kite_msg", hs, store.MessageEntity{})
sqlwrapper.initSQL()
c.columns = sqlwrapper.columns
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String("26c03f00665462591f696a980b5a6c4"),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(false),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
entity.SuccGroups = []string{"go-kite-test"}
hn, _ := os.Hostname()
entity.KiteServer = hn
params := c.Convert2Params(entity)
t.Logf("TestConvert2Entity|Convert2Params|%s\n", params)
econ := &store.MessageEntity{}
c.Convert2Entity(params, econ, func(colname string) bool {
return false
})
t.Logf("TestConvert2Entity|Convert2Entity|%s\n", econ)
if econ.MessageId != entity.MessageId {
t.Fail()
}
if econ.ExpiredTime != entity.ExpiredTime {
t.Fail()
}
}
func (self *KiteFileStore) Query(messageId string) *MessageEntity {
lock, _, el := self.hash(messageId)
lock.RLock()
defer lock.RUnlock()
e, ok := el[messageId]
if !ok {
return nil
}
v := e.Value.(*opBody)
//wait save done
self.waitSaveDone(v)
data, err := self.snapshot.Query(v.Id)
if nil != err {
// log.Error("KiteFileStore|Query|Entity|FAIL|%s|%d", err, v.Id)
return nil
}
var msg interface{}
msgType := data[0]
switch msgType {
case protocol.CMD_BYTES_MESSAGE:
var bms protocol.BytesMessage
err = protocol.UnmarshalPbMessage(data[1:], &bms)
msg = &bms
case protocol.CMD_STRING_MESSAGE:
var sms protocol.StringMessage
err = protocol.UnmarshalPbMessage(data[1:], &sms)
msg = &sms
default:
log.ErrorLog("kite_store", "KiteFileStore|Query|INVALID|MSGTYPE|%d", msgType)
return nil
}
if nil != err {
log.ErrorLog("kite_store", "KiteFileStore|Query|UnmarshalPbMessage|Entity|FAIL|%s", err)
return nil
} else {
entity := NewMessageEntity(protocol.NewQMessage(msg))
//merge data
entity.Commit = v.Commit
entity.FailGroups = v.FailGroups
entity.SuccGroups = v.SuccGroups
entity.NextDeliverTime = v.NextDeliverTime
entity.DeliverCount = v.DeliverCount
return entity
}
}
func (self *AcceptHandler) Process(ctx *pipe.DefaultPipelineContext, event pipe.IEvent) error {
// log.Debug("AcceptHandler|Process|%s|%t\n", self.GetName(), event)
ae, ok := self.cast(event)
if !ok {
return pipe.ERROR_INVALID_EVENT_TYPE
}
//这里处理一下ae,做一下校验
var msg *store.MessageEntity
switch ae.msgType {
case protocol.CMD_DELIVER_ACK:
//收到投递结果直接attach响应
// log.DebugLog("kite_handler", "AcceptHandler|DELIVER_ACK|%s|%t", ae.opaque, ae.msg)
ae.remoteClient.Attach(ae.opaque, ae.msg)
return nil
case protocol.CMD_HEARTBEAT:
hb := ae.msg.(*protocol.HeartBeat)
event = pipe.NewHeartbeatEvent(ae.remoteClient, ae.opaque, hb.GetVersion())
ctx.SendForward(event)
return nil
case protocol.CMD_BYTES_MESSAGE:
msg = store.NewMessageEntity(protocol.NewQMessage(ae.msg.(*protocol.BytesMessage)))
case protocol.CMD_STRING_MESSAGE:
msg = store.NewMessageEntity(protocol.NewQMessage(ae.msg.(*protocol.StringMessage)))
default:
//这只是一个bug不支持的数据类型能给你
log.WarnLog("kite_handler", "AcceptHandler|Process|%s|%t", INVALID_MSG_TYPE_ERROR, ae.msg)
}
if nil != msg {
msg.PublishTime = time.Now().Unix()
msg.KiteServer = self.kiteserver
deliver := newPersistentEvent(msg, ae.remoteClient, ae.opaque)
ctx.SendForward(deliver)
return nil
}
return INVALID_MSG_TYPE_ERROR
}
func TestFileStoreDelete(t *testing.T) {
cleanSnapshot("./snapshot/")
fs := NewKiteFileStore(".", 5000000, 1*time.Second)
fs.Start()
for i := 0; i < 100; i++ {
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String(fmt.Sprintf("%x", i) + "26c03f00665862591f696a980b5ac"),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(true),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
succ := fs.Save(entity)
if !succ {
t.Fail()
}
}
//commit and check
for i := 0; i < 100; i++ {
id := fmt.Sprintf("%x", i) + "26c03f00665862591f696a980b5ac"
//delete
fs.Delete(id)
//check entity
entity := fs.Query(id)
if nil != entity {
t.Fail()
}
}
fs.Stop()
cleanSnapshot("./snapshot/")
}
func TestRecoverManager(t *testing.T) {
pipeline := NewDefaultPipeline()
kitedb := memory.NewKiteMemoryStore(100, 100)
messageid := store.MessageId()
t.Logf("messageid:%s\b", messageid)
entity := store.NewMessageEntity(protocol.NewQMessage(buildStringMessage(messageid)))
kitedb.Save(entity)
go func() {
for {
log.Println(kitedb.Monitor())
time.Sleep(1 * time.Second)
}
}()
fs := stat.NewFlowStat("recover")
fs.Start()
ch := make(chan bool, 1)
// 临时在这里创建的BindExchanger
exchanger := binding.NewBindExchanger("localhost:2181", "127.0.0.1:13800")
pipeline.RegisteHandler("deliverpre", handler.NewDeliverPreHandler("deliverpre", kitedb, exchanger, fs, 100))
pipeline.RegisteHandler("deliver", newmockDeliverHandler("deliver", ch))
hostname, _ := os.Hostname()
rm := NewRecoverManager(hostname, 16*time.Second, pipeline, kitedb)
rm.Start()
select {
case succ := <-ch:
log.Printf("--------------recover %s\n", succ)
case <-time.After(5 * time.Second):
t.Fail()
log.Println("waite recover deliver timeout\n")
}
}
func TestBytesMessage(t *testing.T) {
bm := buildBytesMessage(true)
// 发送数据
err := manager.SendMessage(protocol.NewQMessage(bm))
if nil != err {
log.Println("SEND BytesMESSAGE |FAIL|", err)
} else {
log.Println("SEND BytesMESSAGE |SUCCESS")
}
select {
case mid := <-rc:
if mid != bm.GetHeader().GetMessageId() {
t.Fail()
}
log.Println("RECIEVE BytesMESSAGE |SUCCESS")
case <-time.After(10 * time.Second):
log.Println("WAIT BytesMESSAGE |TIMEOUT|", err)
t.Fail()
}
}
func (self *KiteQClient) SendTxBytesMessage(msg *protocol.BytesMessage, transcation core.DoTranscation) error {
message := protocol.NewQMessage(msg)
return self.kclientManager.SendTxMessage(message, transcation)
}
func innerT(kiteMysql *KiteMysqlStore, msg interface{}, msgid string, t *testing.T) {
qm := protocol.NewQMessage(msg)
entity := store.NewMessageEntity(qm)
entity.SuccGroups = []string{"go-kite-test"}
hn := "localhost"
entity.KiteServer = hn
entity.PublishTime = time.Now().Unix()
succ := kiteMysql.Save(entity)
if !succ {
t.Fail()
} else {
t.Logf("SAVE|SUCC|%s\n", entity)
}
ret := kiteMysql.Query(msgid)
t.Logf("Query|%s|%s\n", msgid, ret)
if nil == ret {
t.Fail()
return
}
bb, ok := qm.GetBody().([]byte)
if ok {
rb, _ := ret.GetBody().([]byte)
if string(rb) != string(bb) {
t.Fail()
} else {
t.Logf("Query|SUCC|%s\n", ret)
}
} else {
bs, _ := qm.GetBody().(string)
rs, _ := ret.GetBody().(string)
if bs != rs {
t.Fail()
} else {
t.Logf("Query|SUCC|%s\n", ret)
}
}
t.Logf("Commint BEGIN")
commit := kiteMysql.Commit(msgid)
if !commit {
t.Logf("Commint FAIL")
t.Fail()
}
t.Logf("Commint END")
time.Sleep(200 * time.Millisecond)
ret = kiteMysql.Query(msgid)
t.Logf("PageQueryEntity|COMMIT RESULT|%s\n", ret)
if !ret.Commit {
t.Logf("Commit|FAIL|%s\n", ret)
t.Fail()
}
hasNext, entities := kiteMysql.PageQueryEntity(msgid, hn, time.Now().Unix(), 0, 10)
t.Logf("PageQueryEntity|%s\n", entities)
if hasNext {
t.Logf("PageQueryEntity|FAIL|HasNext|%s\n", entities)
t.Fail()
} else {
if len(entities) != 1 {
t.Logf("PageQueryEntity|FAIL|%s\n", entities)
t.Fail()
} else {
if entities[0].Header.GetMessageId() != qm.GetHeader().GetMessageId() {
t.Fail()
}
}
}
}
//增加迁移
func TestExpiredDLQ(t *testing.T) {
options := MysqlOptions{
Addr: "localhost:3306",
DB: "kite",
Username: "******",
Password: "",
ShardNum: 4,
BatchUpSize: 100,
BatchDelSize: 100,
FlushPeriod: 10 * time.Millisecond,
MaxIdleConn: 10,
MaxOpenConn: 10}
kiteMysql := NewKiteMysql(options, "localhost")
truncate(kiteMysql)
messageIds := make([]string, 0, 10)
for i := 0; i < 256; i++ {
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String("26c03f00665862591f696a980b5a6" + fmt.Sprintf("%x", i)),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Second).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(false),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
qm := protocol.NewQMessage(msg)
entity := store.NewMessageEntity(qm)
entity.SuccGroups = []string{"go-kite-test"}
hn := "localhost"
entity.KiteServer = hn
entity.PublishTime = time.Now().Unix()
entity.DeliverCount = 101
succ := kiteMysql.Save(entity)
if !succ {
t.Fail()
} else {
// fmt.Printf("SAVE|SUCC|%s\n", entity)
}
messageIds = append(messageIds, msg.GetHeader().GetMessageId())
}
//开始清理
kiteMysql.MoveExpired()
for _, messageId := range messageIds {
entity := kiteMysql.Query(messageId)
if nil != entity {
t.Fail()
fmt.Println("MoveExpired|FAIL|" + messageId)
}
}
total := 0
for i := 0; i < 4; i++ {
db := kiteMysql.dbshard.FindSlave(fmt.Sprintf("%x", i))
rows, _ := db.Query("select count(*) from kite_msg_dlq")
if rows.Next() {
var count int
rows.Scan(&count)
t.Logf("TestExpiredDLQ|COUNT|%s|%d\n", fmt.Sprintf("%x", i), total)
total += count
}
}
if total != 256 {
t.Fail()
t.Logf("TestExpiredDLQ|TOTAL NOT EQUAL|%d\n", total)
}
truncate(kiteMysql)
kiteMysql.Stop()
}
func TestPageQuery(t *testing.T) {
options := MysqlOptions{
Addr: "localhost:3306",
DB: "kite",
Username: "******",
Password: "",
ShardNum: 4,
BatchUpSize: 100,
BatchDelSize: 100,
FlushPeriod: 10 * time.Millisecond,
MaxIdleConn: 10,
MaxOpenConn: 10}
kiteMysql := NewKiteMysql(options, "localhost")
truncate(kiteMysql)
hn := "localhost"
for i := 0; i < 10; i++ {
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String(fmt.Sprintf("%x", i) + "26c03f00665862591f696a980b5ac"),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(false),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
entity.KiteServer = hn
entity.PublishTime = time.Now().Unix()
kiteMysql.Save(entity)
}
startIdx := 0
hasMore := true
count := 0
//开始分页查询未过期的消息实体
for hasMore {
more, entities := kiteMysql.PageQueryEntity("c", hn,
time.Now().Unix(), 0, 1)
if len(entities) <= 0 {
break
}
//开始发起重投
for _, entity := range entities {
count++
t.Logf("TestPageQuery|PageQueryEntity|%s\n", entity.MessageId)
msg := &store.MessageEntity{
MessageId: entity.MessageId,
DeliverCount: 1,
SuccGroups: []string{},
FailGroups: []string{"s-mts-test"},
//设置一下下一次投递时间
NextDeliverTime: time.Now().Add(1 * time.Minute).Unix()}
kiteMysql.AsyncUpdate(msg)
}
time.Sleep(1 * time.Second)
hasMore = more
startIdx += len(entities)
}
if count != 10 {
t.Fail()
t.Logf("TestPageQuery|IDX|FAIL|%d\n", count)
return
}
startIdx = 0
hasMore = true
//开始分页查询未过期的消息实体
for hasMore {
more, entities := kiteMysql.PageQueryEntity("6c", hn,
time.Now().Add(8*time.Minute).Unix(), startIdx, 1)
if len(entities) <= 0 {
t.Logf("TestPageQuery|CHECK|NO DATA|%s\n", entities)
break
}
//开始发起重投
for _, entity := range entities {
if entity.DeliverCount != 1 || entity.FailGroups[0] != "s-mts-test" {
t.Fail()
}
t.Logf("TestPageQuery|PageQueryEntity|CHECK|%s\n", entity.MessageId)
}
startIdx += len(entities)
hasMore = more
}
t.Logf("TestPageQuery|CHECK|%d\n", startIdx)
if startIdx != 10 {
t.Fail()
}
truncate(kiteMysql)
}
func TestBatch(t *testing.T) {
options := MysqlOptions{
Addr: "localhost:3306",
DB: "kite",
Username: "******",
Password: "",
ShardNum: 4,
BatchUpSize: 100,
BatchDelSize: 100,
FlushPeriod: 10 * time.Millisecond,
MaxIdleConn: 10,
MaxOpenConn: 10}
kiteMysql := NewKiteMysql(options, "localhost")
truncate(kiteMysql)
mids := make([]string, 0, 16)
for i := 0; i < 16; i++ {
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String("26c03f00665862591f696a980b5a6" + fmt.Sprintf("%x", i)),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(false),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
entity.SuccGroups = []string{"go-kite-test"}
hn := "localhost"
entity.KiteServer = hn
entity.PublishTime = time.Now().Unix()
kiteMysql.Save(entity)
mids = append(mids, entity.MessageId)
}
for _, v := range mids {
msg := &store.MessageEntity{
MessageId: v,
DeliverCount: 1,
SuccGroups: []string{"s-mts-test"},
FailGroups: []string{},
//设置一下下一次投递时间
NextDeliverTime: time.Now().Unix()}
kiteMysql.AsyncUpdate(msg)
}
time.Sleep(5 * time.Second)
for _, v := range mids {
e := kiteMysql.Query(v)
if nil == e || len(e.SuccGroups) < 1 {
t.Fatalf("TestBatch|Update FAIL|%s|%s\n", e, v)
t.Fail()
return
}
t.Logf("Query|%s\n", e)
}
//测试批量删除
for _, v := range mids {
kiteMysql.AsyncDelete(v)
}
time.Sleep(5 * time.Second)
for _, v := range mids {
entity := kiteMysql.Query(v)
if nil != entity {
t.Fatalf("TestBatch|AysncDelete FAIL|%s\n", entity)
t.Fail()
}
}
truncate(kiteMysql)
}
func (self *KiteQClient) SendBytesMessage(msg *protocol.BytesMessage) error {
message := protocol.NewQMessage(msg)
return self.kclientManager.SendMessage(message)
}
func TestFileStoreInit(t *testing.T) {
cleanSnapshot("./snapshot/")
fs := NewKiteFileStore(".", 5000000, 1*time.Second)
fs.Start()
for i := 0; i < 100; i++ {
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String(fmt.Sprint(i) + "26c03f00665862591f696a980b5ac"),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(true),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
succ := fs.Save(entity)
if !succ {
t.Fail()
}
if i < 50 {
fs.AsyncDelete(entity.MessageId)
}
}
fs.Stop()
time.Sleep(10 * time.Second)
log.Println("-------------------Query")
fs = NewKiteFileStore(".", 5000000, 1*time.Second)
fs.Start()
for _, v := range fs.oplogs {
for _, ol := range v {
ob := ol.Value.(*opBody)
log.Printf("TestFileStoreInit|Check|%d|%s", ob.Id, ob.MessageId)
}
}
log.Printf("TestFileStoreInit|Check|SUCC|\n")
//commit and check
for i := 50; i < 100; i++ {
id := fmt.Sprint(i) + "26c03f00665862591f696a980b5ac"
//check entity
entity := fs.Query(id)
if nil == entity || !entity.Commit {
log.Printf("TestFileStoreInit|Exist|FAIL|%s|%s", id, entity)
t.Fail()
return
}
log.Printf("TestFileStoreInit|Exist|SUCC|%d|%s|%s", i, id, entity)
}
log.Printf("TestFileStoreInit|Exist|\n")
//commit and check
for i := 0; i < 50; i++ {
id := fmt.Sprint(i) + "26c03f00665862591f696a980b5ac"
//check entity
entity := fs.Query(id)
if nil != entity {
log.Printf("TestFileStoreInit|Delete|FAIL|%s", id)
t.Fail()
}
}
log.Printf("TestFileStoreInit|Delete\n")
fs.Stop()
cleanSnapshot("./snapshot/")
}
func (self *MockKiteStore) Query(messageId string) *MessageEntity {
entity := NewMessageEntity(protocol.NewQMessage(buildBytesMessage(messageId)))
return entity
}
func TestConvert2Params(t *testing.T) {
options := MysqlOptions{
Addr: "localhost:3306",
Username: "******",
Password: "",
ShardNum: 4,
BatchUpSize: 1000,
BatchDelSize: 1000,
FlushPeriod: 1 * time.Minute,
MaxIdleConn: 2,
MaxOpenConn: 4}
hs := newDbShard(options)
c := convertor{}
sqlwrapper := newSqlwrapper("kite_msg", hs, store.MessageEntity{})
sqlwrapper.initSQL()
c.columns = sqlwrapper.columns
//创建消息
msg := &protocol.BytesMessage{}
msg.Header = &protocol.Header{
MessageId: proto.String("26c03f00665862591f696a980b5a6c4"),
Topic: proto.String("trade"),
MessageType: proto.String("pay-succ"),
ExpiredTime: proto.Int64(time.Now().Add(10 * time.Minute).Unix()),
DeliverLimit: proto.Int32(100),
GroupId: proto.String("go-kite-test"),
Commit: proto.Bool(false),
Fly: proto.Bool(false)}
msg.Body = []byte("hello world")
entity := store.NewMessageEntity(protocol.NewQMessage(msg))
entity.SuccGroups = []string{"go-kite-test"}
hn, _ := os.Hostname()
entity.KiteServer = hn
params := c.Convert2Params(entity)
if nil != params {
for i, col := range c.columns {
cv := params[i]
t.Logf("TestConvert2Params|FIELD|%s|%s\n", col.fieldName, cv)
if col.fieldName == "MessageId" {
rv := reflect.ValueOf(cv)
s := rv.Elem().Interface()
if s.(string) != entity.MessageId {
t.Fail()
}
} else if col.columnName == "body" {
rv := reflect.ValueOf(cv)
s := rv.Elem().Interface()
if string(s.([]byte)) != string(entity.GetBody().([]byte)) {
t.Fail()
}
}
}
} else {
t.Fail()
}
}