2016-01-27 01:45:18 +00:00
|
|
|
// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
|
|
|
|
// Use of this source code is governed by a MIT license that can
|
|
|
|
// be found in the LICENSE file.
|
|
|
|
|
2015-06-16 21:16:37 +00:00
|
|
|
// +build ignore
|
|
|
|
|
2015-06-16 20:39:24 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
2015-10-21 15:11:08 +00:00
|
|
|
"errors"
|
|
|
|
"fmt"
|
2015-06-16 20:39:24 +00:00
|
|
|
"io"
|
2015-10-21 15:11:08 +00:00
|
|
|
"os"
|
2015-06-16 20:39:24 +00:00
|
|
|
"regexp"
|
2015-10-21 15:11:08 +00:00
|
|
|
"runtime"
|
2015-06-16 20:39:24 +00:00
|
|
|
"sort"
|
|
|
|
"strconv"
|
2015-10-21 15:11:08 +00:00
|
|
|
"strings"
|
|
|
|
|
|
|
|
"github.com/gizak/termui"
|
|
|
|
"github.com/gizak/termui/extra"
|
2015-06-16 20:39:24 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
const statFilePath = "/proc/stat"
|
|
|
|
const meminfoFilePath = "/proc/meminfo"
|
|
|
|
|
|
|
|
type CpuStat struct {
|
2015-10-21 15:11:08 +00:00
|
|
|
user float32
|
|
|
|
nice float32
|
|
|
|
system float32
|
|
|
|
idle float32
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type CpusStats struct {
|
2015-10-21 15:11:08 +00:00
|
|
|
stat map[string]CpuStat
|
|
|
|
proc map[string]CpuStat
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewCpusStats(s map[string]CpuStat) *CpusStats {
|
|
|
|
return &CpusStats{stat: s, proc: make(map[string]CpuStat)}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cs *CpusStats) String() (ret string) {
|
|
|
|
for key, _ := range cs.proc {
|
|
|
|
ret += fmt.Sprintf("%s: %.2f %.2f %.2f %.2f\n", key, cs.proc[key].user, cs.proc[key].nice, cs.proc[key].system, cs.proc[key].idle)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func subCpuStat(m CpuStat, s CpuStat) CpuStat {
|
|
|
|
return CpuStat{user: m.user - s.user,
|
2015-10-21 15:11:08 +00:00
|
|
|
nice: m.nice - s.nice,
|
|
|
|
system: m.system - s.system,
|
|
|
|
idle: m.idle - s.idle}
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func procCpuStat(c CpuStat) CpuStat {
|
|
|
|
sum := c.user + c.nice + c.system + c.idle
|
2015-10-21 15:11:08 +00:00
|
|
|
return CpuStat{user: c.user / sum * 100,
|
|
|
|
nice: c.nice / sum * 100,
|
|
|
|
system: c.system / sum * 100,
|
|
|
|
idle: c.idle / sum * 100}
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (cs *CpusStats) tick(ns map[string]CpuStat) {
|
|
|
|
for key, _ := range cs.stat {
|
|
|
|
proc := subCpuStat(ns[key], cs.stat[key])
|
|
|
|
cs.proc[key] = procCpuStat(proc)
|
|
|
|
cs.stat[key] = ns[key]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type errIntParser struct {
|
|
|
|
err error
|
|
|
|
}
|
|
|
|
|
|
|
|
func (eip *errIntParser) parse(s string) (ret int64) {
|
|
|
|
if eip.err != nil {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
ret, eip.err = strconv.ParseInt(s, 10, 0)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
type LineProcessor interface {
|
|
|
|
process(string) error
|
2015-10-21 15:11:08 +00:00
|
|
|
finalize() interface{}
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type CpuLineProcessor struct {
|
|
|
|
m map[string]CpuStat
|
|
|
|
}
|
|
|
|
|
|
|
|
func (clp *CpuLineProcessor) process(line string) (err error) {
|
|
|
|
r := regexp.MustCompile("^cpu([0-9]*)")
|
|
|
|
|
|
|
|
if r.MatchString(line) {
|
|
|
|
tab := strings.Fields(line)
|
|
|
|
if len(tab) < 5 {
|
|
|
|
err = errors.New("cpu info line has not enough fields")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
parser := errIntParser{}
|
|
|
|
cs := CpuStat{user: float32(parser.parse(tab[1])),
|
2015-10-21 15:11:08 +00:00
|
|
|
nice: float32(parser.parse(tab[2])),
|
|
|
|
system: float32(parser.parse(tab[3])),
|
|
|
|
idle: float32(parser.parse(tab[4]))}
|
2015-06-16 20:39:24 +00:00
|
|
|
clp.m[tab[0]] = cs
|
|
|
|
err = parser.err
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
func (clp *CpuLineProcessor) finalize() interface{} {
|
2015-06-16 20:39:24 +00:00
|
|
|
return clp.m
|
|
|
|
}
|
|
|
|
|
|
|
|
type MemStat struct {
|
2015-10-21 15:11:08 +00:00
|
|
|
total int64
|
|
|
|
free int64
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ms MemStat) String() (ret string) {
|
|
|
|
ret = fmt.Sprintf("TotalMem: %d, FreeMem: %d\n", ms.total, ms.free)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ms *MemStat) process(line string) (err error) {
|
|
|
|
rtotal := regexp.MustCompile("^MemTotal:")
|
|
|
|
rfree := regexp.MustCompile("^MemFree:")
|
|
|
|
var aux int64
|
|
|
|
if rtotal.MatchString(line) || rfree.MatchString(line) {
|
|
|
|
tab := strings.Fields(line)
|
|
|
|
if len(tab) < 3 {
|
|
|
|
err = errors.New("mem info line has not enough fields")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
aux, err = strconv.ParseInt(tab[1], 10, 0)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if rtotal.MatchString(line) {
|
|
|
|
ms.total = aux
|
|
|
|
}
|
|
|
|
if rfree.MatchString(line) {
|
|
|
|
ms.free = aux
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
func (ms *MemStat) finalize() interface{} {
|
2015-06-16 20:39:24 +00:00
|
|
|
return *ms
|
|
|
|
}
|
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
func processFileLines(filePath string, lp LineProcessor) (ret interface{}, err error) {
|
2015-06-16 20:39:24 +00:00
|
|
|
var statFile *os.File
|
|
|
|
statFile, err = os.Open(filePath)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("open: %v\n", err)
|
|
|
|
}
|
|
|
|
defer statFile.Close()
|
|
|
|
|
|
|
|
statFileReader := bufio.NewReader(statFile)
|
|
|
|
|
|
|
|
for {
|
|
|
|
var line string
|
|
|
|
line, err = statFileReader.ReadString('\n')
|
|
|
|
if err == io.EOF {
|
|
|
|
err = nil
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("open: %v\n", err)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
line = strings.TrimSpace(line)
|
|
|
|
|
|
|
|
err = lp.process(line)
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = lp.finalize()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func getCpusStatsMap() (m map[string]CpuStat, err error) {
|
2015-10-21 15:11:08 +00:00
|
|
|
var aux interface{}
|
2015-06-16 20:39:24 +00:00
|
|
|
aux, err = processFileLines(statFilePath, &CpuLineProcessor{m: make(map[string]CpuStat)})
|
|
|
|
return aux.(map[string]CpuStat), err
|
|
|
|
}
|
|
|
|
|
|
|
|
func getMemStats() (ms MemStat, err error) {
|
2015-10-21 15:11:08 +00:00
|
|
|
var aux interface{}
|
2015-06-16 20:39:24 +00:00
|
|
|
aux, err = processFileLines(meminfoFilePath, &MemStat{})
|
|
|
|
return aux.(MemStat), err
|
|
|
|
}
|
|
|
|
|
|
|
|
type CpuTabElems struct {
|
2015-10-21 15:11:08 +00:00
|
|
|
GMap map[string]*termui.Gauge
|
2015-06-16 20:39:24 +00:00
|
|
|
LChart *termui.LineChart
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewCpuTabElems(width int) *CpuTabElems {
|
|
|
|
lc := termui.NewLineChart()
|
|
|
|
lc.Width = width
|
|
|
|
lc.Height = 12
|
|
|
|
lc.X = 0
|
|
|
|
lc.Mode = "dot"
|
2016-10-14 11:48:50 +00:00
|
|
|
lc.BorderLabel = "CPU"
|
2015-06-16 20:39:24 +00:00
|
|
|
return &CpuTabElems{GMap: make(map[string]*termui.Gauge),
|
2015-10-21 15:11:08 +00:00
|
|
|
LChart: lc}
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (cte *CpuTabElems) AddGauge(key string, Y int, width int) *termui.Gauge {
|
|
|
|
cte.GMap[key] = termui.NewGauge()
|
|
|
|
cte.GMap[key].Width = width
|
|
|
|
cte.GMap[key].Height = 3
|
|
|
|
cte.GMap[key].Y = Y
|
2016-10-14 11:48:50 +00:00
|
|
|
cte.GMap[key].BorderLabel = key
|
2015-10-21 15:11:08 +00:00
|
|
|
cte.GMap[key].Percent = 0 //int(val.user + val.nice + val.system)
|
2015-06-16 20:39:24 +00:00
|
|
|
return cte.GMap[key]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cte *CpuTabElems) Update(cs CpusStats) {
|
|
|
|
for key, val := range cs.proc {
|
|
|
|
p := int(val.user + val.nice + val.system)
|
|
|
|
cte.GMap[key].Percent = p
|
|
|
|
if key == "cpu" {
|
|
|
|
cte.LChart.Data = append(cte.LChart.Data, 0)
|
|
|
|
copy(cte.LChart.Data[1:], cte.LChart.Data[0:])
|
|
|
|
cte.LChart.Data[0] = float64(p)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type MemTabElems struct {
|
2015-10-21 15:11:08 +00:00
|
|
|
Gauge *termui.Gauge
|
2015-06-16 20:39:24 +00:00
|
|
|
SLines *termui.Sparklines
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewMemTabElems(width int) *MemTabElems {
|
|
|
|
g := termui.NewGauge()
|
|
|
|
g.Width = width
|
|
|
|
g.Height = 3
|
|
|
|
g.Y = 0
|
|
|
|
|
|
|
|
sline := termui.NewSparkline()
|
|
|
|
sline.Title = "MEM"
|
|
|
|
sline.Height = 8
|
|
|
|
|
|
|
|
sls := termui.NewSparklines(sline)
|
|
|
|
sls.Width = width
|
|
|
|
sls.Height = 12
|
|
|
|
sls.Y = 3
|
|
|
|
return &MemTabElems{Gauge: g, SLines: sls}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mte *MemTabElems) Update(ms MemStat) {
|
|
|
|
used := int((ms.total - ms.free) * 100 / ms.total)
|
|
|
|
mte.Gauge.Percent = used
|
|
|
|
mte.SLines.Lines[0].Data = append(mte.SLines.Lines[0].Data, 0)
|
|
|
|
copy(mte.SLines.Lines[0].Data[1:], mte.SLines.Lines[0].Data[0:])
|
|
|
|
mte.SLines.Lines[0].Data[0] = used
|
|
|
|
if len(mte.SLines.Lines[0].Data) > mte.SLines.Width-2 {
|
2015-10-21 15:11:08 +00:00
|
|
|
mte.SLines.Lines[0].Data = mte.SLines.Lines[0].Data[0 : mte.SLines.Width-2]
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func main() {
|
|
|
|
if runtime.GOOS != "linux" {
|
|
|
|
panic("Currently works only on Linux")
|
|
|
|
}
|
2015-10-21 15:11:08 +00:00
|
|
|
err := termui.Init()
|
|
|
|
if err != nil {
|
2015-06-16 20:39:24 +00:00
|
|
|
panic(err)
|
|
|
|
}
|
2015-10-21 15:11:08 +00:00
|
|
|
defer termui.Close()
|
2015-06-16 20:39:24 +00:00
|
|
|
|
|
|
|
termWidth := 70
|
|
|
|
|
2016-11-03 05:41:47 +00:00
|
|
|
//termui.UseTheme("helloworld")
|
2015-06-16 20:39:24 +00:00
|
|
|
|
|
|
|
header := termui.NewPar("Press q to quit, Press j or k to switch tabs")
|
|
|
|
header.Height = 1
|
|
|
|
header.Width = 50
|
2016-11-03 05:41:47 +00:00
|
|
|
header.Border = false
|
2015-06-16 20:39:24 +00:00
|
|
|
header.TextBgColor = termui.ColorBlue
|
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
tabCpu := extra.NewTab("CPU")
|
|
|
|
tabMem := extra.NewTab("MEM")
|
2015-06-16 20:39:24 +00:00
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
tabpane := extra.NewTabpane()
|
2015-06-16 20:39:24 +00:00
|
|
|
tabpane.Y = 1
|
2015-10-21 15:11:08 +00:00
|
|
|
tabpane.Width = 30
|
2016-11-03 05:41:47 +00:00
|
|
|
tabpane.Border = false
|
2015-06-16 20:39:24 +00:00
|
|
|
|
|
|
|
cs, errcs := getCpusStatsMap()
|
|
|
|
cpusStats := NewCpusStats(cs)
|
|
|
|
|
|
|
|
if errcs != nil {
|
|
|
|
panic("error")
|
|
|
|
}
|
|
|
|
|
|
|
|
cpuTabElems := NewCpuTabElems(termWidth)
|
|
|
|
|
|
|
|
Y := 0
|
|
|
|
cpuKeys := make([]string, 0, len(cs))
|
|
|
|
for key := range cs {
|
|
|
|
cpuKeys = append(cpuKeys, key)
|
|
|
|
}
|
|
|
|
sort.Strings(cpuKeys)
|
|
|
|
for _, key := range cpuKeys {
|
|
|
|
g := cpuTabElems.AddGauge(key, Y, termWidth)
|
|
|
|
Y += 3
|
|
|
|
tabCpu.AddBlocks(g)
|
|
|
|
}
|
|
|
|
cpuTabElems.LChart.Y = Y
|
|
|
|
tabCpu.AddBlocks(cpuTabElems.LChart)
|
|
|
|
|
|
|
|
memTabElems := NewMemTabElems(termWidth)
|
|
|
|
ms, errm := getMemStats()
|
|
|
|
if errm != nil {
|
|
|
|
panic(errm)
|
|
|
|
}
|
|
|
|
memTabElems.Update(ms)
|
|
|
|
tabMem.AddBlocks(memTabElems.Gauge)
|
|
|
|
tabMem.AddBlocks(memTabElems.SLines)
|
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
tabpane.SetTabs(*tabCpu, *tabMem)
|
2015-06-16 20:39:24 +00:00
|
|
|
|
2015-10-21 15:11:08 +00:00
|
|
|
termui.Render(header, tabpane)
|
2015-06-16 20:39:24 +00:00
|
|
|
|
2016-11-03 05:41:47 +00:00
|
|
|
termui.Handle("/sys/kbd/q", func(termui.Event) {
|
|
|
|
termui.StopLoop()
|
|
|
|
})
|
|
|
|
|
|
|
|
termui.Handle("/sys/kbd/j", func(termui.Event) {
|
|
|
|
tabpane.SetActiveLeft()
|
|
|
|
termui.Render(header, tabpane)
|
|
|
|
})
|
|
|
|
|
|
|
|
termui.Handle("/sys/kbd/k", func(termui.Event) {
|
|
|
|
tabpane.SetActiveRight()
|
|
|
|
termui.Render(header, tabpane)
|
|
|
|
})
|
|
|
|
|
|
|
|
termui.Handle("/timer/1s", func(e termui.Event) {
|
|
|
|
cs, errcs := getCpusStatsMap()
|
|
|
|
if errcs != nil {
|
|
|
|
panic(errcs)
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|
2016-11-03 05:41:47 +00:00
|
|
|
cpusStats.tick(cs)
|
|
|
|
cpuTabElems.Update(*cpusStats)
|
|
|
|
|
|
|
|
ms, errm := getMemStats()
|
|
|
|
if errm != nil {
|
|
|
|
panic(errm)
|
|
|
|
}
|
|
|
|
memTabElems.Update(ms)
|
|
|
|
termui.Render(header, tabpane)
|
|
|
|
})
|
|
|
|
|
|
|
|
termui.Loop()
|
2015-06-16 20:39:24 +00:00
|
|
|
}
|