示例#1
0
文件: info.go 项目: mysll/flynet
func GetInfo() map[string]interface{} {
	path := "/"
	if runtime.GOOS == "windows" {
		file, _ := exec.LookPath(os.Args[0])
		path = filepath.VolumeName(file)
	}

	diskinfo := disk.UsageStat{}
	if v, err := disk.Usage(path); err == nil {
		var i interface{}
		i = v
		switch inst := i.(type) {
		case disk.UsageStat:
			diskinfo = inst
			break
		case *disk.UsageStat:
			if inst != nil {
				diskinfo = *inst
			}
			break
		}

	}
	diskinfo.Total /= 1024 * 1024
	diskinfo.Used /= 1024 * 1024

	vm := mem.VirtualMemoryStat{}
	sm := mem.SwapMemoryStat{}

	if v, err := mem.VirtualMemory(); err == nil {
		vm = *v
	}
	vm.Total /= 1024 * 1024
	vm.Used /= 1024 * 1024
	if v, err := mem.SwapMemory(); err == nil {
		sm = *v
	}
	sm.Total /= 1024 * 1024
	sm.Used /= 1024 * 1024

	var cpupercent float64

	ps, err := cpu.Percent(time.Millisecond, true)
	if err == nil && len(ps) > 0 {
		for _, v := range ps {
			cpupercent += v
		}
		cpupercent /= float64(len(ps))
	}

	return map[string]interface{}{
		"DiskInfo":      diskinfo,
		"SwapMemory":    sm,
		"VirtualMemory": vm,
		"CpuPercent":    cpupercent * 100,
	}
}
示例#2
0
func (c *CpuPerc) report(kill <-chan struct{}) chan float64 {
	out := make(chan float64)
	go func() {
		defer close(out)

		out <- 0.0

		for {
			select {
			case <-kill:
				return
			default:
				p, err := cpu.Percent(c.Interval, false)
				if err != nil {
					continue
				}
				out <- p[0]
			}
		}
	}()

	return out
}
示例#3
0
func main() {
	fmt.Println("Hello RGB-spear")

	ser, err := serial.OpenPort(&serial.Config{
		Name: flagPort,
		Baud: 9600,
	})
	if err != nil {
		panic(err)
	}
	defer ser.Close()
	defer ser.Flush()

	fmt.Println("Wating 10 seconds for booting...")
	time.Sleep(10 * time.Second)

	spr = new(Spear)

	// RED for cpu
	if flagCPU {
		fmt.Println("Enable CPU")
		go func() {
			for {
				c, err := cpu.Percent(100*time.Millisecond, false)
				if err != nil {
					panic(err)
				}

				t := byte((c[0] * 255) / 100)
				spr.Lock()
				spr.R = t
				// log.Println("R->", spr.R)
				spr.Unlock()
				time.Sleep(300 * time.Millisecond)
			}
		}()
	}

	// Green for memory
	if flagMEM {
		fmt.Println("Enable MEM")
		go func() {
			for {
				v, err := mem.VirtualMemory()
				if err != nil {
					panic(err)
				}
				t := byte((v.UsedPercent * 255) / 100)
				spr.Lock()
				spr.G = t
				// log.Println("G->", spr.R)
				spr.Unlock()
				time.Sleep(300 * time.Millisecond)
			}
		}()
	}

	// Blue for network
	if flagNET {
		fmt.Println("Enable Network")
		go func() {
			lastSent, lastRecv := uint64(0), uint64(0)

			for {
				c, err := net.IOCounters(false)
				if err != nil {
					panic(err)
				}
				currSent := c[0].BytesSent
				currRecv := c[0].BytesRecv

				sent := currSent - lastSent
				recv := currRecv - lastRecv

				t := byte(((sent + recv) * 255) / 1000000)

				spr.Lock()
				spr.B = t
				spr.Unlock()
				time.Sleep(1 * time.Second)

				lastSent = currSent
				lastRecv = currRecv
			}
		}()

		t := time.NewTicker(100 * time.Millisecond)
		for {
			select {
			case <-t.C:
				fmt.Fprint(ser, spr)
				// log.Println("spr:", spr)
				ser.Flush()
			}
		}
	}
}
func (c *CPUOps) Percent(interval time.Duration, perCpu bool) ([]float64, error) {
	return CPUUtil.Percent(interval, perCpu)
}