func (self *MockListener) OnMessageCheck(tx *protocol.TxResponse) error {
log.Debug("MockListener|OnMessageCheck|%s\n", tx.MessageId)
v, _ := tx.GetProperty("tradeno")
log.DebugLog("kite_client", "MockListener|OnMessageCheck|PROP|%s\n", v)
tx.Commit()
return nil
}
func (self *MessageStore) recoverSnapshot() {
//current segmentid
if len(self.segments) > 0 {
//replay log
for i, s := range self.segments {
err := s.Open(self.replay)
if nil != err {
log.ErrorLog("kite_store", "MessageStore|recoverSnapshot|Fail|%s", err, s.slog.path)
panic(err)
}
//last segments
if i == len(self.segments)-1 {
if nil != err {
panic("MessageStore|Load Last Segment|FAIL|" + err.Error())
}
//set snapshost status
if len(s.chunks) > 0 {
self.chunkId = s.chunks[len(s.chunks)-1].id
}
}
log.DebugLog("kite_store", "MessageStore|recoverSnapshot|%s", s.name)
}
}
}
//处理push
func (self *ApnsHttpServer) handlePush(out http.ResponseWriter, req *http.Request) {
resp := &response{}
resp.Status = RESP_STATUS_SUCC
if req.Method == "GET" {
//返回不支持的请求方式
resp.Status = RESP_STATUS_INVALID_PROTO
resp.Error = errors.New("Unsupport Get method Invoke!")
} else if req.Method == "POST" {
//pushType
pushType := req.PostFormValue("pt") //先默认采用Enhanced方式
//接卸对应的token和payload
token, payload := self.decodePayload(req, resp)
trace := req.PostFormValue("trace")
expiredSeconds := req.PostFormValue("expiredSeconds")
expiredTime := self.expiredTime
if len(expiredSeconds) > 0 {
t, err := strconv.ParseInt(expiredSeconds, 10, 32)
if nil == err {
expiredTime = uint32(t)
}
}
//----------------如果依然是成功状态则证明当前可以发送
if RESP_STATUS_SUCC == resp.Status {
func() {
defer func() {
if re := recover(); nil != re {
stack := re.(*errors.Error).ErrorStack()
log.ErrorLog("push_handler", "ApnsHttpServer|handlePush|SEND|FAIL|%s|%s|%s", stack, payload, trace)
resp.Status = RESP_STATUS_ERROR
resp.Error = errors.New(fmt.Sprintf("%s", re))
self.write(out, resp)
}
}()
self.innerSend(pushType, token, payload, resp, expiredTime)
self.write(out, resp)
log.DebugLog("push_handler", "ApnsHttpServer|handlePush|SUCC|%s|%s|%s", resp, payload, trace)
}()
} else {
log.WarnLog("push_handler", "ApnsHttpServer|handlePush|FAIL|%s|%s|%s", resp, payload, trace)
self.write(out, resp)
}
}
}
//重发逻辑
func (self *ApnsClient) resend(ch chan *entry.Message) {
for self.running {
select {
case <-time.After(5 * time.Second):
case msg := <-ch:
//发送之......
self.sendMessage(msg)
self.resendCounter.Incr(1)
log.DebugLog("push_client", "APNSCLIENT|RESEND|%s\n", msg)
}
}
}
//发送非flymessage
func (self *PersistentHandler) sendUnFlyMessage(ctx *DefaultPipelineContext, pevent *persistentEvent) {
saveSucc := true
// log.DebugLog("kite_handler", "PersistentHandler|sendUnFlyMessage|%s", pevent.entity)
//提交并且开启优化
if self.fly &&
pevent.entity.Header.GetCommit() {
//先投递尝试投递一次再去根据结果写存储
ch := make(chan []string, 1) //用于返回尝试投递结果
self.send(ctx, pevent, ch)
/*如果是成功的则直接返回处理存储成功的
*如果失败了，则需要持久化
*/
failGroups := <-ch
//失败或者超时的持久化
if len(failGroups) > 0 {
pevent.entity.DeliverCount += 1
if nil != failGroups {
pevent.entity.FailGroups = failGroups
}
//写入到持久化存储里面
saveSucc = self.kitestore.Save(pevent.entity)
//再投递
self.send(ctx, pevent, nil)
} else {
log.DebugLog("kite_handler", "PersistentHandler|sendUnFlyMessage|FLY|%s", pevent.entity)
}
} else {
// now := time.Now().UnixNano()
//写入到持久化存储里面,再投递
saveSucc = self.kitestore.Save(pevent.entity)
// log.DebugLog("kite_handler", "PersistentHandler|sendUnFlyMessage|cost:%d", time.Now().UnixNano()-now)
if saveSucc && pevent.entity.Commit {
self.send(ctx, pevent, nil)
}
}
//发送存储结果ack
remoteEvent := NewRemotingEvent(storeAck(pevent.opaque,
pevent.entity.Header.GetMessageId(), saveSucc, fmt.Sprintf("Store Result %t", saveSucc)),
[]string{pevent.remoteClient.RemoteAddr()})
ctx.SendForward(remoteEvent)
}
//delete chunk
func (self *Segment) Delete(cid int64) bool {
idx := sort.Search(len(self.chunks), func(i int) bool {
return self.chunks[i].id >= cid
})
if idx < len(self.chunks) {
//mark delete
s := self.chunks[idx]
if s.flag != DELETE && s.flag != EXPIRED {
s.flag = DELETE
return true
}
} else {
log.DebugLog("kite_store", "Segment|Delete|NO Chunk|chunkid:%d|%d", cid, idx, len(self.chunks))
}
return true
}
func loadTomlConf(path, clusterName, bindHost string, pprofPort int, so *ServerOption) error {
f, err := os.Open(path)
if err != nil {
return err
}
defer f.Close()
buff, rerr := ioutil.ReadAll(f)
if nil != rerr {
return rerr
}
log.DebugLog("kite_server", "ServerConfig|Parse|toml:%s", string(buff))
//读取配置
var option Option
err = toml.Unmarshal(buff, &option)
if nil != err {
return err
}
cluster, ok := option.Clusters[clusterName]
if !ok {
return errors.New("no cluster config for " + clusterName)
}
zk, exist := option.Zookeeper[cluster.Env]
if !exist {
return errors.New("no zk for " + clusterName + ":" + cluster.Env)
}
//解析
so.zkhosts = zk.Hosts
so.topics = cluster.Topics
so.deliveryFirst = cluster.DeliveryFirst
so.dlqExecHour = cluster.DlqExecHour
so.logxml = cluster.Logxml
so.db = cluster.Db
so.deliveryTimeout = time.Duration(cluster.DeliverySeconds * int64(time.Second))
so.maxDeliverWorkers = cluster.MaxDeliverWorkers
so.recoverPeriod = time.Duration(cluster.RecoverSeconds * int64(time.Second))
so.bindHost = bindHost
so.pprofPort = pprofPort
so.clusterName = clusterName
so.configPath = path
return nil
}
func (self *ApnsConnection) sendMessage(msg *entry.Message) error {
//将当前的msg强制设置为当前conn的id作为标识
msg.ProcessId = self.connectionId
err, packet := msg.Encode()
if nil != err {
return err
}
length, sendErr := self.conn.Write(packet)
if nil != err || length != len(packet) {
log.WarnLog("push_client", "CONNECTION|SEND MESSAGE|FAIL|%s", err)
} else {
log.DebugLog("push_client", "CONNECTION|SEND MESSAGE|SUCC")
}
return sendErr
}
//检查idle的数据
func (self *ConnPool) checkIdle() {
self.mutex.Lock()
defer self.mutex.Unlock()
for e := self.idlePool.Back(); nil != e; e = e.Prev() {
idleconn := e.Value.(*IdleConn)
//如果当前时间在过期时间之后或者活动的链接大于corepoolsize则关闭
isExpired := idleconn.expiredTime.Before(time.Now())
if isExpired ||
(self.idlePool.Len()+self.workPool.Len()) > self.corepoolSize {
idleconn.conn.Close()
idleconn = nil
self.idlePool.Remove(e)
log.DebugLog("apns_pool", "POOL_FACTORY|evict|Expired|%d/%d/%d",
self.workPool.Len(), self.idlePool.Len(), (self.workPool.Len() + self.idlePool.Len()))
}
}
//检查当前的连接数是否满足corepoolSize,不满足则创建
enhanceSize := self.corepoolSize - (self.idlePool.Len() + self.workPool.Len())
if enhanceSize > 0 {
//创建这个数量的连接
self.enhancedPool(enhanceSize)
}
}
//内部发送代码
func (self *ApnsHttpServer) innerSend(pushType string, token string, payload *entry.PayLoad, resp *response, expiredTime uint32) {
var sendFunc func() error
if NOTIFY_SIMPLE_FORMAT == pushType {
//如果为简单
sendFunc = func() error {
return self.apnsClient.SendSimpleNotification(token, *payload)
}
} else if NOTIFY_ENHANCED_FORMAT == pushType {
//如果为扩展的
id := self.identifierId()
sendFunc = func() error {
return self.apnsClient.SendEnhancedNotification(id,
expiredTime, token, *payload)
}
} else {
resp.Status = RESP_STATUS_INVALID_NOTIFY_FORMAT
resp.Error = errors.New("Invalid notification format " + pushType)
}
//能直接放在chan中异步发送
var err error
//如果有异常则重试发送
if RESP_STATUS_SUCC == resp.Status {
err = sendFunc()
if nil == err {
log.DebugLog("push_handler", "ApnsHttpServer|SendNotification|SUCC|FORMAT:%s|%s", pushType, *payload)
}
}
if nil != err {
log.ErrorLog("push_handler", "ApnsHttpServer|SendNotification|FORMAT:%s|FAIL|IGNORED|%s|%s", pushType, *payload, err)
resp.Status = RESP_STATUS_SEND_OVER_TRY_ERROR
resp.Error = err
}
}
func (self *MockListener) OnMessage(msg *protocol.QMessage) bool {
log.DebugLog("kite_client", "MockListener|OnMessage", msg.GetHeader(), msg.GetBody())
return true
}