func (self *KiteQServer) Start() {
self.remotingServer = server.NewRemotionServer(self.kc.server, self.kc.rc,
func(rclient *client.RemotingClient, p *packet.Packet) {
event := pipe.NewPacketEvent(rclient, p)
err := self.pipeline.FireWork(event)
if nil != err {
log.Error("RemotingServer|onPacketRecieve|FAIL|%s|%t\n", err, p)
} else {
// log.Debug("RemotingServer|onPacketRecieve|SUCC|%s|%t\n", rclient.RemoteAddr(), packet)
}
})
err := self.remotingServer.ListenAndServer()
if nil != err {
log.Crashf("KiteQServer|RemotionServer|START|FAIL|%s|%s\n", err, self.kc.server)
} else {
log.Info("KiteQServer|RemotionServer|START|SUCC|%s\n", self.kc.server)
}
//推送可发送的topic列表并且获取了对应topic下的订阅关系
succ := self.exchanger.PushQServer(self.kc.server, self.kc.topics)
if !succ {
log.Crashf("KiteQServer|PushQServer|FAIL|%s|%s\n", err, self.kc.topics)
} else {
log.Info("KiteQServer|PushQServer|SUCC|%s\n", self.kc.topics)
}
//开启流量统计
self.kc.flowstat.Start()
//开启recover
self.recoverManager.Start()
}
func (self *ConnPool) Shutdown() {
self.mutex.Lock()
defer self.mutex.Unlock()
self.running = false
for i := 0; i < 3; {
//等待五秒中结束
time.Sleep(5 * time.Second)
if self.workPool.Len() <= 0 {
break
}
log.Info("CONNECTION POOL|CLOSEING|WORK POOL SIZE|:%d", self.workPool.Len())
i++
}
var idleconn *IdleConn
//关闭掉空闲的client
for e := self.idlePool.Front(); e != nil; e = e.Next() {
idleconn = e.Value.(*IdleConn)
idleconn.conn.Close()
self.idlePool.Remove(e)
idleconn = nil
}
log.Info("CONNECTION_POOL|SHUTDOWN")
}
func NewApnsHttpServer(option Option) *ApnsHttpServer {
feedbackChan := make(chan *entry.Feedback, 1000)
var apnsClient *apns.ApnsClient
if option.startMode == STARTMODE_MOCK {
//初始化mock apns
apnsClient = apns.NewMockApnsClient(option.cert,
option.pushAddr, chan<- *entry.Feedback(feedbackChan), option.feedbackAddr, entry.NewCycleLink(3, option.storageCapacity))
log.Info("MOCK APNS HTTPSERVER IS STARTING ....")
} else {
//初始化apns
apnsClient = apns.NewDefaultApnsClient(option.cert,
option.pushAddr, chan<- *entry.Feedback(feedbackChan), option.feedbackAddr, entry.NewCycleLink(3, option.storageCapacity))
log.Info("ONLINE APNS HTTPSERVER IS STARTING ....")
}
server := &ApnsHttpServer{feedbackChan: feedbackChan,
apnsClient: apnsClient, expiredTime: option.expiredTime}
//创建http
server.httpserver = NewMomoHttpServer(option.bindAddr, nil)
go server.dial(option.bindAddr)
return server
}
func (self *StmtPool) Shutdown() {
self.mutex.Lock()
defer self.mutex.Unlock()
self.running = false
//等待五秒中结束
time.Sleep(1 * time.Second)
for i := 0; i < 3; {
if self.numWork <= 0 {
break
}
log.Info("Statment Pool|CLOSEING|WORK POOL SIZE|:%d\n", self.numWork)
i++
}
var idleStmt *IdleStmt
//关闭掉空闲的client
for e := self.idlePool.Front(); e != nil; e = e.Next() {
idleStmt = e.Value.(*IdleStmt)
idleStmt.stmt.Close()
self.idlePool.Remove(e)
idleStmt = nil
}
log.Info("Statment Pool|SHUTDOWN")
}
func (self *ApnsHttpServer) dial(hp string) {
log.Info("APNS HTTPSERVER IS STARTING ....")
http.HandleFunc("/apns/push", self.handlePush)
http.HandleFunc("/apns/feedback", self.handleFeedBack)
err := self.httpserver.ListenAndServe()
if nil != err {
log.Error("APNSHTTPSERVER|LISTEN|FAIL|%s", err)
} else {
log.Info("APNSHTTPSERVER|LISTEN|SUCC|%s .....", hp)
}
}
//启动
func (self *KiteClientManager) Start() {
self.zkManager = binding.NewZKManager(self.zkAddr)
//注册kiteqserver的变更
self.zkManager.RegisteWather(PATH_KITEQ_SERVER, self)
hostname, _ := os.Hostname()
//推送本机到
err := self.zkManager.PublishTopics(self.topics, self.ga.GroupId, hostname)
if nil != err {
log.Crashf("KiteClientManager|PublishTopics|FAIL|%s|%s\n", err, self.topics)
} else {
log.Info("KiteClientManager|PublishTopics|SUCC|%s\n", self.topics)
}
outter:
for _, b := range self.binds {
for _, t := range self.topics {
if t == b.Topic {
continue outter
}
}
self.topics = append(self.topics, b.Topic)
}
for _, topic := range self.topics {
hosts, err := self.zkManager.GetQServerAndWatch(topic)
if nil != err {
log.Crashf("KiteClientManager|GetQServerAndWatch|FAIL|%s|%s\n", err, topic)
} else {
log.Info("KiteClientManager|GetQServerAndWatch|SUCC|%s|%s\n", topic, hosts)
}
self.onQServerChanged(topic, hosts)
}
if len(self.kiteClients) <= 0 {
log.Crashf("KiteClientManager|Start|NO VALID KITESERVER|%s\n", self.topics)
}
if len(self.binds) > 0 {
//订阅关系推送，并拉取QServer
err = self.zkManager.PublishBindings(self.ga.GroupId, self.binds)
if nil != err {
log.Crashf("KiteClientManager|PublishBindings|FAIL|%s|%s\n", err, self.binds)
}
}
}
//remove segment
func (self *MessageStore) remove(s *Segment) {
self.Lock()
//remove from segments
for i, s := range self.segments {
if s.sid == s.sid {
self.segments = append(self.segments[0:i], self.segments[i+1:]...)
break
}
}
//remove from cache
for e := self.segmentCache.Front(); nil != e; e = e.Next() {
cs := e.Value.(*Segment)
if cs.sid == s.sid {
self.segmentCache.Remove(e)
break
}
}
//close segment
s.Close()
err := os.Remove(s.path)
if nil != err {
log.Warn("MessageStore|Remove|Segment|FAIL|%s|%s", err, s.path)
}
err = os.Remove(s.slog.path)
if nil != err {
log.Warn("MessageStore|Remove|SegmentLog|FAIL|%s|%s", err, s.slog.path)
}
self.Unlock()
log.Info("MessageStore|Remove|Segment|%s", s.path)
}
func (self *ClientManager) Shutdown() {
self.reconnectManager.stop()
for _, c := range self.allClients {
c.Shutdown()
}
log.Info("ClientManager|Shutdown....")
}
func (self *ClientManager) removeClient(hostport string) {
ga, ok := self.groupAuth[hostport]
if ok {
//删除分组
delete(self.groupAuth, hostport)
//删除group中的client
gc, ok := self.groupClients[ga.GroupId]
if ok {
for i, cli := range gc {
if cli.RemoteAddr() == hostport {
self.groupClients[ga.GroupId] = append(gc[0:i], gc[i+1:]...)
break
}
}
}
//删除hostport->client的对应关系
c, ok := self.allClients[hostport]
if ok {
c.Shutdown()
delete(self.allClients, hostport)
}
}
log.Info("ClientManager|removeClient|%s...\n", hostport)
}
//发布topic对应的server
func (self *ZKManager) PublishQServer(hostport string, topics []string) error {
for _, topic := range topics {
qpath := KITEQ_SERVER + "/" + topic
spath := KITEQ_SUB + "/" + topic
ppath := KITEQ_PUB + "/" + topic
//创建发送和订阅的根节点
self.traverseCreatePath(ppath, nil, zk.CreatePersistent)
// self.session.ExistsW(ppath)
self.traverseCreatePath(spath, nil, zk.CreatePersistent)
self.session.ExistsW(spath)
//先删除当前这个临时节点再注册 避免监听不到临时节点变更的事件
self.session.Delete(qpath+"/"+hostport, -1)
//注册当前节点
path, err := self.registePath(qpath, hostport, zk.CreateEphemeral, nil)
if nil != err {
log.Error("ZKManager|PublishQServer|FAIL|%s|%s/%s\n", err, qpath, hostport)
return err
}
log.Info("ZKManager|PublishQServer|SUCC|%s\n", path)
}
//注册当前的kiteqserver
self.session.Delete(KITEQ_ALIVE_SERVERS+"/"+hostport, -1)
self.registePath(KITEQ_ALIVE_SERVERS, hostport, zk.CreateEphemeral, nil)
self.registePath(KITEQ_ALL_SERVERS, hostport, zk.CreatePersistent, nil)
return nil
}
//发布订阅关系
func (self *ZKManager) PublishBindings(groupId string, bindings []*Binding) error {
//按topic分组
groupBind := make(map[string][]*Binding, 10)
for _, b := range bindings {
g, ok := groupBind[b.Topic]
if !ok {
g = make([]*Binding, 0, 2)
}
b.GroupId = groupId
g = append(g, b)
groupBind[b.Topic] = g
}
for topic, binds := range groupBind {
data, err := MarshalBinds(binds)
if nil != err {
log.Error("ZKManager|PublishBindings|MarshalBind|FAIL|%s|%s|%t\n", err, groupId, binds)
return err
}
createType := zk.CreatePersistent
path := KITEQ_SUB + "/" + topic
//注册对应topic的groupId //注册订阅信息
succpath, err := self.registePath(path, groupId+"-bind", createType, data)
if nil != err {
log.Error("ZKManager|PublishTopic|Bind|FAIL|%s|%s/%s\n", err, path, binds)
return err
} else {
log.Info("ZKManager|PublishTopic|Bind|SUCC|%s|%s\n", succpath, binds)
}
}
return nil
}
func main() {
runtime.GOMAXPROCS(8)
startMode := flag.Int("startMode", 1, " 0 为mock ,1 为正式")
bindAddr := flag.String("bindAddr", ":17070", "-bindAddr=:17070")
certPath := flag.String("certPath", "./cert.pem", "-certPath=xxxxxx/cert.pem or -certPath=http://")
keyPath := flag.String("keyPath", "./key.pem", "-keyPath=xxxxxx/key.pem or -keyPath=http://")
runMode := flag.Int("runMode", 0, "-runMode=1(online) ,0(sandbox)")
storeCap := flag.Int("storeCap", 1000, "-storeCap=100000 //重发链条长度")
logxml := flag.String("log", "log.xml", "-log=log.xml //log配置文件")
pprofPort := flag.String("pprof", ":9090", "pprof=:9090 //端口")
flag.Parse()
go func() {
if len(*pprofPort) > 0 {
addr, _ := net.ResolveTCPAddr("tcp4", *bindAddr)
log.Error(http.ListenAndServe(addr.IP.String()+*pprofPort, nil))
}
}()
//加载log4go的配置
log.LoadConfiguration(*logxml)
//设置启动项
option := server.NewOption(*startMode, *bindAddr, *certPath, *keyPath, *runMode, *storeCap)
apnsserver := server.NewApnsHttpServer(option)
ch := make(chan os.Signal, 1)
signal.Notify(ch, os.Kill)
//kill掉的server
<-ch
apnsserver.Shutdown()
log.Info("APNS SERVER IS STOPPED!")
}
//发布topic对应的server
func (self *ZKManager) PublishQServer(hostport string, topics []string) error {
for _, topic := range topics {
qpath := KITEQ_SERVER + "/" + topic
spath := KITEQ_SUB + "/" + topic
ppath := KITEQ_PUB + "/" + topic
//创建发送和订阅的根节点
self.traverseCreatePath(ppath, nil, zk.CreatePersistent)
// self.session.ExistsW(ppath)
self.traverseCreatePath(spath, nil, zk.CreatePersistent)
self.session.ExistsW(spath)
//注册当前节点
path, err := self.registePath(qpath, hostport, zk.CreateEphemeral, nil)
if nil != err {
log.Error("ZKManager|PublishQServer|FAIL|%s|%s/%s\n", err, qpath, hostport)
return err
}
log.Info("ZKManager|PublishQServer|SUCC|%s\n", path)
}
return nil
}
//关闭掉exchanger
func (self *BindExchanger) Shutdown() {
//删除掉当前的QServer
self.zkmanager.UnpushlishQServer(self.kiteqserver, self.topics)
time.Sleep(10 * time.Second)
self.zkmanager.Close()
log.Info("BindExchanger|Shutdown...")
}
//握手包
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 (self *FlowStat) Start() {
go func() {
t := time.NewTicker(1 * time.Second)
for !self.stop {
self.DeliverCount = self.DeliverFlow.Changes()
line := fmt.Sprintf("%s\tdeliver:%d\tdeliver-go:%d\t", self.name, self.DeliverCount, self.DeliverPool.Count())
log.Info(line)
if nil != self.Kitestore {
log.Info(self.Kitestore.Monitor())
}
<-t.C
}
t.Stop()
}()
}
func (self *KiteMysqlStore) Start() {
count := SHARD_SEED
//创建Hash的channel
batchDelChan := make([]chan string, 0, count)
batchUpChan := make([]chan *MessageEntity, 0, count)
batchComChan := make([]chan string, 0, count)
for i := 0; i < count; i++ {
batchUpChan = append(batchUpChan, make(chan *MessageEntity, self.batchUpSize*2))
batchDelChan = append(batchDelChan, make(chan string, self.batchDelSize*2))
batchComChan = append(batchComChan, make(chan string, self.batchUpSize*2))
}
//批量的channel
self.batchUpChan = batchUpChan
self.batchDelChan = batchDelChan
self.batchComChan = batchComChan
//创建每种批量的preparedstmt
stmts := make(map[batchType][][]*StmtPool, 4)
for k, v := range self.sqlwrapper.batchSQL {
btype := k
pool := make([][]*StmtPool, 0, self.dbshard.ShardNum())
//对每个shard构建stmt的pool
for i := 0; i < self.dbshard.ShardNum(); i++ {
innerPool := make([]*StmtPool, 0, self.dbshard.HashNum())
for j, s := range v {
psql := s
db := self.dbshard.FindShardById(i*self.dbshard.HashNum() + j).master
err, p := NewStmtPool(5, 10, 20, 1*time.Minute, func() (error, *sql.Stmt) {
stmt, err := db.Prepare(psql)
if nil != err {
log.Error("StmtPool|Create Stmt|FAIL|%s|%s\n", err, psql)
return err, nil
}
return nil, stmt
})
if nil != err {
log.Error("NewKiteMysql|NewStmtPool|FAIL|%s\n", err)
panic(err)
}
innerPool = append(innerPool, p)
}
pool = append(pool, innerPool)
}
stmts[btype] = pool
}
self.stmtPools = stmts
for i := 0; i < count; i++ {
// log.Printf("KiteMysqlStore|start|SQL|%s\n|%s\n", sqlu, sqld)
self.startBatch(i, self.batchUpChan[i],
self.batchDelChan[i], self.batchComChan[i])
}
log.Info("KiteMysqlStore|Start...")
}
func (self *ReconnectManager) stop() {
self.allowReconnect = false
self.lock.Lock()
defer self.lock.Unlock()
for _, t := range self.timers {
t.Stop()
}
log.Info("ReconnectManager|stop...")
}
func (self *KiteClientManager) remointflow() {
go func() {
t := time.NewTicker(1 * time.Second)
for {
log.Info(self.rc.FlowStat.Monitor())
<-t.C
}
}()
}
func (self *KiteQServer) Shutdown() {
//先关闭exchanger让客户端不要再输送数据
self.exchanger.Shutdown()
self.recoverManager.Stop()
self.kitedb.Stop()
self.clientManager.Shutdown()
self.remotingServer.Shutdown()
log.Info("KiteQServer|Shutdown...")
}
func (self *RemotingServer) Start() {
t := time.NewTicker(1 * time.Second)
for !self.isShutdown {
line := self.rc.FlowStat.Monitor()
log.Info(line)
<-t.C
}
t.Stop()
}
//------创建投递结果处理器
func NewDeliverResultHandler(name string, deliverTimeout time.Duration, kitestore store.IKiteStore, rw []RedeliveryWindow) *DeliverResultHandler {
dhandler := &DeliverResultHandler{}
dhandler.BaseForwardHandler = NewBaseForwardHandler(name, dhandler)
dhandler.kitestore = kitestore
dhandler.deliverTimeout = deliverTimeout
dhandler.rw = redeliveryWindows(rw)
dhandler.tw = turbo.NewTimeWheel(time.Duration(int64(deliverTimeout)/10), 10, 5)
go func() {
for {
time.Sleep(1 * time.Second)
log.Info(dhandler.tw.Monitor())
}
}()
//排好序
sort.Sort(dhandler.rw)
log.Info("RedeliveryWindows|%s\n ", dhandler.rw)
return dhandler
}
func (self *DefaultPipeline) RegisteHandler(name string, handler IHandler) {
_, canHandleForward := handler.(IForwardHandler)
_, canHandleBackward := handler.(IBackwardHandler)
ctx := &DefaultPipelineContext{handler: handler,
canHandleForward: canHandleForward,
canHandleBackward: canHandleBackward}
ctx.pipeline = self
currctx := self.eventHandler.PushBack(ctx)
self.hashEventHandler[name] = currctx
log.Info("DefaultPipeline|RegisteHandler|%s\n", name)
}
func (self *KiteMysqlStore) Stop() {
self.stop = true
for k, v := range self.stmtPools {
for _, s := range v {
for _, p := range s {
p.Shutdown()
}
}
log.Info("KiteMysqlStore|Stop|Stmt|%t\n", k)
}
self.dbshard.Stop()
}
//重连管理器
func NewReconnectManager(allowReconnect bool,
reconnectTimeout time.Duration, maxReconnectTimes int,
handshake func(ga *GroupAuth, remoteClient *RemotingClient) (bool, error)) *ReconnectManager {
manager := &ReconnectManager{
timers: make(map[string]*time.Timer, 20),
allowReconnect: allowReconnect,
reconnectTimeout: reconnectTimeout,
maxReconnectTimes: maxReconnectTimes, handshake: handshake}
log.Info("ReconnectManager|Start...")
return manager
}
func (self *KiteFileStore) Start() {
self.Lock()
defer self.Unlock()
if !self.running {
self.Add(1)
self.running = true
//start snapshost
self.snapshot.Start()
go self.delSync()
log.Info("KiteFileStore|Start...\t%s", self.Monitor())
}
}
//发布可以使用的topic类型的publisher
func (self *ZKManager) PublishTopics(topics []string, groupId string, hostport string) error {
for _, topic := range topics {
pubPath := KITEQ_PUB + "/" + topic + "/" + groupId
path, err := self.registePath(pubPath, hostport, zk.CreatePersistent, nil)
if nil != err {
log.Error("ZKManager|PublishTopic|FAIL|%s|%s/%s\n", err, pubPath, hostport)
return err
}
log.Info("ZKManager|PublishTopic|SUCC|%s\n", path)
}
return nil
}
//推送Qserver到配置中心
func (self *BindExchanger) PushQServer(hostport string, topics []string) bool {
err := self.zkmanager.PublishQServer(hostport, topics)
if nil != err {
log.Error("BindExchanger|PushQServer|FAIL|%s|%s|%s\n", err, hostport, topics)
return false
}
log.Info("BindExchanger|PushQServer|SUCC|%s|%s\n", hostport, topics)
self.topics = append(self.topics, topics...)
sort.Strings(self.topics)
//订阅订阅关系变更
return self.subscribeBinds(self.topics)
}
func (self *Segment) Open(do func(ol *oplog)) error {
self.Lock()
defer self.Unlock()
if atomic.CompareAndSwapInt32(&self.isOpen, 0, 1) {
// log.Info("Segment|Open|BEGIN|%s|%s", self.path, self.name)
var rf *os.File
var wf *os.File
_, err := os.Stat(self.path)
//file exist
if os.IsNotExist(err) {
_, err := os.Create(self.path)
if nil != err {
log.Error("Segment|Create|FAIL|%s|%s", err, self.path)
return err
}
}
//file not exist create file
wf, err = os.OpenFile(self.path, os.O_RDWR|os.O_APPEND, os.ModePerm)
if nil != err {
log.Error("Segment|Open|FAIL|%s|%s", err, self.name)
return err
}
rf, err = os.OpenFile(self.path, os.O_RDWR, os.ModePerm)
if nil != err {
log.Error("Segment|Open|FAIL|%s|%s", err, self.name)
return err
}
self.rf = rf
self.wf = wf
//buffer
self.br = bufio.NewReader(rf)
//load
self.loadCheck()
// //seek
// self.wf.Seek(self.offset, 0)
self.bw = bufio.NewWriter(wf)
//op segment log
self.slog.Open()
//recover segment
self.recover(do)
total, n, d, e := self.stat()
log.Info("Segment|Open|SUCC|%s|total:%d,n:%d,d:%d,e:%d", self.name, total, n, d, e)
return nil
}
return nil
}
//去除掉当前的KiteQServer
func (self *ZKManager) UnpushlishQServer(hostport string, topics []string) {
for _, topic := range topics {
qpath := KITEQ_SERVER + "/" + topic + "/" + hostport
//删除当前该Topic下的本机
err := self.session.Delete(qpath, -1)
if nil != err {
log.Error("ZKManager|UnpushlishQServer|FAIL|%s|%s\n", err, qpath)
} else {
log.Info("ZKManager|UnpushlishQServer|SUCC|%s\n", qpath)
}
}
}