You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
478 lines
9.9 KiB
478 lines
9.9 KiB
/*
|
|
* System info
|
|
*/
|
|
package helper
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"os/exec"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
func CpuUsage() string {
|
|
cmd := exec.Command("ps", "aux")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
|
|
var all float64
|
|
for {
|
|
line, err := out.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
tokens := strings.Split(line, " ")
|
|
ft := make([]string, 0)
|
|
for _, t := range tokens {
|
|
if t != "" && t != "\t" {
|
|
ft = append(ft, t)
|
|
}
|
|
}
|
|
|
|
if ft[2] == "%CPU" {
|
|
continue
|
|
}
|
|
cpu, err := strconv.ParseFloat(ft[2], 64)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
all += cpu
|
|
}
|
|
return fmt.Sprintf("%.2f", all)
|
|
}
|
|
|
|
/*
|
|
* disk usage of path/disk
|
|
*/
|
|
//func DiskUsage(path string) map[string]string {
|
|
// mDisk := make(map[string]string)
|
|
// sFs := syscall.Statfs_t{}
|
|
// Err := syscall.Statfs(path, &sFs)
|
|
// if Err != nil {
|
|
// log.Println("ERROR", "170060|查询磁盘使用情况出错", Err.Error())
|
|
// return mDisk
|
|
// }
|
|
// All := sFs.Blocks * uint64(sFs.Bsize) / 1024 / 1024
|
|
// Free := sFs.Bfree * uint64(sFs.Bsize) / 1024 / 1024
|
|
// mDisk["All"] = strconv.FormatUint(All, 10)
|
|
// mDisk["Free"] = strconv.FormatUint(Free, 10)
|
|
// mDisk["Used"] = strconv.FormatUint((All - Free), 10)
|
|
// return mDisk
|
|
//}
|
|
|
|
//func MemStat() map[string]string {
|
|
// //系统占用,仅linux/mac下有效
|
|
// //system memory usage
|
|
// mMem := make(map[string]string)
|
|
// sysInfo := new(syscall.Sysinfo_t)
|
|
// Err := syscall.Sysinfo(sysInfo)
|
|
// if Err == nil {
|
|
// All := sysInfo.Totalram / 1024 / 1024
|
|
// Free := sysInfo.Freeram / 1024 / 1024
|
|
// Swap := sysInfo.Totalswap / 1024 / 1024
|
|
// SwapFree := sysInfo.Freeswap / 1024 / 1024
|
|
// mMem["All"] = strconv.FormatUint(All, 10) //* uint64(syscall.Getpagesize())
|
|
// mMem["Free"] = strconv.FormatUint(Free, 10) //* uint64(syscall.Getpagesize())
|
|
// mMem["Used"] = strconv.FormatUint(All-Free, 10)
|
|
// mMem["Swap"] = strconv.FormatUint(Swap, 10)
|
|
// mMem["SwapFree"] = strconv.FormatUint(SwapFree, 10)
|
|
// mMem["SwapUsed"] = strconv.FormatUint(Swap-SwapFree, 10)
|
|
// day := sysInfo.Uptime / 86400
|
|
// hour := sysInfo.Uptime % 86400 / 3600
|
|
// minute := sysInfo.Uptime % 86400 % 3600 / 60
|
|
// tTime := time.Now().Unix() - sysInfo.Uptime
|
|
// tNow := time.Unix(tTime, 10)
|
|
// mMem["StartTime"] = tNow.Format("2006") + "-" + tNow.Format("01") + "-" + tNow.Format("02") + " " + tNow.Format("15") + ":" + tNow.Format("04") + ":" + tNow.Format("05")
|
|
// mMem["Runtime"] = strconv.FormatInt(day, 10) + "天" + strconv.FormatInt(hour, 10) + "小时" + strconv.FormatInt(minute, 10) + "分钟"
|
|
//
|
|
// } else {
|
|
// log.Println("ERROR", "170060|查询内存使用情况出错", Err.Error())
|
|
// }
|
|
// return mMem
|
|
//}
|
|
|
|
|
|
/**
|
|
* IO读写
|
|
*/
|
|
func IoUsage() map[string]string {
|
|
cmd := exec.Command("iostat")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
mIo := make(map[string]string)
|
|
if err != nil {
|
|
log.Println("ERROR", "170061|系统命令iostat 执行错误", err.Error())
|
|
return mIo
|
|
}
|
|
for {
|
|
line, err := out.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
tokens := strings.Split(line, " ")
|
|
ft := make([]string, 0)
|
|
for _, t := range tokens {
|
|
if t != "" && t != "\t" {
|
|
fi := strings.Trim(t, "\n\t")
|
|
ft = append(ft, fi)
|
|
}
|
|
}
|
|
if ft[0] == "sda" {
|
|
mIo["ReadSpd"] = ft[2]
|
|
mIo["WriteSpd"] = ft[3]
|
|
mIo["Read"] = ft[4]
|
|
mIo["Write"] = ft[5]
|
|
}
|
|
}
|
|
return mIo
|
|
}
|
|
|
|
/**
|
|
*文件系统使用率
|
|
*/
|
|
|
|
func FileUsage() []interface{} {
|
|
cmd := exec.Command("df", "-h")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
mList := make([]interface{}, 0)
|
|
if err != nil {
|
|
log.Println("ERROR", "170061|系统命令df -h执行错误", err.Error())
|
|
return mList
|
|
}
|
|
var mRet map[string]string
|
|
for {
|
|
line, err := out.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
tokens := strings.Split(line, " ")
|
|
ft := make([]string, 0)
|
|
for _, t := range tokens {
|
|
if t != "" && t != "\t" {
|
|
fi := strings.Trim(t, "\n\t")
|
|
ft = append(ft, fi)
|
|
}
|
|
}
|
|
if ft[0] != "Filesystem" {
|
|
mRet = make(map[string]string)
|
|
mRet["FileSystem"] = ft[0]
|
|
mRet["All"] = ft[1]
|
|
mRet["Used"] = ft[2]
|
|
mRet["Free"] = ft[3]
|
|
mRet["UsePercent"] = ft[4]
|
|
mRet["Mounted"] = ft[5]
|
|
mList = append(mList, mRet)
|
|
}
|
|
}
|
|
return mList
|
|
}
|
|
|
|
/**
|
|
*系统负载1 5 10 分钟
|
|
*/
|
|
func LoadAverage() map[string]string {
|
|
|
|
cmd := exec.Command("uptime")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
mRet := make(map[string]string)
|
|
|
|
if err != nil {
|
|
log.Println("ERROR", "170061|系统命令uptime执行错误", err.Error())
|
|
return mRet
|
|
}
|
|
|
|
sLine, err := out.ReadString('\n')
|
|
|
|
if err != nil {
|
|
log.Println("ERROR", "170060|读取系统负载数据出错", err.Error())
|
|
return mRet
|
|
}
|
|
//正则表达获取1 5 15 分钟系统负载数据
|
|
sRegs := "\\d+\\.\\d+"
|
|
|
|
sReg := regexp.MustCompile(sRegs)
|
|
|
|
sLoadAverage := sReg.FindAllString(sLine, 3)
|
|
|
|
if len(sLoadAverage) >= 3 {
|
|
mRet["OneMin"] = sLoadAverage[0]
|
|
|
|
mRet["FivMin"] = sLoadAverage[1]
|
|
|
|
mRet["TenfivMin"] = sLoadAverage[2]
|
|
} else {
|
|
return mRet
|
|
}
|
|
return mRet
|
|
}
|
|
|
|
/**
|
|
*网卡使用情况
|
|
*/
|
|
func NetUsage() []interface{} {
|
|
|
|
var Net struct {
|
|
NetCard string
|
|
Rbytes string
|
|
Rpackets string
|
|
Rerrors string
|
|
Rpck string
|
|
Sbytes string
|
|
Spackets string
|
|
Serrors string
|
|
Spck string
|
|
}
|
|
cmd := exec.Command("ifconfig")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
aNetList := make([]interface{}, 0)
|
|
if err != nil {
|
|
log.Println("ERROR", "170060|查询网卡使用情况出错", err.Error())
|
|
return aNetList
|
|
}
|
|
for {
|
|
line, err := out.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
tokens := strings.Split(line, " ")
|
|
ft := make([]string, 0)
|
|
for _, t := range tokens {
|
|
if t != "" && t != "\t" {
|
|
fi := strings.Trim(t, "\n\t")
|
|
ft = append(ft, fi)
|
|
}
|
|
}
|
|
if ft[0] != "" {
|
|
if ft[1] == "Link" {
|
|
Net.NetCard = ft[0]
|
|
sPck := NetBytes(ft[0])
|
|
if len(sPck) >= 2 {
|
|
Net.Rpck = sPck[0]
|
|
Net.Spck = sPck[1]
|
|
} else {
|
|
Net.Rpck = "0.0"
|
|
Net.Spck = "0.0"
|
|
}
|
|
}
|
|
if ft[0] == "RX" {
|
|
if strings.Contains(ft[1], "packets") {
|
|
sPackets := strings.SplitAfter(ft[1], ":")
|
|
Net.Rpackets = sPackets[1]
|
|
sErrors := strings.SplitAfter(ft[2], ":")
|
|
Net.Rerrors = sErrors[1]
|
|
}
|
|
if strings.Contains(ft[1], "bytes") {
|
|
rBytes := strings.SplitAfter(ft[1], ":")
|
|
Net.Rbytes = rBytes[1]
|
|
sBytes := strings.SplitAfter(ft[5], ":")
|
|
Net.Sbytes = sBytes[1]
|
|
aNetList = append(aNetList, Net)
|
|
}
|
|
}
|
|
if ft[0] == "TX" {
|
|
if strings.Contains(ft[1], "packets") {
|
|
sPackets := strings.SplitAfter(ft[1], ":")
|
|
Net.Spackets = sPackets[1]
|
|
sErrors := strings.SplitAfter(ft[2], ":")
|
|
Net.Serrors = sErrors[1]
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return aNetList
|
|
}
|
|
|
|
/**
|
|
*网卡实时流量
|
|
*/
|
|
func NetBytes(Iface string) []string {
|
|
aBytesInfo := make([]string, 0)
|
|
cmd := exec.Command("sar", "-n", "DEV", "1", "1")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
log.Println("ERROR", "170060|查询实时流量情况出错", err.Error())
|
|
return aBytesInfo
|
|
}
|
|
for {
|
|
line, err := out.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
tokens := strings.Split(line, " ")
|
|
ft := make([]string, 0)
|
|
for _, t := range tokens {
|
|
if t != "" && t != "\t" {
|
|
fi := strings.Trim(t, "\n\t")
|
|
ft = append(ft, fi)
|
|
}
|
|
}
|
|
if ft[0] == "Average:" {
|
|
if ft[1] == Iface {
|
|
aBytesInfo = append(aBytesInfo, ft[2])
|
|
aBytesInfo = append(aBytesInfo, ft[3])
|
|
}
|
|
}
|
|
}
|
|
return aBytesInfo
|
|
}
|
|
|
|
/**
|
|
*网络配置
|
|
*/
|
|
func GetNetConfig() []interface{} {
|
|
|
|
aNetCard := make([]interface{}, 0)
|
|
cmd := exec.Command("cat", "/etc/network/interfaces")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
log.Println("ERROR", "170050|查询网卡配置信息出错", err.Error())
|
|
return aNetCard
|
|
}
|
|
var mNetConfig map[string]string
|
|
mNetConfig = make(map[string]string)
|
|
|
|
for {
|
|
|
|
line, err := out.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
nline := strings.Replace(line, "\t", " ", -1)
|
|
tokens := strings.Split(nline, " ")
|
|
ft := make([]string, 0)
|
|
|
|
for _, t := range tokens {
|
|
if t != "" {
|
|
fi := strings.Trim(t, "\n")
|
|
ft = append(ft, fi)
|
|
}
|
|
}
|
|
|
|
switch ft[0] {
|
|
case "auto":
|
|
|
|
if len(ft) < 2 {
|
|
ft = append(ft, " ")
|
|
}
|
|
if ft[1] != "lo" {
|
|
mNetConfig["NetCard"] = ft[1]
|
|
}
|
|
|
|
case "netmask":
|
|
|
|
if len(ft) < 2 {
|
|
ft = append(ft, " ")
|
|
}
|
|
mNetConfig["NetMask"] = ft[1]
|
|
|
|
case "gateway":
|
|
|
|
if len(ft) < 2 {
|
|
ft = append(ft, " ")
|
|
}
|
|
mNetConfig["GateWay"] = ft[1]
|
|
|
|
case "address":
|
|
|
|
if len(ft) < 2 {
|
|
ft = append(ft, " ")
|
|
}
|
|
mNetConfig["Ip"] = ft[1]
|
|
|
|
case "dns-nameservers":
|
|
|
|
if len(ft) < 2 {
|
|
ft = append(ft, "")
|
|
}
|
|
mNetConfig["Dns"] = ft[1]
|
|
|
|
case "dns-nameserver":
|
|
|
|
if len(ft) < 2 {
|
|
ft = append(ft, "")
|
|
}
|
|
mNetConfig["Dns"] = ft[1]
|
|
}
|
|
|
|
if len(mNetConfig) == 5 {
|
|
aNetCard = append(aNetCard, mNetConfig)
|
|
mNetConfig = make(map[string]string)
|
|
}
|
|
|
|
}
|
|
|
|
return aNetCard
|
|
}
|
|
|
|
/**
|
|
*修改网络配置
|
|
*/
|
|
func PutNetConfig(mString map[string]string) error {
|
|
|
|
bFile, err := ioutil.ReadFile("/etc/network/interfaces")
|
|
|
|
if err != nil {
|
|
log.Println("ERROR", "170050|读取网卡配置文件出错", err.Error())
|
|
return err
|
|
}
|
|
|
|
var sName, sRegs string
|
|
var Reg *regexp.Regexp
|
|
mNetCard := make(map[string]string, 0)
|
|
for i, v := range mString {
|
|
var err error
|
|
if v == "" {
|
|
err = errors.New("参数值为空")
|
|
return err
|
|
}
|
|
switch i {
|
|
case "Ip":
|
|
mNetCard["address"] = v
|
|
case "GateWay":
|
|
mNetCard["gateway"] = v
|
|
case "Dns":
|
|
mNetCard["dns-nameserver"] = v
|
|
case "NetMask":
|
|
mNetCard["netmask"] = v
|
|
}
|
|
}
|
|
|
|
for i, v := range mNetCard {
|
|
sName = i
|
|
sRegs = sName + "\\s+\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"
|
|
Reg = regexp.MustCompile(sRegs)
|
|
bOld := Reg.Find(bFile)
|
|
bFile = bytes.Replace(bFile, bOld, []byte(i+" "+v), 1)
|
|
}
|
|
|
|
err = ioutil.WriteFile("/etc/network/interfaces", bFile, 644)
|
|
|
|
if err != nil {
|
|
panic(err)
|
|
log.Println("ERROR", "170051|写入网卡配置文件出错", err.Error())
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|