ZLGoLib/handle_linux.go

package mokuai

import (
	"fmt"
	"net"
	"os/exec"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"time"
)

// 网速使用
type Net_dev struct {
	Ifc_bytes_r   float64 //1  Receive接收(下行)字节数 ，单位 Byte  。 1Byte(B)=8bit(b)
	Ifc_packets_r float64 //2   接收的正确包量
	Ifc_bytes_t   float64 //9  Transmit发出(上行)字节数 ，单位 Byte 。 1Byte(B)=8bit(b)
	Ifc_packets_t float64 //10  发出的正确包量
	Ifc_bytes_r_a int64   //  Receive接收(下行)总字节数（总流量） ，单位 Byte  。 1Byte(B)=8bit(b)
	Ifc_bytes_t_a int64   //  Transmit发出(下行)总字节数（总流量） ，单位 Byte  。 1Byte(B)=8bit(b)
}

// 获取机器唯一UUID ID
func OS_Linux_GetUuid() string {
	return File_ReadStr("/sys/class/dmi/id/product_uuid")
}

// 获取linux版本
func OS_Linux_GetLinuxVersion() string {
	return File_ReadStr("/proc/version")
}

// linux下运行shell指令 仅支持一行
func OS_Linux_RunSh(args ...string) string {
	cmdStr := strings.Join(args, " ")
	//	fmt.Println("cmdStr  >",cmdStr)
	cmd := exec.Command("/bin/bash", "-c", cmdStr)
	opBytes, err := cmd.Output()
	//	fmt.Print("cmdStr  ",opBytes,string(opBytes))
	if err != nil {
		if err.Error() == "exit status 1" {
			return Text_DelOuterSpace(string(opBytes))
		} else {
			return "Error:" + string(err.Error())
		}

	}
	return Text_DelOuterSpace(string(opBytes))
}

// linux下运行shell指令 仅支持一行 带错误输出
func OS_Linux_RunShWithErr(args ...string) (text, errText string) {
	cmdStr := strings.Join(args, " ")
	//	fmt.Println("cmdStr  >",cmdStr)
	cmd := exec.Command("/bin/bash", "-c", cmdStr)
	var out bytes.Buffer
	var stderr bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &stderr
	err := cmd.Run()
	if err != nil {
		return Text_DelOuterSpace(out.String()), err.Error() + "\n" + stderr.String()
	} else {
		return Text_DelOuterSpace(out.String()), ""
	}
}

// 获取linux默认出口网卡名
func OS_Linux_GetDefNet() string {
	lin := OS_Linux_RunSh("ip route |grep 'default'")
	lin = Text_GetBetween(lin, "dev ", " ")
	return lin
}

// 获取Linux 唯一不变机器sn  默认网卡、系统UUID相关联
func OS_Linux_GetSn() string {
	a, _ := net.InterfaceByName(OS_Linux_GetDefNet())
	HardwareAddr := a.HardwareAddr.String()
	SwSecret := "yw"
	//	fmt.Println("-->HardwareAddr:", HardwareAddr+"-->GetUuid:"+GetUuid()+"-->SwSecret:"+SwSecret)
	return Code_GetMd5(OS_Linux_GetUuid() + SwSecret + HardwareAddr)
}

// 获取linux当前内存使用率
// memTotal : 内存总量,单位 Byte(B) ；   used : 当前使用率,单位% ；   used_true ： 当前实际使用率,单位%
func OS_Linux_MemGetRate() (memTotal, used, used_true string) {
	a := File_ReadStr("/proc/meminfo")
	r, _ := regexp.Compile("(MemTotal|MemFree|Buffers|Cached):.*")
	b := r.FindAllString(a, 4)
	r, _ = regexp.Compile("[0-9]+")
	memTotal = r.FindString(b[0])
	MemTotal, _ := strconv.ParseFloat(r.FindString(b[0]), 64)
	MemFree, _ := strconv.ParseFloat(r.FindString(b[1]), 64)
	Buffers, _ := strconv.ParseFloat(r.FindString(b[2]), 64)
	Cached, _ := strconv.ParseFloat(r.FindString(b[3]), 64)

	//有5%的误差
	MemAvailable := (MemFree + Buffers + Cached) * 0.95

	Used := fmt.Sprintf("%.2f", (1-MemFree/MemTotal)*100)

	TrueUsed := fmt.Sprintf("%.2f", (1-MemAvailable/MemTotal)*100)

	return memTotal, Used, TrueUsed
}

// 获取linux当前CPU使用率 。 s 秒 间隔的时间长度
func OS_Linux_CpuGetRate(s int) string {
	if s < 1 {
		s = 1
	}
	c1 := File_ReadStr("/proc/stat")
	r, _ := regexp.Compile("cpu .*")
	c1 = r.FindString(c1)

	time.Sleep(time.Duration(s) * time.Second)

	c2 := File_ReadStr("/proc/stat")
	c2 = r.FindString(c2)

	tmp1 := []string{}
	tmp2 := []string{}
	tmp1 = strings.Fields(c1)
	tmp2 = strings.Fields(c2)
	var c1_total, c2_total, c1_free, c2_free float64
	c1_total, c2_total, c1_free, c2_free = 0, 0, 0, 0
	var c_tmp, c_tmp2 float64

	for i := 0; i < len(tmp1); i++ {
		c_tmp, _ = strconv.ParseFloat(tmp1[i], 64)
		c_tmp2, _ = strconv.ParseFloat(tmp2[i], 64)
		c1_total += c_tmp
		c2_total += c_tmp2
	}
	c1_free, _ = strconv.ParseFloat(tmp1[4], 64)
	c2_free, _ = strconv.ParseFloat(tmp2[4], 64)

	idle := (c2_free - c1_free) / (c2_total - c1_total)
	used := (1 - idle) * 100
	return fmt.Sprintf("%.3f", used)
}

// 获取linux当前CPU核数
func OS_Linux_CpuGetNum() string {
	a := runtime.NumCPU()
	return strconv.Itoa(a)
}

/*
	获取linux CPU信息

返回值： CpuModel：CPU型号  ； CpuPHY：物理cpu个数 ； CpuCores: CPU核数 ； CpuThread: CPU(逻辑)线程数
*/
func OS_Linux_Cpu_info() (CpuModel string, CpuPHY, CpuCores, CpuThread int) {
	a1 := File_ReadStr("/proc/cpuinfo")
	cpuPHY_zu := []string{}
	cpuCores_zu := []string{}
	cpuThread_zu := []string{}
	linzu := Text_GetSplitText(a1, "\n")

	for _, v := range linzu {
		if v == "" {
			continue
		}
		// CPU 型号
		if Text_FindKeyword(Text_GetLeftText(v, ":"), "model name") != -1 {
			CpuModel = strings.TrimSpace(Text_GetRightText(v, ":"))
			continue
		}
		if Text_FindKeyword(Text_GetLeftText(v, ":"), "physical id") != -1 {
			s := 0
			for _, v1 := range cpuPHY_zu {
				if v1 == strings.TrimSpace(Text_GetRightText(v, ":")) {
					s = 1
					break
				}
			}
			if s == 0 {
				cpuPHY_zu = append(cpuPHY_zu, strings.TrimSpace(Text_GetRightText(v, ":")))
			}
			continue
		}
		if Text_FindKeyword(Text_GetLeftText(v, ":"), "cpu cores") != -1 {
			s := 0
			for _, v1 := range cpuCores_zu {
				if v1 == strings.TrimSpace(Text_GetRightText(v, ":")) {
					s = 1
					break
				}
			}
			if s == 0 {
				cpuCores_zu = append(cpuCores_zu, strings.TrimSpace(Text_GetRightText(v, ":")))
			}
			continue
		}

		if Text_FindKeyword(Text_GetLeftText(v, ":"), "siblings") != -1 {
			s := 0
			for _, v1 := range cpuThread_zu {
				if v1 == strings.TrimSpace(Text_GetRightText(v, ":")) {
					s = 1
					break
				}
			}
			if s == 0 {
				cpuThread_zu = append(cpuThread_zu, strings.TrimSpace(Text_GetRightText(v, ":")))
			}
			continue
		}

	}

	// 整理

	CpuPHY = len(cpuPHY_zu)

	all := 0
	for _, v := range cpuCores_zu {
		i, _ := strconv.Atoi(v)
		all += i
	}

	CpuCores = all

	all = 0
	for _, v := range cpuThread_zu {
		i, _ := strconv.Atoi(v)
		all += i
	}

	CpuThread = all

	return
}

// 获取linux当前系统负载系数。 返回格式： 1、5、15分钟内的平均进程数，正在运行的进程数/进程总数，最近运行的进程ID号  （0.00 0.02 0.01 1/201 24781）
func OS_Linux_GetSystemAvg() string {
	return File_ReadStr("/proc/loadavg")
}

// 获取linux当前tcp连接数
func OS_Linux_GetTcp() string {
	str := File_ReadStr("/proc/net/tcp")
	i := strings.Count(str, "\n")
	return strconv.Itoa(i)
}

// 获取linux当前udp连接数
func OS_Linux_GetUdp() string {
	str := File_ReadStr("/proc/net/udp")
	i := strings.Count(str, "\n")
	return strconv.Itoa(i)
}

// 获取linux实时网速 。 s 秒 间隔的时间长度 ,返回网卡及对应的上下行实时流量 .返回单位见 Net_dev
func Os_Linux_NetRealSpeed(s int) (inter map[string]Net_dev) {
	if s < 1 {
		s = 1
	}
	a1 := File_ReadStr("/proc/net/dev")
	rt := make(map[string]Net_dev)
	rt2 := make(map[string]Net_dev)
	var nt Net_dev

	tmp := strings.Split(a1, "\n")
	tmp2 := []string{}
	for i := 2; i < len(tmp); i++ {
		tmp2 = strings.Fields(tmp[i])
		//	fmt.Println("tmp2",tmp2)
		if len(tmp2) > 0 {
			nt.Ifc_bytes_r, _ = strconv.ParseFloat(tmp2[1], 64)
			nt.Ifc_packets_r, _ = strconv.ParseFloat(tmp2[2], 64)
			nt.Ifc_bytes_t, _ = strconv.ParseFloat(tmp2[9], 64)
			nt.Ifc_packets_t, _ = strconv.ParseFloat(tmp2[10], 64)
			tmp2[0] = strings.Replace(tmp2[0], ":", "", 1)
			rt[tmp2[0]] = nt
		}
	}

	time.Sleep(time.Duration(s) * time.Second)
	s1 := float64(s)
	a2 := File_ReadStr("/proc/net/dev")
	tmp = strings.Split(a2, "\n")
	tmp2 = []string{}
	for i := 2; i < len(tmp); i++ {
		tmp2 = strings.Fields(tmp[i])
		if len(tmp2) > 0 {

			nt.Ifc_bytes_r, _ = strconv.ParseFloat(tmp2[1], 64)
			nt.Ifc_packets_r, _ = strconv.ParseFloat(tmp2[2], 64)
			nt.Ifc_bytes_t, _ = strconv.ParseFloat(tmp2[9], 64)
			nt.Ifc_packets_t, _ = strconv.ParseFloat(tmp2[10], 64)
			i64, _ := strconv.ParseInt(tmp2[1], 10, 64)
			nt.Ifc_bytes_r_a = i64
			i64, _ = strconv.ParseInt(tmp2[9], 10, 64)
			nt.Ifc_bytes_t_a = i64
			tmp2[0] = strings.Replace(tmp2[0], ":", "", 1)
			rt2[tmp2[0]] = nt
		}
	}
	inter = make(map[string]Net_dev)
	for k := range rt {
		Ifc_bytes_r := (rt2[k].Ifc_bytes_r - rt[k].Ifc_bytes_r) / s1 / 1024
		Ifc_packets_r := (rt2[k].Ifc_packets_r - rt[k].Ifc_packets_r) / s1
		Ifc_bytes_t := (rt2[k].Ifc_bytes_t - rt[k].Ifc_bytes_t) / s1 / 1024
		Ifc_packets_t := (rt2[k].Ifc_packets_t - rt[k].Ifc_packets_t) / s1
		inter[k] = Net_dev{Ifc_bytes_r: Ifc_bytes_r, Ifc_packets_r: Ifc_packets_r, Ifc_bytes_t: Ifc_bytes_t, Ifc_packets_t: Ifc_packets_t, Ifc_bytes_r_a: rt2[k].Ifc_bytes_r_a, Ifc_bytes_t_a: rt2[k].Ifc_bytes_t_a}
	}

	return inter
}