Пример #1
0
func (self *MockListener) OnMessageCheck(tx *protocol.TxResponse) error {
	log.Debug("MockListener|OnMessageCheck|%s\n", tx.MessageId)
	v, _ := tx.GetProperty("tradeno")
	log.Debug("MockListener|OnMessageCheck|PROP|%s\n", v)
	tx.Commit()
	return nil
}
Пример #2
0
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.Error("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.Debug("MessageStore|recoverSnapshot|%s", s.name)
		}
	}
}
Пример #3
0
func (self *Session) Close() error {

	if !self.isClose {
		self.isClose = true
		//flush
		self.bw.Flush()
		self.conn.Close()
		close(self.WriteChannel)
		close(self.ReadChannel)

		log.Debug("Session|Close|%s...", self.remoteAddr)
	}
	return nil
}
Пример #4
0
//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.Debug("Segment|Delete|NO Chunk|chunkid:%d|%d", cid, idx, len(self.chunks))
	}

	return true
}
Пример #5
0
//启动当前的client
func (self *RemotingClient) Start() {

	//重新初始化
	laddr := self.conn.LocalAddr().(*net.TCPAddr)
	raddr := self.conn.RemoteAddr().(*net.TCPAddr)
	self.localAddr = fmt.Sprintf("%s:%d", laddr.IP, laddr.Port)
	self.remoteAddr = fmt.Sprintf("%s:%d", raddr.IP, raddr.Port)

	//开启写操作
	go self.remoteSession.WritePacket()

	//开启转发
	go self.dispatcherPacket()

	//启动读取
	go self.remoteSession.ReadPacket()

	log.Debug("RemotingClient|Start|SUCC|local:%s|remote:%s\n", self.LocalAddr(), self.RemoteAddr())
}
Пример #6
0
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.Warn("CONNECTION|SEND MESSAGE|FAIL|%s", err)
	} else {
		log.Debug("CONNECTION|SEND MESSAGE|SUCC")

	}

	return sendErr
}
Пример #7
0
func (self *ApnsClient) sendMessage(msg *entry.Message) error {
	var sendError error
	//重发逻辑
	for i := 0; i < 3; i++ {

		err, conn := self.factory.Get()
		if nil != err || nil == conn {
			log.Error("APNSCLIENT|SEND MESSAGE|FAIL|GET CONN|FAIL|%s|%s", err, *msg)
			sendError = err
			continue
		}

		//将当前enchanced发送的数据写入到storage中
		if nil != self.storage &&
			msg.MsgType == entry.MESSAGE_TYPE_ENHANCED {
			//正常发送的记录即可
			self.storage.Insert(entry.UmarshalIdentifier(msg), msg)
			// if rand.Intn(100) == 0 {
			// 	log.Printf("APNSCLIENT|sendMessage|RECORD MESSAGE|%s\n", msg)
			// }
		} else {
			//否则丢弃不开启重发........
		}

		//直接发送的没有返回值
		sendError = conn.sendMessage(msg)
		self.sendCounter.Incr(1)
		if nil != sendError {
			self.failCounter.Incr(1)
			//连接有问题直接销毁
			releaseErr := self.factory.ReleaseBroken(conn)
			log.Debug("APNSCLIENT|SEND MESSAGE|FAIL|RELEASE BROKEN CONN|FAIL|%s", releaseErr)

		} else {
			//发送成功归还连接
			self.factory.Release(conn)
			break
		}
	}

	return sendError
}
Пример #8
0
func (self *FeedbackConn) readFeedBack(limit int) {

	buff := make([]byte, entry.FEEDBACK_RESP, entry.FEEDBACK_RESP)
	for self.alive && limit > 0 {
		length, err := self.conn.Read(buff)
		//如果已经读完数据那么久直接退出
		if length == -1 || nil != err {
			self.feedbackChan <- nil
			break
		}

		//读取的数据
		feedback := entry.NewFeedBack(buff)
		self.feedbackChan <- feedback
		limit--
		buff = buff[:entry.FEEDBACK_RESP]
	}
	//本次读取完毕
	log.Debug("FEEDBACK CONNECTION|READ FEEDBACK|FINISHED!")

}
Пример #9
0
//内部发送代码
func (self *ApnsHttpServer) innerSend(pushType string, token string, payload *entry.PayLoad, resp *response) {

	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,
				self.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.Debug("APNS_HTTP_SERVER|SendNotification|SUCC|FORMAT:%s|%s", pushType, *payload)
		}
	}
	if nil != err {
		log.ErrorLog("go-apns", "APNS_HTTP_SERVER|SendNotification|FORMAT:%s|FAIL|IGNORED|%s|%s", pushType, *payload, err)
		resp.Status = RESP_STATUS_SEND_OVER_TRY_ERROR
		resp.Error = err
	}
}
Пример #10
0
//检查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.Debug("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)
	}
}
Пример #11
0
func parseDB(kc KiteQConfig) store.IKiteStore {
	db := kc.db

	var kitedb store.IKiteStore
	if strings.HasPrefix(db, "mock://") {
		kitedb = &store.MockKiteStore{}
	} else if strings.HasPrefix(db, "memory://") {
		url := strings.TrimPrefix(db, "memory://")
		split := strings.Split(url, "&")
		params := make(map[string]string, len(split))
		for _, v := range split {
			p := strings.SplitN(v, "=", 2)
			if len(p) >= 2 {
				params[p[0]] = p[1]
			}
		}

		initval := 10 * 10000
		initcap, ok := params["initcap"]
		if ok {
			v, e := strconv.ParseInt(initcap, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|INIT CAP|%s\n", db)
			}
			initval = int(v)
		}
		max := 50 * 10000
		maxcap, ok := params["maxcap"]
		if ok {
			v, e := strconv.ParseInt(maxcap, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|MAX CAP|%s\n", db)
			}
			max = int(v)
		}
		kitedb = sm.NewKiteMemoryStore(initval, max)
	} else if strings.HasPrefix(db, "mysql://") {
		url := strings.TrimPrefix(db, "mysql://")
		mp := strings.Split(url, "?")
		params := make(map[string]string, 5)
		if len(mp) > 1 {
			split := strings.Split(mp[1], "&")
			for _, v := range split {
				p := strings.SplitN(v, "=", 2)
				params[p[0]] = p[1]
			}
		}

		bus := 100
		u, ok := params["batchUpdateSize"]
		if ok {
			v, e := strconv.ParseInt(u, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|batchUpdateSize|%s\n", db)
			}
			bus = int(v)
		}

		bds := 100
		d, ok := params["batchDelSize"]
		if ok {
			v, e := strconv.ParseInt(d, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|batchDelSize|%s\n", db)
			}
			bds = int(v)
		}

		flushPeriod := 1 * time.Second
		fp, ok := params["flushPeriod"]
		if ok {
			v, e := strconv.ParseInt(fp, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|batchDelSize|%s\n", db)
			}
			flushPeriod = time.Duration(v * int64(flushPeriod))
		}

		maxConn := 500
		mc, ok := params["maxConn"]
		if ok {
			v, e := strconv.ParseInt(mc, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|batchDelSize|%s\n", db)
			}
			maxConn = int(v)
		}

		//解析Mysql的host
		master := mp[0]
		slave := ""
		mysqlHosts := strings.Split(mp[0], ",")
		if len(mysqlHosts) > 1 {
			master = mysqlHosts[0]
			slave = mysqlHosts[1]
		}

		//解析用户名密码:
		username, _ := params["username"]
		password, pok := params["password"]
		if !pok {
			password = ""
		}

		//shard的数量
		shardnum := 8
		sd, sdok := params["shardnum"]
		if sdok {
			v, e := strconv.ParseInt(sd, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|ShardNum|%s\n", db)
			}
			shardnum = int(v)
		}

		options := smq.MysqlOptions{
			Addr:         master,
			SlaveAddr:    slave,
			ShardNum:     shardnum,
			DB:           params["db"],
			Username:     username,
			Password:     password,
			BatchUpSize:  bus,
			BatchDelSize: bds,
			FlushPeriod:  flushPeriod,
			MaxIdleConn:  maxConn / 2,
			MaxOpenConn:  maxConn}
		kitedb = smq.NewKiteMysql(options)
	} else if strings.HasPrefix(db, "file://") {
		url := strings.TrimPrefix(db, "file://")
		mp := strings.Split(url, "?")
		params := make(map[string]string, 5)
		if len(mp) > 1 {
			split := strings.Split(mp[1], "&")
			for _, v := range split {
				p := strings.SplitN(v, "=", 2)
				params[p[0]] = p[1]
			}
		}
		if len(mp[0]) <= 0 {
			log.Crashf("NewKiteQServer|INVALID|FilePath|%s\n", db)
		}

		//最大消息容量
		maxcap := 100
		d, ok := params["cap"]
		if ok {
			v, e := strconv.ParseInt(d, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|cap|%s\n", db)
			}
			maxcap = int(v)
		}

		//检查文件过期时间
		checkPeriod := 1 * time.Second
		fp, ok := params["checkPeriod"]
		if ok {
			v, e := strconv.ParseInt(fp, 10, 32)
			if nil != e {
				log.Crashf("NewKiteQServer|INVALID|checkPeriod|%s\n", db)
			}
			checkPeriod = time.Duration(v * int64(checkPeriod))
		}

		kitedb = smf.NewKiteFileStore(mp[0], maxcap, checkPeriod)
		log.Debug("NewKiteQServer|FILESTORE|%s|%d|%d", mp[0], maxcap, int(checkPeriod.Seconds()))
	} else {
		log.Crashf("NewKiteQServer|UNSUPPORT DB PROTOCOL|%s\n", db)
	}
	kc.flowstat.Kitestore = kitedb
	return kitedb
}
Пример #12
0
func main() {
	logxml := flag.String("logxml", "./log/log_producer.xml", "-logxml=./log/log_producer.xml")
	k := flag.Int("k", 1, "-k=1  //kiteclient num ")
	c := flag.Int("c", 10, "-c=100")
	tx := flag.Bool("tx", false, "-tx=true send Tx Message")
	zkhost := flag.String("zkhost", "localhost:2181", "-zkhost=localhost:2181")
	flag.Parse()

	runtime.GOMAXPROCS(8)

	log.LoadConfiguration(*logxml)

	go func() {

		log.Info(http.ListenAndServe(":28000", nil))
	}()

	count := int32(0)
	lc := int32(0)

	fc := int32(0)
	flc := int32(0)

	go func() {
		for {

			tmp := count
			ftmp := fc

			time.Sleep(1 * time.Second)
			fmt.Printf("tps:%d/%d\n", (tmp - lc), (ftmp - flc))
			lc = tmp
			flc = ftmp
		}
	}()

	wg := &sync.WaitGroup{}
	stop := false
	clients := make([]*client.KiteQClient, 0, *k)
	for j := 0; j < *k; j++ {

		kiteClient := client.NewKiteQClient(*zkhost, "pb-mts-test", "123456", &defualtListener{})
		kiteClient.SetTopics([]string{"trade"})
		kiteClient.Start()
		clients = append(clients, kiteClient)
		time.Sleep(3 * time.Second)
		log.Debug("Open Client %d", j)
		for i := 0; i < *c; i++ {
			go func(kite *client.KiteQClient) {
				wg.Add(1)

				for !stop {
					if *tx {
						msg := buildBytesMessage(false)
						err := kite.SendTxBytesMessage(msg, doTranscation)
						if nil != err {
							fmt.Printf("SEND TxMESSAGE |FAIL|%s\n", err)
							atomic.AddInt32(&fc, 1)
						} else {
							atomic.AddInt32(&count, 1)
						}
					} else {
						txmsg := buildBytesMessage(true)
						err := kite.SendBytesMessage(txmsg)
						if nil != err {
							// fmt.Printf("SEND MESSAGE |FAIL|%s\n", err)
							atomic.AddInt32(&fc, 1)
						} else {
							atomic.AddInt32(&count, 1)
						}
					}
					// stop = true
				}
				wg.Done()
			}(kiteClient)
		}
	}

	var s = make(chan os.Signal, 1)
	signal.Notify(s, syscall.SIGKILL, syscall.SIGUSR1)
	//是否收到kill的命令
	for {
		cmd := <-s
		if cmd == syscall.SIGKILL {
			break
		} else if cmd == syscall.SIGUSR1 {
			//如果为siguser1则进行dump内存
			unixtime := time.Now().Unix()
			path := "./heapdump-producer" + fmt.Sprintf("%d", unixtime)
			f, err := os.Create(path)
			if nil != err {
				continue
			} else {
				debug.WriteHeapDump(f.Fd())
			}
		}
	}

	wg.Wait()

	for _, k := range clients {
		k.Destory()
	}
}
Пример #13
0
func (self *MockListener) OnMessage(msg *protocol.QMessage) bool {
	log.Debug("MockListener|OnMessage", msg.GetHeader(), msg.GetBody())
	return true
}