Example #1
0
func (m *Master) recHeartbeatEvt() {
	var nextDur time.Duration
	nowSec := time.Now().Second()
	if nowSec > 30 {
		nextDur = time.Duration(90-nowSec) * time.Second
	} else {
		nextDur = time.Duration(30-nowSec) * time.Second
	}

	t1 := time.NewTimer(nextDur)
	for {
		select {
		case <-t1.C:
			catInst := cat.Instance()
			tran := catInst.NewTransaction("System", "Status")
			h := catInst.NewHeartbeat("HeartBeat", util.GetIP())
			combineHeartbeat(h, strconv.Itoa(m.port), heartbeatValues{mapValues: util.GetStatus(), urlValues: nil})
			for _, w := range m.workers {
				combineHeartbeat(h, strconv.Itoa(w.host.GetPort()), w.heartbeatInfo)
			}
			h.SetStatus("0")
			h.Complete()
			tran.SetStatus("0")
			tran.Complete()
			t1.Reset(time.Duration(time.Minute))
		}
	}
}
Example #2
0
func LogHeartbeat() {
	defer func() {
		if err := recover(); err != nil {
			//log.Error(fmt.Sprintf("%v", err))
			LogHeartbeat()
		}
	}()

	ip := util.GetIP()
	second := time.Now().Second()
	if second < 29 {
		sleep := time.Duration((29 - second) * 1000000000)
		time.Sleep(sleep)
	}

	catinstance := cat.Instance()
	for {
		//log.Debug("send cat heartbeat")
		stats := util.GetStatus()
		tran := catinstance.NewTransaction("System", "Status")
		h := catinstance.NewHeartbeat("HeartBeat", ip)
		for key, value := range stats {
			switch key {
			case "Alloc", "TotalAlloc", "Sys", "Mallocs", "Frees", "OtherSys", "PauseNs":
				h.Set("System", key, value)
			case "HeapAlloc", "HeapSys", "HeapIdle", "HeapInuse", "HeapReleased", "HeapObjects":
				h.Set("HeapUsage", key, value)
			case "NextGC", "LastGC", "NumGC":
				h.Set("GC", key, value)
			}
		}
		h.SetStatus("0")
		h.Complete()
		tran.SetStatus("0")
		tran.Complete()
		second = time.Now().Second()
		sleep := time.Duration((90 - second) * 1000000000)
		time.Sleep(sleep)
	}
}
Example #3
0
func (this *SubProcessor) sendStatus() {
	defer func() {
		if p := recover(); p != nil {
			log.WithFields(log.Fields{
				"port": this.Port,
				"type": "Worker.SendStatusPanic",
			}).Error(fmt.Sprintf("%v", p))
			LogErrorEvent(CatInstance, "Worker.SendStatusPanic", fmt.Sprintf("%v", p))
			this.sendStatus()

		}
	}()
	for {
		time.Sleep(10 * time.Second)
		uri := JoinString("http://localhost:", this.HostPort, "/heartbeat/")
		log.WithFields(log.Fields{
			"port": this.Port,
			"uri":  uri,
		}).Debug("begin send status")
		status := util.GetStatus()
		data := url.Values{}
		data.Add("port", this.Port)
		for k, v := range status {
			data.Add(k, v)
		}
		_, err := PostHttp(uri, data)
		if err != nil {
			// handle error
			log.WithFields(log.Fields{
				"port": this.Port,
				"type": "Worker.SendStatusError",
			}).Error(err.Error())
			LogErrorEvent(CatInstance, "Worker.SendStatusError", err.Error())
		}
	}
}
Example #4
0
func (this *HostProcessor) sendCatHeartBeat() {
	defer func() {
		if err := recover(); err != nil {
			log.Error(fmt.Sprintf("%v", err))
			this.sendCatHeartBeat()
		}
	}()
	ip := GetIP()
	second := time.Now().Second()
	if second < 29 {
		sleep := time.Duration((29 - second) * 1000000000)
		time.Sleep(sleep)
	}

	catinstance := cat.Instance()
	for {
		log.Debug("send cat heartbeat")
		stats1 := util.GetStatus()
		data := url.Values{}
		data.Add("port", hostPort)
		for k, v := range stats1 {
			data.Add(k, v)
		}
		portstats[hostPort] = data

		tran := catinstance.NewTransaction("System", "Status")
		h := catinstance.NewHeartbeat("HeartBeat", ip)
		for _, heart := range portstats {
			if heart == nil {
				continue
			}
			port := heart.Get("port")
			if port == "" {
				continue
			}
			h.Set("System", JoinString("Alloc_", port), heart.Get("Alloc"))
			h.Set("System", JoinString("TotalAlloc_", port), heart.Get("TotalAlloc"))
			h.Set("System", JoinString("Sys_", port), heart.Get("Sys"))
			h.Set("System", JoinString("Mallocs_", port), heart.Get("Mallocs"))
			h.Set("System", JoinString("Frees_", port), heart.Get("Frees"))
			h.Set("System", JoinString("OtherSys_", port), heart.Get("OtherSys"))
			h.Set("System", JoinString("PauseNs_", port), heart.Get("PauseNs"))

			h.Set("HeapUsage", JoinString("HeapAlloc_", port), heart.Get("HeapAlloc"))
			h.Set("HeapUsage", JoinString("HeapSys_", port), heart.Get("HeapSys"))
			h.Set("HeapUsage", JoinString("HeapIdle_", port), heart.Get("HeapIdle"))
			h.Set("HeapUsage", JoinString("HeapInuse_", port), heart.Get("HeapInuse"))
			h.Set("HeapUsage", JoinString("HeapReleased_", port), heart.Get("HeapReleased"))
			h.Set("HeapUsage", JoinString("HeapObjects_", port), heart.Get("HeapObjects"))

			h.Set("GC", JoinString("NextGC_", port), heart.Get("NextGC"))
			h.Set("GC", JoinString("LastGC_", port), heart.Get("LastGC"))
			h.Set("GC", JoinString("NumGC_", port), heart.Get("NumGC"))
			portstats[port] = nil
		}
		h.SetStatus("0")
		h.Complete()
		tran.SetStatus("0")
		tran.Complete()
		second = time.Now().Second()
		sleep := time.Duration((90 - second) * 1000000000)
		time.Sleep(sleep)
	}
}