func (self *SourceManager) monitorFlume() {
	for self.isRunning {
		time.Sleep(1 * time.Second)
		monitor := "FLUME_TPS|"
		for k, v := range self.sourceServers {

			succ, fail := v.monitor()
			monitor += fmt.Sprintf("%s|%d/%d \t", k, succ, fail)
		}
		log.Println(monitor)

		mk := make([]string, 0)
		monitor = "FLUME_POOL|\n"
		for k, _ := range self.hp2flumeClientPool {
			mk = append(mk, k.Host+":"+strconv.Itoa(k.Port))
		}
		sort.Strings(mk)

		for _, hp := range mk {
			v, ok := self.hp2flumeClientPool[config.NewHostPort(hp)]
			if !ok {
				continue
			}
			active, core, max := v.FlumePool.MonitorPool()
			monitor += fmt.Sprintf("%s|%d/%d/%d\n", hp, active, core, max)
		}

		log.Println(monitor)
	}
}
Example #2
0
func parseHostPort(hps string) []config.HostPort {
	hostports := make([]config.HostPort, 0)
	for _, v := range strings.Split(hps, ",") {
		hostports = append(hostports, config.NewHostPort(v))
	}

	return hostports
}
Example #3
0
func (self *SourceManager) monitorFlumePool() {

	//---------------flumepool-----------
	mk := make(map[string][]int, 0)
	hosts := make([]string, 0)
	for k, _ := range self.hp2flumeClientPool {

		ports, ok := mk[k.Host]
		if !ok {
			ports = make([]int, 0)
			hosts = append(hosts, k.Host)
		}
		ports = append(ports, k.Port)
		mk[k.Host] = ports
	}
	sort.Strings(hosts)
	for _, hp := range hosts {
		i := 0
		monitor := hp + "\n"
		ports, _ := mk[hp]
		for _, port := range ports {
			v, ok := self.hp2flumeClientPool[config.NewHostPort(hp+":"+strconv.Itoa(port))]
			if !ok {
				continue
			}

			i++
			active, core, max := v.FlumePool.MonitorPool()
			monitor += fmt.Sprintf("%d:%d/%d/%d\t", port, active, core, max)
			if i%5 == 0 {
				monitor += "\n"
			}
		}
		self.flumePoolLog.Println(monitor)
	}

}
Example #4
0
func Test_Pool(t *testing.T) {
	errs, clientPool := newFlumeClientPool(config.NewHostPort("localhost:44444"),
		10, 20, 30, 10*time.Second, func() (error, *client.FlumeClient) {
			flumeclient := client.NewFlumeClient("localhost", 44444)
			err := flumeclient.Connect()
			return err, flumeclient
		})

	idlecount := clientPool.CorePoolSize()

	log.Println(errs)

	//默认初始化10个最小连接
	if idlecount != 10 {
		t.Fail()
	}

	var err error
	checkout := list.New()
	for i := 0; i < 45; i++ {
		fclient, perr := clientPool.Get(5 * time.Second)
		if nil == perr && nil != fclient {
			checkout.PushFront(fclient)
		}

		err = perr
	}

	if nil == err {
		//达到最大的连接数后应该会报错
		t.Fail()
	}

	log.Printf("------------get |active:%d,core:%d,max:%d", clientPool.ActivePoolSize(), clientPool.CorePoolSize(), clientPool.maxPoolSize)
	//如果活动线程数等于现在持有的则成功,反则失败
	if clientPool.ActivePoolSize() != checkout.Len() {
		t.Logf("client pool |active ne checkout|%d,%d", clientPool.ActivePoolSize(), checkout.Len())
		t.Fail()
	}

	if clientPool.CorePoolSize() != clientPool.maxPoolSize {
		t.Logf("client pool |active ne checkout|%d,%d", clientPool.CorePoolSize(), checkout.Len())
		t.Fail()
	}

	func() {

		for e := checkout.Front(); nil != e; e = e.Next() {
			clientPool.Release(e.Value.(*client.FlumeClient))
		}
	}()

	log.Printf("------------release  conn |active:%d,core:%d,max:%d", clientPool.ActivePoolSize(), clientPool.CorePoolSize(), clientPool.maxPoolSize)

	for i := 0; i < 20; i++ {

		client, err := clientPool.Get(5 * time.Second)
		if nil != err {
			log.Println(err)
		} else {
			time.Sleep(2 * time.Second)
			clientPool.Release(client)
			log.Printf("test release  checkout client|active:%d,core:%d,max:%d", clientPool.ActivePoolSize(), clientPool.CorePoolSize(), clientPool.maxPoolSize)
		}
	}

	time.Sleep(5 * time.Second)
	log.Printf("end ------------active:%d,core:%d,max:%d", clientPool.ActivePoolSize(), clientPool.CorePoolSize(), clientPool.maxPoolSize)

	clientPool.Destroy()

}