smart_streetlights/edge/ipole/sysinfo.go

package main

import (
	"strconv"
	"strings"
	"time"

	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/disk"
	"github.com/shirou/gopsutil/mem"
	"github.com/shirou/gopsutil/net"
	"github.com/shirou/gopsutil/process"

	"lc/common/protocol"
)

func SysInfoStat(seq uint64) {
	var si protocol.SysInfo
	si.Appinfo.Name = appname
	si.Appinfo.Version = version
	//CPU信息
	var cpuinfo protocol.CpuInfo
	if is, err := cpu.Info(); err == nil && len(is) > 0 {
		cpuinfo.Cpus = len(is)
		cpuinfo.Cores = int(is[0].Cores)
		cpuinfo.ModelName = is[0].ModelName
		if percent, err := cpu.Percent(time.Second*10, false); err == nil && len(percent) > 0 {
			cpuinfo.Percent = Precision(percent[0], 1, false)
		}
		si.Cpuinfo = &cpuinfo
	}
	//内存信息
	var meminfo protocol.MemInfo
	if vms, err := mem.VirtualMemory(); err == nil {
		meminfo.Total = vms.Total / (1024 * 1024)
		meminfo.Available = vms.Available / (1024 * 1024)
		meminfo.Used = vms.Used / (1024 * 1024)
		meminfo.Percent = Precision(vms.UsedPercent, 1, false)
		si.Meminfo = &meminfo
	}

	//硬盘信息
	var diskinfos []protocol.DiskInfo
	if parts, err := disk.Partitions(true); err == nil {
		for _, v := range parts {
			var diskinfo protocol.DiskInfo
			diskinfo.Mountpoint = v.Mountpoint
			diskinfo.Device = v.Device
			diskinfo.Fstype = v.Fstype
			if di, err := disk.Usage(v.Mountpoint); err == nil {
				diskinfo.Path = di.Path
				diskinfo.Total = di.Total / (1024 * 1024)
				diskinfo.Free = di.Free / (1024 * 1024)
				diskinfo.Used = di.Used / (1024 * 1024)
				diskinfo.Percent = Precision(di.UsedPercent, 1, false)
			}
			diskinfos = append(diskinfos, diskinfo)
		}
		si.Diskinfos = diskinfos
	}

	//网卡信息
	var ifss []protocol.LcInterfaces
	if iss, err := net.Interfaces(); err == nil {
		for _, v := range iss {
			var up = false
			var ipv4 = ""
			for _, v1 := range v.Flags {
				if v1 == "up" {
					up = true
				}
			}
			for _, v2 := range v.Addrs {
				if strings.Contains(v2.Addr, ".") {
					if strlist := strings.Split(v2.Addr, "/"); len(strlist) > 0 {
						ipv4 = strlist[0]
					}
				}
			}
			if up && ipv4 != "" && v.HardwareAddr != "" {
				var ifs protocol.LcInterfaces
				ifs.Name = v.Name
				ifs.HardwareAddr = v.HardwareAddr
				ifs.Addr = ipv4
				if sts, err := net.IOCounters(true); err == nil {
					for _, vv := range sts {
						if v.Name == vv.Name {
							ifs.Recv = vv.BytesRecv / (1024 * 1024)
							ifs.Sent = vv.BytesSent / (1024 * 1024)
							ifs.PacketsRecv = vv.PacketsRecv
							ifs.PacketsSent = vv.PacketsSent
							ifss = append(ifss, ifs)
							break
						}
					}
				}
			}
		}
		si.Ifs = ifss
	}

	//监听端口，连接信息

	if arr, err := net.Connections("inet4"); err == nil {
		var tcpListen []protocol.ConnectionInfo
		var tcpConn []protocol.ConnectionInfo
		var udp []protocol.ConnectionInfo
		for _, v := range arr {
			laddr := v.Laddr.IP + ":" + strconv.Itoa(int(v.Laddr.Port))
			raddr := v.Raddr.IP + ":" + strconv.Itoa(int(v.Raddr.Port))
			x := protocol.ConnectionInfo{
				Type:   v.Type,
				Laddr:  laddr,
				Raddr:  raddr,
				Status: v.Status,
				Pid:    v.Pid,
			}
			if v.Type == 1 { //TCP
				if v.Status == "LISTEN" { //TCP监听信息
					tcpListen = append(tcpListen, x)
				} else { //TCP连接信息
					tcpConn = append(tcpConn, x)
				}
			} else if v.Type == 2 { //UDP
				udp = append(udp, x)
			}
		}
		si.TcpListen = tcpListen
		si.TcpConn = tcpConn
		si.Udp = udp
	}

	//进程cpu和内存
	var pis []protocol.ProcessInfo
	ps, _ := process.Processes()
	for _, v := range ps {
		var pi protocol.ProcessInfo
		if cpup, err := v.CPUPercent(); err == nil {
			pi.Cpu = Precision(cpup, 1, false)
		}
		if mp, err := v.MemoryPercent(); err == nil {
			pi.Mem = Precision(float64(mp), 1, false)
		}
		if nm, err := v.Name(); err == nil {
			pi.Name = nm
		}
		pi.Pid = v.Pid
		pis = append(pis, pi)
	}
	si.Pis = pis

	var obj protocol.Pack_SysInfo
	if str, err := obj.EnCode(appConfig.GID, appConfig.GID, seq, si); err == nil {
		GetMQTTMgr().Publish(GetTopic(protocol.DT_GATEWAY, appConfig.GID, protocol.TP_GW_SYS_ACK), str, 0, ToCloud)
	}
	return
}