/**
read node resource usage
**/
func GetNodeResource(w http.ResponseWriter, r *http.Request) {
// get this node memory
memory, _ := mem.VirtualMemory()
// get this node cpu percent usage
cpu_percent, _ := cpu.CPUPercent(time.Duration(1)*time.Second, false)
// Disk mount Point
disk_partitions, _ := disk.DiskPartitions(true)
// Disk usage
var disk_usages []*disk.DiskUsageStat
for _, disk_partition := range disk_partitions {
if disk_partition.Mountpoint == "/" || disk_partition.Mountpoint == "/home" {
disk_stat, _ := disk.DiskUsage(disk_partition.Device)
disk_usages = append(disk_usages, disk_stat)
}
}
// Network
network, _ := net.NetIOCounters(false)
// create new node obj with resource usage information
node_metric := thoth.NodeMetric{
Cpu: cpu_percent,
Memory: memory,
DiskUsage: disk_usages,
Network: network,
}
node_json, err := json.MarshalIndent(node_metric, "", "\t")
if err != nil {
fmt.Println("error:", err)
}
fmt.Fprint(w, string(node_json))
}
func jsonDiskInfo() []byte {
type DiskStat struct {
Partition disk.DiskPartitionStat
Usage disk.DiskUsageStat
Counters disk.DiskIOCountersStat
}
var disks []DiskStat
partitions, _ := disk.DiskPartitions(false)
c := &DiskStat{}
IOCounters, _ := disk.DiskIOCounters()
for _, singleDisk := range partitions {
if !strings.HasPrefix(singleDisk.Device, "/") {
continue
}
usage, _ := disk.DiskUsage(singleDisk.Mountpoint)
c.Partition = singleDisk
c.Usage = *usage
c.Counters = IOCounters[strings.Split(singleDisk.Device, "/")[2]]
disks = append(disks, *c)
}
jsonPartitions, _ := json.Marshal(disks)
return jsonPartitions
}
func updateDisk() {
disks, err = disk.DiskPartitions(true)
log.Printf("updateDisk(): %v", spew.Sdump(disks))
if err != nil {
log.Fatal(err)
}
disksUsage, err = disk.DiskUsage("/")
log.Printf("updateDisk(): %v", spew.Sdump(disksUsage))
if err != nil {
log.Fatal(err)
}
}
// DiskUsage - return a list with disk usage structs
func DiskUsage() (DiskUsageList, error) {
parts, err := disk.DiskPartitions(false)
if err != nil {
diskLogger.Errorf("Error getting disk usage info: %v", err)
}
var usage DiskUsageList
for _, p := range parts {
if _, err := os.Stat(p.Mountpoint); err == nil {
du, err := disk.DiskUsage(p.Mountpoint)
if err != nil {
diskLogger.Errorf("Error getting disk usage for Mount: %v", err)
}
if !isPseudoFS(du.Fstype) && !removableFs(du.Path) {
TotalMB, _ := util.ConvertBytesTo(du.Total, "mb", 0)
FreeMB, _ := util.ConvertBytesTo(du.Free, "mb", 0)
UsedMB, _ := util.ConvertBytesTo(du.Used, "mb", 0)
UsedPercent := 0.0
if TotalMB > 0 && UsedMB > 0 {
UsedPercent = (float64(du.Used) / float64(du.Total)) * 100.0
UsedPercent, _ = util.FloatDecimalPoint(UsedPercent, 2)
DeviceName := strings.Replace(p.Device, "/dev/", "", -1)
TotalMBFormatted, _ := util.FloatToString(TotalMB)
FreeMBFormatted, _ := util.FloatToString(FreeMB)
UsedMBFormatted, _ := util.FloatToString(UsedMB)
d := DiskUsageStruct{
Name: DeviceName,
Path: du.Path,
Fstype: du.Fstype,
Total: TotalMBFormatted,
Free: FreeMBFormatted,
Used: UsedMBFormatted,
UsedPercent: UsedPercent,
}
usage = append(usage, d)
}
}
}
}
return usage, err
}
func (s *systemPS) DiskUsage(
mountPointFilter []string,
fstypeExclude []string,
) ([]*disk.DiskUsageStat, error) {
parts, err := disk.DiskPartitions(true)
if err != nil {
return nil, err
}
// Make a "set" out of the filter slice
mountPointFilterSet := make(map[string]bool)
for _, filter := range mountPointFilter {
mountPointFilterSet[filter] = true
}
fstypeExcludeSet := make(map[string]bool)
for _, filter := range fstypeExclude {
fstypeExcludeSet[filter] = true
}
var usage []*disk.DiskUsageStat
for _, p := range parts {
if len(mountPointFilter) > 0 {
// If the mount point is not a member of the filter set,
// don't gather info on it.
_, ok := mountPointFilterSet[p.Mountpoint]
if !ok {
continue
}
}
if _, err := os.Stat(p.Mountpoint); err == nil {
du, err := disk.DiskUsage(p.Mountpoint)
if err != nil {
return nil, err
}
// If the mount point is a member of the exclude set,
// don't gather info on it.
_, ok := fstypeExcludeSet[p.Fstype]
if ok {
continue
}
du.Fstype = p.Fstype
usage = append(usage, du)
}
}
return usage, nil
}
// Run gathers partition information from gopsutil.
func (d *DiskPartitions) Run() error {
dataSlice, err := gopsutil_disk.DiskPartitions(true)
if err != nil {
return err
}
d.Data["PartitionsByDevice"] = make(map[string]gopsutil_disk.DiskPartitionStat)
d.Data["PartitionsByMount"] = make(map[string]gopsutil_disk.DiskPartitionStat)
for _, data := range dataSlice {
d.Data["PartitionsByDevice"][data.Device] = data
d.Data["PartitionsByMount"][data.Mountpoint] = data
}
return nil
}
func initDiskInfo(monitorData *monitoringData) error {
partitions, err := disk.DiskPartitions(true)
monitorData.DiskStats = make(map[string]disk.DiskUsageStat)
if err == nil {
for d := range partitions {
if partitions[d].Device != "none" {
usage, _ := disk.DiskUsage(partitions[d].Mountpoint)
if usage != nil {
if !math.IsNaN(usage.UsedPercent) {
monitorData.DiskStats[partitions[d].Device] = *usage
}
}
}
}
}
return err
}
func (s *systemPS) DiskUsage() ([]*disk.DiskUsageStat, error) {
parts, err := disk.DiskPartitions(true)
if err != nil {
return nil, err
}
var usage []*disk.DiskUsageStat
for _, p := range parts {
if _, err := os.Stat(p.Mountpoint); err == nil {
du, err := disk.DiskUsage(p.Mountpoint)
if err != nil {
return nil, err
}
du.Fstype = p.Fstype
usage = append(usage, du)
}
}
return usage, nil
}
func getDiskUsage() (total uint64, used uint64, usedPercent float64, err error) {
if partitions, pErr := disk.DiskPartitions(true); pErr == nil {
for _, partition := range partitions {
if diskStat, statErr := disk.DiskUsage(partition.Mountpoint); statErr == nil {
total += diskStat.Total
used += diskStat.Used
} else {
log.Error("Failed to get diskStat:", statErr)
err = statErr
}
}
if total > 0 {
usedPercent = float64(used) / float64(total) * 100
}
} else {
log.Error("Failed to get partitions:", pErr)
err = pErr
}
return
}
func main() {
// DISK INFO
fmt.Print("\n----Disk Info ----\n\n")
diskInfo, err := disk.DiskPartitions(true)
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", diskInfo)
for _, diskn := range diskInfo {
fmt.Printf("%s %s\n", diskn.Device, diskn.Mountpoint)
}
// CPU INFO
fmt.Print("\n----CPU Info ----\n\n")
cpuInfo, err := cpu.CPUInfo()
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", cpuInfo)
var totalCores int32
var frequency float64
var totalCompute float64
var flags string
for _, cpu := range cpuInfo {
totalCores += cpu.Cores
if frequency == 0 {
frequency = cpu.Mhz
} else {
if frequency != cpu.Mhz {
log.Printf("A CPU shows inconsistent frequency with other CPUs: baseline %f, abberant %f", frequency, frequency)
}
}
flags = strings.Join(cpu.Flags, " ")
}
totalCompute = frequency * float64(totalCores)
fmt.Printf("%s %d\n", "cpu.totalcores", totalCores)
fmt.Printf("%s %d\n", "cpu.numcpus", len(cpuInfo))
fmt.Printf("%s %f\n", "cpu.frequency", frequency)
fmt.Printf("%s %f\n", "cpu.totalcompute", totalCompute)
fmt.Printf("%s %s\n", "cpu.flags", flags)
// MEMORY INFO
fmt.Print("\n----Memory Info ----\n\n")
memInfo, err := mem.VirtualMemory()
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", memInfo)
fmt.Printf("%s %d\n", "memory.totalbytes", memInfo.Total)
// HOST INFO
fmt.Print("\n----Host Info ----\n\n")
hostInfo, err := host.HostInfo()
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", hostInfo)
fmt.Printf("%s %s\n", "hostInfo.Hostname ", hostInfo.Hostname)
fmt.Printf("%s %s\n", "hostInfo.OS ", hostInfo.OS)
fmt.Printf("%s %s\n", "hostInfo.Platform ", hostInfo.Platform)
fmt.Printf("%s %s\n", "hostInfo.PlatformVersion", hostInfo.PlatformVersion)
fmt.Printf("%s %s\n", "hostInfo.PlatformFamily ", hostInfo.PlatformFamily)
}
func (st *Stat) stat(t string) string {
checkErr := func(err error) string {
return "系统酱正在食用作死药丸中..."
}
switch t {
case "free":
m, err := mem.VirtualMemory()
checkErr(err)
s, err := mem.SwapMemory()
checkErr(err)
mem := new(runtime.MemStats)
runtime.ReadMemStats(mem)
return fmt.Sprintf(
"全局:\n"+
"Total: %s Free: %s\nUsed: %s %s%%\nCache: %s\n"+
"Swap:\nTotal: %s Free: %s\n Used: %s %s%%\n"+
"群组娘:\n"+
"Allocated: %s\nTotal Allocated: %s\nSystem: %s\n",
helper.HumanByte(m.Total, m.Free, m.Used, m.UsedPercent, m.Cached,
s.Total, s.Free, s.Used, s.UsedPercent,
mem.Alloc, mem.TotalAlloc, mem.Sys)...,
)
case "df":
fs, err := disk.DiskPartitions(false)
checkErr(err)
var buf bytes.Buffer
for k := range fs {
du, err := disk.DiskUsage(fs[k].Mountpoint)
switch {
case err != nil, du.UsedPercent == 0, du.Free == 0:
continue
}
f := fmt.Sprintf("Mountpoint: %s Type: %s \n"+
"Total: %s Free: %s \nUsed: %s %s%%\n",
helper.HumanByte(fs[k].Mountpoint, fs[k].Fstype,
du.Total, du.Free, du.Used, du.UsedPercent)...,
)
buf.WriteString(f)
}
return buf.String()
case "os":
h, err := host.HostInfo()
checkErr(err)
uptime := time.Duration(time.Now().Unix()-int64(h.Uptime)) * time.Second
l, err := load.LoadAvg()
checkErr(err)
c, err := cpu.CPUPercent(time.Second*3, false)
checkErr(err)
return fmt.Sprintf(
"OSRelease: %s\nHostName: %s\nUptime: %s\nLoadAvg: %.2f %.2f %.2f\n"+
"Goroutine: %d\nCPU: %.2f%%",
h.Platform, h.Hostname, uptime.String(), l.Load1, l.Load5, l.Load15,
runtime.NumGoroutine(), c[0],
)
case "redis":
info := conf.Redis.Info().Val()
if info != "" {
infos := strings.Split(info, "\r\n")
infoMap := make(map[string]string)
for k := range infos {
line := strings.Split(infos[k], ":")
if len(line) > 1 {
infoMap[line[0]] = line[1]
}
}
DBSize := conf.Redis.DbSize().Val()
return fmt.Sprintf("Redis Version: %s\nOS: %s\nUsed Memory: %s\n"+
"Used Memory Peak: %s\nDB Size: %d\n",
infoMap["redis_version"], infoMap["os"], infoMap["used_memory_human"],
infoMap["used_memory_peak_human"], DBSize)
}
return ""
default:
return "欢迎来到未知领域(ゝ∀･)"
}
}
func json_diskpartitions(w http.ResponseWriter, r *http.Request) {
diskinfo, _ := disk.DiskPartitions(true)
b, _ := json.Marshal(diskinfo)
w.Header().Set("Content-Type", "application/json")
fmt.Fprintf(w, string(b))
}