func main() { v, _ := mem.VirtualMemory() // almost every return value is a struct fmt.Printf("Total: %v, Free:%v, UsedPercent:%f%%\n", v.Total, v.Free, v.UsedPercent) // convert to JSON. String() is also implemented fmt.Println(v) h, err := host.HostInfo() if err != nil { fmt.Println("err:", err) } else { fmt.Printf("hostname %v", h) } c, err := cpu.CPUInfo() if err != nil { fmt.Println("err:", err) } for _, v := range c { fmt.Printf("cpu info %v \n ", v) } }
func updateCPUInfo() { ci, err = cpu.CPUInfo() log.Printf("updateCPUInfo(): %v", spew.Sdump(ci)) if err != nil { log.Fatal(err) } }
func initCPUInfo(monitorData *monitoringData) error { info, err := cpu.CPUInfo() if info != nil { monitorData.CPUInfo = info monitorData.CPUModelName = monitorData.CPUInfo[0].ModelName t, err := cpu.CPUTimes(true) if t != nil { monitorData.CPUTime = t globalTime, err := cpu.CPUTimes(false) if globalTime != nil { monitorData.GlobalCPUTime = globalTime var percentWaitGroup sync.WaitGroup percentWaitGroup.Add(2) go func(monitorData *monitoringData, wg *sync.WaitGroup) { defer wg.Done() cpuPercent, _ := cpu.CPUPercent(monitorData.UpdatePeriod, true) monitorData.CPUPercent = cpuPercent }(monitorData, &percentWaitGroup) go func(monitorData *monitoringData, wg *sync.WaitGroup) { defer wg.Done() globalCpuPercent, _ := cpu.CPUPercent(monitorData.UpdatePeriod, false) monitorData.GlobalCPUPercent = globalCpuPercent[0] }(monitorData, &percentWaitGroup) percentWaitGroup.Wait() cpuCounts, err := cpu.CPUCounts(false) monitorData.CPUCounts = cpuCounts logicalCpuCounts, err := cpu.CPUCounts(false) monitorData.LogicalCPUCounts = logicalCpuCounts return err } return err } return err } return err }
func (c *CpuInfo) Run() error { data, err := gopsutil_cpu.CPUInfo() if err != nil { return err } c.Data["CpuInfo"] = data return nil }
func main() { v, _ := mem.VirtualMemory() c, _ := cpu.CPUInfo() // almost every return value is a struct fmt.Printf("Total: %v, Free:%v, UsedPercent:%f%%\n", v.Total, v.Free, v.UsedPercent) for _, v := range c { fmt.Printf("Percentage: %f\n", v.Mhz) } // convert to JSON. String() is also implemented }
func startNode(masterHost, name string) { var sock mangos.Socket var err error var msg []byte masterUrl := url.URL{Scheme: "tcp", Host: masterHost} ip := getPrivateIP() // Try to get new "respondent" socket if sock, err = respondent.NewSocket(); err != nil { utils.Die("Can't get new respondent socket: %s", err.Error()) } defer sock.Close() sock.AddTransport(tcp.NewTransport()) // Connect to master if err = sock.Dial(masterUrl.String()); err != nil { utils.Die("Can't dial on respondent socket: %s", err.Error()) } // Wait for a survey request and send responses for { if msg, err = sock.Recv(); err != nil { utils.Die("Cannot recv: %s", err.Error()) } fmt.Printf("Client(%s): Received \"%s\" survey request\n", name, string(msg)) var loadAvg *load.LoadAvgStat if loadAvg, err = load.LoadAvg(); err != nil { utils.Die("Cannot get load average: %s", err.Error()) } var cpuInfo []cpu.CPUInfoStat if cpuInfo, err = cpu.CPUInfo(); err != nil { utils.Die("Cannot get CPU info: %s", err.Error()) } fmt.Printf("CPU INFO len: %d\n", len(cpuInfo)) // Get the normalized CPU load avg := loadAvg.Load1 cores := int32(0) for _, info := range cpuInfo { fmt.Printf("Inner Cores: %d\n", info.Cores) cores += info.Cores } fmt.Printf("Load avg: %f\n", avg) fmt.Printf("Cores: %d\n", cores) avg = avg / float64(cores) fmt.Printf("Client(%s): Sending survey response\n", name) if err = sock.Send([]byte(fmt.Sprintf("%s,%f", ip, avg))); err != nil { utils.Die("Cannot send: %s", err.Error()) } } }
func (f *CPUFingerprint) Fingerprint(cfg *config.Config, node *structs.Node) (bool, error) { cpuInfo, err := cpu.CPUInfo() if err != nil { f.logger.Println("[WARN] Error reading CPU information:", err) return false, err } var numCores int32 var mhz float64 var modelName string // Assume all CPUs found have same Model. Log if not. // If CPUInfo() returns nil above, this loop is still safe for _, c := range cpuInfo { numCores += c.Cores mhz += c.Mhz if modelName != "" && modelName != c.ModelName { f.logger.Println("[WARN] Found different model names in the same CPU information. Recording last found") } modelName = c.ModelName } // Get average CPU frequency mhz /= float64(len(cpuInfo)) if mhz > 0 { node.Attributes["cpu.frequency"] = fmt.Sprintf("%.6f", mhz) } if numCores > 0 { node.Attributes["cpu.numcores"] = fmt.Sprintf("%d", numCores) } if mhz > 0 && numCores > 0 { tc := float64(numCores) * mhz node.Attributes["cpu.totalcompute"] = fmt.Sprintf("%.6f", tc) if node.Resources == nil { node.Resources = &structs.Resources{} } node.Resources.CPU = int(tc) } if modelName != "" { node.Attributes["cpu.modelname"] = modelName } return true, nil }
func jsonCPUInfo() []byte { type CpuInfo struct { Info []cpu.CPUInfoStat Times []cpu.CPUTimesStat Time []cpu.CPUTimesStat } c := &CpuInfo{} CPUTime, _ := cpu.CPUTimes(false) CPUTimes, _ := cpu.CPUTimes(true) CPUInfo, _ := cpu.CPUInfo() c.Info = CPUInfo c.Time = CPUTime c.Times = CPUTimes jsonPartitions, _ := json.Marshal(c) return jsonPartitions }
hateoas.ServiceUse(api.JSON), hateoas.AddResource(root, cpuRsc, loadRsc, procRsc), ) var root = hateoas.NewResource( hateoas.Path("/"), hateoas.AddLink("cpus", cpuRsc), hateoas.AddLink("load", loadRsc), hateoas.AddLink("processes", procRsc), hateoas.HEAD(mohttp.EmptyBodyHandler), ) var cpuRsc = hateoas.NewResource( hateoas.Path("/cpus"), hateoas.GET(mohttp.DataHandlerFunc(func(c context.Context) (interface{}, error) { return cpu.CPUInfo() })), ) var loadRsc = hateoas.NewResource( hateoas.Path("/load"), hateoas.GET(mohttp.DataHandlerFunc(func(c context.Context) (interface{}, error) { return load.LoadAvg() })), ) var procRsc = hateoas.NewResource( hateoas.Path("/processes"), hateoas.GET(mohttp.DataHandlerFunc(func(c context.Context) (interface{}, error) { return process.Pids() })),
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 json_cpuinfo(w http.ResponseWriter, r *http.Request) { cpuinfo, _ := cpu.CPUInfo() b, _ := json.Marshal(cpuinfo) w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, string(b)) }