コード例 #1
0
ファイル: host_linux.go プロジェクト: toorop/telegraf
func BootTime() (uint64, error) {
	sysinfo := &syscall.Sysinfo_t{}
	if err := syscall.Sysinfo(sysinfo); err != nil {
		return 0, err
	}
	return uint64(sysinfo.Uptime), nil
}
コード例 #2
0
ファイル: status.go プロジェクト: jmptrader/interlock
func runningStatus(w http.ResponseWriter) (res jsonObject) {
	sys := &syscall.Sysinfo_t{}
	_ = syscall.Sysinfo(sys)

	log := []statusEntry{}

	status.LogBuf.Do(func(v interface{}) {
		if v != nil {
			log = append(log, v.(statusEntry))
		}
	})

	res = jsonObject{
		"status": "OK",
		"response": map[string]interface{}{
			"uptime":       sys.Uptime,
			"load_1":       sys.Loads[0],
			"load_5":       sys.Loads[1],
			"load_15":      sys.Loads[2],
			"freeram":      sys.Freeram,
			"log":          log,
			"notification": status.Notifications(),
		},
	}

	return
}
コード例 #3
0
ファイル: pse_linux.go プロジェクト: picmonkey/gnatsd
func procUsage(pcpu *float64, rss, vss *int64) error {
	contents, err := ioutil.ReadFile(procStatFile)
	if err != nil {
		return err
	}
	fields := bytes.Fields(contents)

	*rss = (parseInt64(fields[rssPos])) << 12
	*vss = parseInt64(fields[vssPos])

	startTime := parseInt64(fields[startPos])
	utime := parseInt64(fields[utimePos])
	stime := parseInt64(fields[stimePos])
	totalTime := utime + stime

	var sysinfo syscall.Sysinfo_t
	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	seconds := int64(sysinfo.Uptime) - (startTime / ticks)

	if seconds > 0 {
		ipcpu := (totalTime * 1000 / ticks) / seconds
		*pcpu = float64(ipcpu) / 10.0
	}

	return nil
}
コード例 #4
0
ファイル: uptime.go プロジェクト: qeedquan/misc_utilities
func main() {
	log.SetFlags(0)
	log.SetPrefix("uptime: ")
	flag.Parse()

	var info syscall.Sysinfo_t
	var err error
	syscall.Sysinfo(&info)
	ck(err)

	now := time.Now().Format("15:04:05")
	fmt.Printf(" %s up ", now)

	info.Uptime /= 60
	min := info.Uptime % 60
	info.Uptime /= 60
	hours := info.Uptime % 24
	days := info.Uptime / 24
	if days != 0 {
		fmt.Printf("%d day", days)
		if days != 1 {
			fmt.Printf("s")
		}
		fmt.Printf(", ")
	}
	if hours != 0 {
		fmt.Printf("%2d:%02d, ", hours, min)
	} else {
		fmt.Printf("%d min,", min)
	}
	fmt.Printf(" load average: %.02f, %.02f, %.02f\n",
		float64(info.Loads[0])/65536, float64(info.Loads[1])/65536, float64(info.Loads[2])/65536)
}
コード例 #5
0
ファイル: collector.go プロジェクト: marcelom/gocollector
func main() {
	client := http.Client{}

	for {

		si := syscall.Sysinfo_t{}
		syscall.Sysinfo(&si)

		l := strconv.FormatFloat(float64(si.Loads[0])/65536, 'f', 2)
		fmt.Println(l, si.Loads[0]/65536.0, si.Loads[0])

		time.Sleep(1 * time.Second)
		continue

		resp, err := client.PostForm("https://api.stathat.com/ez", url.Values{
			"stat":  {"loadavg"},
			"ezkey": {"YLJRun7adtSFKR2u"},
			"value": {l},
		})
		if err != nil {
			// Problems...
			fmt.Println("Error sending stat... : %v", err)
			os.Exit(1)
		}
		fmt.Println(resp)
		resp.Body.Close()
		time.Sleep(1 * time.Second)
	}
}
コード例 #6
0
ファイル: uptime_nix.go プロジェクト: juju/utils
// Uptime returns the number of seconds since the system has booted
func Uptime() (int64, error) {
	info := &syscall.Sysinfo_t{}
	err := syscall.Sysinfo(info)
	if err != nil {
		return 0, err
	}
	return int64(info.Uptime), nil
}
コード例 #7
0
ファイル: memhelper.go プロジェクト: pwaller/go-memhelper
func update_sysinfo() {
	sysinfo_mutex.Lock()
	defer sysinfo_mutex.Unlock()
	err := syscall.Sysinfo(sysinfo)
	if err != nil {
		log.Panic("syscall.Sysinfo failed: ", err)
	}
}
コード例 #8
0
ファイル: info_linux.go プロジェクト: HarryBird/go-gnulib
// Returns available physical memory
func PhysmemAvail() uint64 {
	info := syscall.Sysinfo_t{}
	err := syscall.Sysinfo(&info)
	if err != nil {
		return 0
	}
	return info.Freeram
}
コード例 #9
0
ファイル: mac-emulation.go プロジェクト: DrItanium/moo
func uptime() (int64, error) {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return 0.0, err
	} else {
		return sysinfo.Uptime, nil
	}
}
コード例 #10
0
ファイル: uptime.go プロジェクト: setkeh/fluffy-fibula
func Load() int64 {
	info := &syscall.Sysinfo_t{}
	err := syscall.Sysinfo(info)
	if err != nil {
		fmt.Printf("%s\n", err)
	}

	return info.Uptime
}
コード例 #11
0
func (mem *MemStatus) fillInStatus() {
	//system memory usage
	sysInfo := new(syscall.Sysinfo_t)
	err := syscall.Sysinfo(sysInfo)
	if err == nil {
		mem.All = uint64(sysInfo.Totalram)
		mem.Free = uint64(sysInfo.Freeram)
		mem.Used = mem.All - mem.Free
	}
}
コード例 #12
0
ファイル: sysstat.go プロジェクト: richardliao/swarmstorage
// Get sysinfo
func GetSysinfo() (sysinfo *syscall.Sysinfo_t, err error) {
	sysinfo = new(syscall.Sysinfo_t)

	err = syscall.Sysinfo(sysinfo)
	if err != nil {
		ALARM_MANAGER.Add(ALARM_SYSCALL, err, "Sysinfo failed")
		logger.Debug("Failed in syscall sysinfo, error: %s", err.Error())
		return
	}
	return sysinfo, nil
}
コード例 #13
0
ファイル: sysinfo.go プロジェクト: 0xef53/phoenix-guest-agent
func GetSystemInfo(cResp chan<- *Response, rawArgs *json.RawMessage, tag string) {
	st := &syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(st); err != nil {
		cResp <- &Response{nil, tag, err}
		return
	}

	sinfo := &SysInfo{}
	sinfo.Uptime = time.Duration(st.Uptime)

	// float64(1<<SI_LOAD_SHIFT) == 65536.0
	scale := 65536.0
	sinfo.Loadavg.One = float64(st.Loads[0]) / scale
	sinfo.Loadavg.Five = float64(st.Loads[1]) / scale
	sinfo.Loadavg.Fifteen = float64(st.Loads[2]) / scale

	unit := uint64(st.Unit) * 1024 // kB

	sinfo.Ram.Total = uint64(st.Totalram) / unit
	sinfo.Ram.Free = uint64(st.Freeram) / unit
	sinfo.Ram.Buffer = uint64(st.Bufferram) / unit

	sinfo.Swap.Total = uint64(st.Totalswap) / unit
	sinfo.Swap.Free = uint64(st.Freeswap) / unit

	sinfo.LongBit = getLongBit()

	switch u, err := getUname(); {
	case err == nil:
		sinfo.Uname = u
	default:
		cResp <- &Response{nil, tag, err}
		return
	}

	switch u, err := getLoggedUsers(); {
	case err == nil:
		sinfo.Users = u
	default:
		cResp <- &Response{nil, tag, err}
		return
	}

	switch d, err := getDisksInfo(); {
	case err == nil:
		sinfo.Disks = d
	default:
		cResp <- &Response{nil, tag, err}
		return
	}

	cResp <- &Response{sinfo, tag, nil}
}
コード例 #14
0
ファイル: sigar_linux.go プロジェクト: rasputnik/gosigar
func (self *Uptime) Get() error {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	self.Length = float64(sysinfo.Uptime)

	return nil
}
コード例 #15
0
ファイル: systeminfo.go プロジェクト: hugb/beegecluster
func GetSwap() (*Swap, error) {
	swap := &Swap{}
	sysinfo := syscall.Sysinfo_t{}
	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return swap, err
	}
	swap.Total = uint64(sysinfo.Totalswap)
	swap.Free = uint64(sysinfo.Freeswap)
	swap.Used = swap.Total - swap.Free
	return swap, nil
}
コード例 #16
0
ファイル: uptime.go プロジェクト: hjr265/statszer
func (s *Uptime) Collect(c chan *Delta) {
	for {
		info := syscall.Sysinfo_t{}
		err := syscall.Sysinfo(&info)
		if err != nil {
			c <- NewDelta("uptime", err)
			continue
		}
		c <- NewDelta("uptime", time.Duration(info.Uptime)*time.Second)
		time.Sleep(2 * time.Second)
	}
}
コード例 #17
0
ファイル: freeram.go プロジェクト: hjr265/statszer
func (s *Freeram) Collect(c chan *Delta) {
	for {
		info := syscall.Sysinfo_t{}
		err := syscall.Sysinfo(&info)
		if err != nil {
			c <- NewDelta("freeram", err)
			continue
		}
		c <- NewDelta("freeram", uint(info.Freeram))
		time.Sleep(2 * time.Second)
	}
}
コード例 #18
0
ファイル: raspik.go プロジェクト: caglar10ur/raspik
func (swap *Swap) Get() error {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	swap.TotalSwap = uint64(sysinfo.Totalswap)
	swap.FreeSwap = uint64(sysinfo.Freeswap)
	swap.UsedSwap = swap.TotalSwap - swap.FreeSwap

	return nil
}
コード例 #19
0
ファイル: sigar_linux.go プロジェクト: rasputnik/gosigar
func (self *Swap) Get() error {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	self.Total = uint64(sysinfo.Totalswap)
	self.Free = uint64(sysinfo.Freeswap)
	self.Used = self.Total - self.Free

	return nil
}
コード例 #20
0
ファイル: raspik.go プロジェクト: caglar10ur/raspik
func (load *Load) Get() error {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	load.One = float64(sysinfo.Loads[0]) / (1 << SI_LOAD_SHIFT)
	load.Five = float64(sysinfo.Loads[1]) / (1 << SI_LOAD_SHIFT)
	load.Fifteen = float64(sysinfo.Loads[2]) / (1 << SI_LOAD_SHIFT)

	return nil
}
コード例 #21
0
ファイル: raspik.go プロジェクト: caglar10ur/raspik
func (mem *Mem) Get() error {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	mem.TotalRam = uint64(sysinfo.Totalram)
	mem.FreeRam = uint64(sysinfo.Freeram)
	mem.SharedRam = uint64(sysinfo.Sharedram)
	mem.BufferRam = uint64(sysinfo.Bufferram)

	return nil
}
コード例 #22
0
ファイル: mem_linux.go プロジェクト: jianfengye/gopsutil
func SwapMemory() (*SwapMemoryStat, error) {
	sysinfo := &syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(sysinfo); err != nil {
		return nil, err
	}
	ret := &SwapMemoryStat{
		Total: uint64(sysinfo.Totalswap),
		Free:  uint64(sysinfo.Freeswap),
	}
	ret.Used = ret.Total - ret.Free
	ret.UsedPercent = float64(ret.Total-ret.Free) / float64(ret.Total) * 100.0

	return ret, nil
}
コード例 #23
0
ファイル: raspik.go プロジェクト: caglar10ur/raspik
func (uptime *Uptime) Get() error {
	sysinfo := syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	uptime.Uptime = uint64(sysinfo.Uptime)

	/*
	   days := sysinfo.Uptime / 86400
	   hours := (sysinfo.Uptime / 3600) - (days * 24)
	   mins := (sysinfo.Uptime / 60) - (days * 1440) - (hours * 60)
	*/

	return nil
}
コード例 #24
0
ファイル: sysinfo_linux.go プロジェクト: ego008/lessgo
func SysinfoGet() Sysinfo {

	var si syscall.Sysinfo_t
	syscall.Sysinfo(&si)

	return Sysinfo{
		CpuNum:    runtime.NumCPU(),
		Uptime:    si.Uptime,
		Loads:     si.Loads,
		MemTotal:  si.Totalram / 1024,
		MemFree:   si.Freeram / 1024,
		MemShared: si.Sharedram / 1024,
		MemBuffer: si.Bufferram / 1024,
		SwapTotal: si.Totalswap / 1024,
		SwapFree:  si.Freeswap / 1024,
		Procs:     si.Procs,
		TimeNow:   time.Now().Format(time.RFC3339),
	}
}
コード例 #25
0
ファイル: fingerd.go プロジェクト: danielverkamp/gofingerd
func uptime() string {
	var sysinfo syscall.Sysinfo_t
	errno := syscall.Sysinfo(&sysinfo)
	if errno == nil {
		seconds := sysinfo.Uptime

		minutes := seconds / 60
		seconds -= minutes * 60

		hours := minutes / 60
		minutes -= hours * 60

		days := hours / 24
		hours -= days * 24

		return fmt.Sprintf("%v days %v:%02v:%02v", days, hours, minutes, seconds)
	}

	return "unknown"
}
コード例 #26
0
ファイル: mem_linux.go プロジェクト: intelsdi-x/rkt
func SwapMemory() (*SwapMemoryStat, error) {
	sysinfo := &syscall.Sysinfo_t{}

	if err := syscall.Sysinfo(sysinfo); err != nil {
		return nil, err
	}
	ret := &SwapMemoryStat{
		Total: uint64(sysinfo.Totalswap) * uint64(sysinfo.Unit),
		Free:  uint64(sysinfo.Freeswap) * uint64(sysinfo.Unit),
	}
	ret.Used = ret.Total - ret.Free
	//check Infinity
	if ret.Total != 0 {
		ret.UsedPercent = float64(ret.Total-ret.Free) / float64(ret.Total) * 100.0
	} else {
		ret.UsedPercent = 0
	}
	filename := common.HostProc("vmstat")
	lines, _ := common.ReadLines(filename)
	for _, l := range lines {
		fields := strings.Fields(l)
		if len(fields) < 2 {
			continue
		}
		switch fields[0] {
		case "pswpin":
			value, err := strconv.ParseUint(fields[1], 10, 64)
			if err != nil {
				continue
			}
			ret.Sin = value * 4 * 1024
		case "pswpout":
			value, err := strconv.ParseUint(fields[1], 10, 64)
			if err != nil {
				continue
			}
			ret.Sout = value * 4 * 1024
		}
	}
	return ret, nil
}
コード例 #27
0
func MemStat() MemStatus {
	// self mem stat
	memStat := new(runtime.MemStats)
	runtime.ReadMemStats(memStat)
	mem := MemStatus{}
	mem.Self = memStat.Alloc
	// system mem stat
	sysInfo := new(syscall.Sysinfo_t)
	err := syscall.Sysinfo(sysInfo)
	if err == nil {
		mem.All = uint64(sysInfo.Totalram)
		mem.Free = uint64(sysInfo.Freeram)
		mem.Used = mem.All - mem.Free
	}
	fmt.Println("",
		"Self Alloc:", mem.Self, bytefmt.ByteSize(mem.Self), "\n",
		"All:", mem.All, bytefmt.ByteSize(mem.All), "\n",
		"Used:", mem.Used, bytefmt.ByteSize(mem.Used), "\n",
		"Free:", mem.Free, bytefmt.ByteSize(mem.Free),
	)
	return mem
}
コード例 #28
0
ファイル: pse_linux.go プロジェクト: clsung/gnatsd
// Sampling function to keep pcpu relevant.
func periodic() {
	contents, err := ioutil.ReadFile(procStatFile)
	if err != nil {
		return
	}
	fields := bytes.Fields(contents)

	// PCPU
	pstart := parseInt64(fields[startPos])
	utime := parseInt64(fields[utimePos])
	stime := parseInt64(fields[stimePos])
	total := utime + stime

	var sysinfo syscall.Sysinfo_t
	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return
	}

	seconds := int64(sysinfo.Uptime) - (pstart / ticks)

	// Save off temps
	lt := lastTotal
	ls := lastSeconds

	// Update last sample
	lastTotal = total
	lastSeconds = seconds

	// Adjust to current time window
	total -= lt
	seconds -= ls

	if seconds > 0 {
		atomic.StoreInt64(&ipcpu, (total*1000/ticks)/seconds)
	}

	time.AfterFunc(1*time.Second, periodic)
}
コード例 #29
0
ファイル: sysinfo.go プロジェクト: zyxar/berry
func Info() (*sysinfo, error) {
	rawsysinfo := &syscall.Sysinfo_t{}
	if err := syscall.Sysinfo(rawsysinfo); err != nil {
		return nil, err
	}
	defer lock.Unlock()
	lock.Lock()
	unit := uint64(rawsysinfo.Unit) * 1024 // kB
	singelton.Uptime = time.Duration(rawsysinfo.Uptime) * time.Second
	singelton.Loads[0] = float64(rawsysinfo.Loads[0]) / scale
	singelton.Loads[1] = float64(rawsysinfo.Loads[1]) / scale
	singelton.Loads[2] = float64(rawsysinfo.Loads[2]) / scale
	singelton.Procs = uint64(rawsysinfo.Procs)

	singelton.TotalRam = uint64(rawsysinfo.Totalram) / unit
	singelton.FreeRam = uint64(rawsysinfo.Freeram) / unit
	singelton.BufferRam = uint64(rawsysinfo.Bufferram) / unit
	singelton.TotalSwap = uint64(rawsysinfo.Totalswap) / unit
	singelton.FreeSwap = uint64(rawsysinfo.Freeswap) / unit
	singelton.TotalHighRam = uint64(rawsysinfo.Totalhigh) / unit
	singelton.FreeHighRam = uint64(rawsysinfo.Freehigh) / unit
	return singelton, nil
}
コード例 #30
0
ファイル: free.go プロジェクト: qeedquan/misc_utilities
func main() {
	flag.Var(unitFlag('b'), "b", "display in bytes")
	flag.Var(unitFlag('k'), "k", "display in kibibytes")
	flag.Var(unitFlag('m'), "m", "display in megabytes")
	flag.Var(unitFlag('g'), "g", "display in gigabytes")
	flag.Usage = usage
	flag.Parse()

	var info syscall.Sysinfo_t
	err := syscall.Sysinfo(&info)
	ck(err)

	unit = uint64(info.Unit)
	if unit == 0 {
		unit = 1
	}

	fmt.Printf("     %13s%13s%13s%13s%13s\n",
		"total", "used", "free", "shared", "buffers")
	fmt.Printf("Mem: ")

	fmt.Printf("%13d%13d%13d%13d%13d\n",
		scale(info.Totalram),
		scale(info.Totalram-info.Freeram),
		scale(info.Freeram),
		scale(info.Sharedram),
		scale(info.Bufferram))
	fmt.Printf("-/+ buffers/cache:")
	fmt.Printf("%13d%13d\n",
		scale(info.Totalram-info.Freeram-info.Bufferram),
		scale(info.Freeram+info.Bufferram))
	fmt.Printf("Swap:")
	fmt.Printf("%13d%13d%13d\n",
		scale(info.Totalswap),
		scale(info.Totalswap-info.Freeswap),
		scale(info.Freeswap))
}