Beispiel #1
0
func configMemoryRoutes() {
	http.HandleFunc("/page/memory", func(w http.ResponseWriter, r *http.Request) {
		mem, err := nux.MemInfo()
		if err != nil {
			RenderMsgJson(w, err.Error())
			return
		}

		memFree := mem.MemFree + mem.Buffers + mem.Cached
		memUsed := mem.MemTotal - memFree
		var t uint64 = 1024 * 1024
		RenderDataJson(w, []interface{}{mem.MemTotal / t, memUsed / t, memFree / t})
	})

	http.HandleFunc("/proc/memory", func(w http.ResponseWriter, r *http.Request) {
		mem, err := nux.MemInfo()
		if err != nil {
			RenderMsgJson(w, err.Error())
			return
		}

		memFree := mem.MemFree + mem.Buffers + mem.Cached
		memUsed := mem.MemTotal - memFree

		RenderDataJson(w, map[string]interface{}{
			"total": mem.MemTotal,
			"free":  memFree,
			"used":  memUsed,
		})
	})
}
Beispiel #2
0
func heartbeat(duration time.Duration) {
	mem, err := nux.MemInfo()
	if err != nil {
		log.Println("[ERROR] get meminfo:", err)
		return
	}

	// use MB
	memFree := (mem.MemFree + mem.Buffers + mem.Cached) / 1024 / 1024

	localIp := g.Config().LocalIp

	containers, err := dock.Containers(g.Config().Docker)
	if err != nil {
		log.Println("[ERROR] list containers fail:", err)

		// this node dead
		var resp model.NodeResponse
		err = g.RpcClient.Call("NodeState.NodeDown", localIp, &resp)
		if err != nil || resp.Code != 0 {
			log.Println("[ERROR] call rpc: NodeState.NodeDown fail:", err, "resp:", resp)
		} else if g.Config().Debug {
			log.Println("[INFO] call rpc: NodeState.NodeDown successfully. I am dead...")
		}

		for {
			time.Sleep(duration)
			containers, err = dock.Containers(g.Config().Docker)
			if err == nil {
				break
			} else {
				log.Println("[ERROR] list containers fail:", err)
			}
		}
	}

	req := model.NodeRequest{
		Node: model.Node{
			Ip:      localIp,
			MemFree: memFree,
		},
		Containers: containers,
	}
	var resp model.NodeResponse
	err = g.RpcClient.Call("NodeState.Push", req, &resp)
	if err != nil || resp.Code != 0 {
		log.Println("[ERROR] call rpc: NodeState.Push fail:", err, "resp:", resp)
	} else if g.Config().Debug {
		log.Println("[DEBUG] =>", req)
	}
}
Beispiel #3
0
func MemMetrics() []*model.MetricValue {
	m, err := nux.MemInfo()
	if err != nil {
		log.Println(err)
		return nil
	}

	memFree := m.MemFree + m.Buffers + m.Cached
	memUsed := m.MemTotal - memFree

	pmemFree := 0.0
	pmemUsed := 0.0
	if m.MemTotal != 0 {
		pmemFree = float64(memFree) * 100.0 / float64(m.MemTotal)
		pmemUsed = float64(memUsed) * 100.0 / float64(m.MemTotal)
	}

	pswapFree := 0.0
	pswapUsed := 0.0
	if m.SwapTotal != 0 {
		pswapFree = float64(m.SwapFree) * 100.0 / float64(m.SwapTotal)
		pswapUsed = float64(m.SwapUsed) * 100.0 / float64(m.SwapTotal)
	}

	return []*model.MetricValue{
		GaugeValue("mem.memtotal", m.MemTotal),
		GaugeValue("mem.memused", memUsed),
		GaugeValue("mem.memfree", memFree),
		GaugeValue("mem.swaptotal", m.SwapTotal),
		GaugeValue("mem.swapused", m.SwapUsed),
		GaugeValue("mem.swapfree", m.SwapFree),
		GaugeValue("mem.memfree.percent", pmemFree),
		GaugeValue("mem.memused.percent", pmemUsed),
		GaugeValue("mem.swapfree.percent", pswapFree),
		GaugeValue("mem.swapused.percent", pswapUsed),
	}

}