├── bench ├── .gitignore ├── README.md ├── cpu │ ├── bench_cpu.go │ └── cpu_test.go └── net │ └── bench_net.go ├── cmd └── joebench │ ├── .gitignore │ └── README.md ├── mem ├── README.md ├── membasic │ ├── flat │ │ ├── info.fbs │ │ └── membasic_unix_test.go │ └── membasic_unix_test.go └── meminfo │ └── flat │ └── info.fbs ├── sysinfo ├── README.md ├── uptime │ ├── flat │ │ ├── uptime.fbs │ │ ├── structs │ │ │ └── Uptime.go │ │ └── uptime_unix_test.go │ ├── uptime_unix_test.go │ ├── json │ │ ├── uptime_unix_test.go │ │ └── uptime_unix.go │ └── uptime_unix.go ├── loadavg │ ├── flat │ │ ├── loadavg.fbs │ │ ├── structs │ │ │ └── LoadAvg.go │ │ └── loadavg_unix_test.go │ ├── loadavg_unix_test.go │ ├── json │ │ ├── loadavg_unix_test.go │ │ └── loadavg_unix.go │ └── loadavg_unix.go ├── mem │ ├── flat │ │ ├── meminfo.fbs │ │ ├── mem_unix_test.go │ │ └── structs │ │ │ └── MemInfo.go │ ├── mem_unix_test.go │ ├── json │ │ ├── mem_unix_test.go │ │ └── mem_unix.go │ └── mem_unix.go └── sysinfo.go ├── disk ├── README.md ├── structs │ ├── diskstats.fbs │ ├── diskusage.fbs │ ├── device.fbs │ ├── structs.go │ └── flat │ │ ├── DiskStats.go │ │ └── DiskUsage.go ├── diskstats │ ├── diskstats_unix_test.go │ └── flat │ │ └── diskstats_unix_test.go └── diskusage │ ├── diskusage_unix_test.go │ ├── json │ └── diskusage_unix_test.go │ └── flat │ └── diskusage_unix_test.go ├── net ├── README.md ├── structs │ ├── devinfo.fbs │ ├── devusage.fbs │ ├── device.fbs │ ├── flat │ │ ├── DevInfo.go │ │ └── DevUsage.go │ └── structs.go ├── netdev │ ├── netdev_unix_test.go │ ├── flat │ │ └── netdev_unix_test.go │ └── json │ │ └── netdev_unix_test.go └── netusage │ ├── netusage_unix_test.go │ └── flat │ └── netusage_unix_test.go ├── system ├── README.md ├── uptime │ ├── flat │ │ ├── uptime.fbs │ │ ├── structs │ │ │ └── Uptime.go │ │ └── uptime_unix_test.go │ ├── uptime_unix_test.go │ └── json │ │ └── uptime_unix_test.go ├── loadavg │ ├── flat │ │ ├── loadavg.fbs │ │ ├── structs │ │ │ └── LoadAvg.go │ │ └── loadavg_unix_test.go │ └── loadavg_unix_test.go ├── os │ ├── flat │ │ ├── os.fbs │ │ ├── os_unix_test.go │ │ └── structs │ │ │ └── OS.go │ ├── os_unix_test.go │ └── json │ │ ├── os_unix_test.go │ │ └── os_unix.go └── version │ ├── flat │ ├── kernel.fbs │ ├── version_unix_test.go │ └── structs │ │ └── Kernel.go │ ├── version_unix_test.go │ └── json │ └── version_unix_test.go ├── .travis.yml ├── node ├── flat │ ├── nodes.fbs │ ├── structs │ │ ├── Node.go │ │ └── Nodes.go │ └── node_unix_test.go ├── test │ └── node_unix_test.go └── json │ ├── node_unix_test.go │ └── node_unix.go ├── cpu ├── README.md ├── cpufreq │ ├── flat │ │ ├── frequency.fbs │ │ └── structs │ │ │ ├── CPU.go │ │ │ └── Frequency.go │ └── cpufreq_unix_test.go ├── cpux │ └── flat │ │ ├── cpux.fbs │ │ └── structs │ │ ├── CacheInf.go │ │ ├── CPU.go │ │ └── CPUs.go ├── cpuutil │ ├── flat │ │ ├── cpuutil.fbs │ │ ├── structs │ │ │ ├── Utilization.go │ │ │ └── CPUUtil.go │ │ └── cpuutil_unix_test.go │ └── cpuutil_unix_test.go ├── cpustats │ ├── flat │ │ ├── cpustats.fbs │ │ ├── structs │ │ │ └── CPUStats.go │ │ └── cpustats_unix_test.go │ └── cpustats_unix_test.go └── cpuinfo │ ├── flat │ ├── cpuinfo.fbs │ └── structs │ │ └── CPUInfo.go │ ├── cpuinfo_unix_test.go │ ├── test │ └── cpuinfo_unix_test.go │ └── json │ └── cpuinfo_unix_test.go ├── .gitignore ├── processors ├── processors_test.go ├── flat │ ├── processors.fbs │ └── structs │ │ ├── Node.go │ │ └── CacheInf.go └── README.md └── README.md /bench/.gitignore: -------------------------------------------------------------------------------- 1 | bench 2 | -------------------------------------------------------------------------------- /cmd/joebench/.gitignore: -------------------------------------------------------------------------------- 1 | joebench 2 | *.exe 3 | -------------------------------------------------------------------------------- /mem/README.md: -------------------------------------------------------------------------------- 1 | # joefriday/mem 2 | Provides information about a system's memory. -------------------------------------------------------------------------------- /sysinfo/README.md: -------------------------------------------------------------------------------- 1 | # joefriday/sysinfo 2 | Provides basic system information using syscalls. -------------------------------------------------------------------------------- /disk/README.md: -------------------------------------------------------------------------------- 1 | # joefriday/disk 2 | Provides stats and usage information about a system's disks. -------------------------------------------------------------------------------- /net/README.md: -------------------------------------------------------------------------------- 1 | # joefriday/net 2 | Provides information about a system's network devices and their usage. -------------------------------------------------------------------------------- /system/README.md: -------------------------------------------------------------------------------- 1 | # joefriday/system 2 | Provides information about the system including loadavg, uptime, OS release, and kernel version. -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.x 5 | - tip 6 | 7 | matrix: 8 | allow_failures: 9 | - go: tip 10 | 11 | script: 12 | - go test ./... 13 | -------------------------------------------------------------------------------- /sysinfo/uptime/flat/uptime.fbs: -------------------------------------------------------------------------------- 1 | // uptime.fbs 2 | namespace structs; 3 | 4 | table Uptime { 5 | Timestamp:long; 6 | Uptime:long; 7 | } 8 | 9 | root_type Uptime; 10 | -------------------------------------------------------------------------------- /net/structs/devinfo.fbs: -------------------------------------------------------------------------------- 1 | // devinfo.fbs 2 | include "device.fbs"; 3 | namespace flat; 4 | 5 | table DevInfo { 6 | Timestamp:long; 7 | Device:[Device]; 8 | } 9 | 10 | root_type DevInfo; 11 | -------------------------------------------------------------------------------- /node/flat/nodes.fbs: -------------------------------------------------------------------------------- 1 | // nodes.fbs 2 | namespace structs; 3 | 4 | table Nodes { 5 | Node:[Node]; 6 | } 7 | 8 | table Node { 9 | ID:int; 10 | CPUList:string; 11 | } 12 | 13 | root_type Nodes; 14 | -------------------------------------------------------------------------------- /system/uptime/flat/uptime.fbs: -------------------------------------------------------------------------------- 1 | // Uptime.fbs 2 | namespace structs; 3 | 4 | table Uptime { 5 | Timestamp:long; 6 | Total:double; 7 | Idle:double; 8 | } 9 | 10 | root_type Uptime; 11 | -------------------------------------------------------------------------------- /disk/structs/diskstats.fbs: -------------------------------------------------------------------------------- 1 | // diskstats.fbs 2 | include "device.fbs"; 3 | namespace flat; 4 | 5 | table DiskStats { 6 | Timestamp:long; 7 | Device:[Device]; 8 | } 9 | 10 | root_type DiskStats; 11 | -------------------------------------------------------------------------------- /net/structs/devusage.fbs: -------------------------------------------------------------------------------- 1 | // devusage.fbs 2 | include "device.fbs"; 3 | namespace flat; 4 | 5 | table DevUsage { 6 | Timestamp:long; 7 | TimeDelta:long; 8 | Device:[Device]; 9 | } 10 | 11 | root_type DevUsage; 12 | -------------------------------------------------------------------------------- /sysinfo/loadavg/flat/loadavg.fbs: -------------------------------------------------------------------------------- 1 | // loadavg.fbs 2 | namespace structs; 3 | 4 | table LoadAvg { 5 | Timestamp:long; 6 | One:double; 7 | Five:double; 8 | Fifteen:double; 9 | } 10 | 11 | root_type LoadAvg; 12 | -------------------------------------------------------------------------------- /disk/structs/diskusage.fbs: -------------------------------------------------------------------------------- 1 | // diskusage.fbs 2 | include "device.fbs"; 3 | namespace flat; 4 | 5 | table DiskUsage { 6 | Timestamp:long; 7 | TimeDelta:long; 8 | Device:[Device]; 9 | } 10 | 11 | root_type DiskUsage; 12 | -------------------------------------------------------------------------------- /system/loadavg/flat/loadavg.fbs: -------------------------------------------------------------------------------- 1 | // loadavg.fbs 2 | namespace structs; 3 | 4 | table LoadAvg { 5 | Timestamp:long; 6 | Minute:float; 7 | Five:float; 8 | Fifteen:float; 9 | Running:int; 10 | Total:int; 11 | PID:int; 12 | } 13 | 14 | root_type LoadAvg; 15 | -------------------------------------------------------------------------------- /sysinfo/mem/flat/meminfo.fbs: -------------------------------------------------------------------------------- 1 | //info.fbs 2 | namespace structs; 3 | 4 | table MemInfo { 5 | Timestamp:long; 6 | TotalRAM:ulong; 7 | FreeRAM:ulong; 8 | SharedRAM:ulong; 9 | BufferRAM:ulong; 10 | TotalSwap:ulong; 11 | FreeSwap:ulong; 12 | } 13 | 14 | root_type MemInfo; 15 | -------------------------------------------------------------------------------- /system/os/flat/os.fbs: -------------------------------------------------------------------------------- 1 | // os.fbs 2 | namespace structs; 3 | 4 | table OS { 5 | Name:string; 6 | ID:string; 7 | IDLike:string; 8 | PrettyName:string; 9 | Version:string; 10 | VersionID:string; 11 | HomeURL:string; 12 | BugReportURL:string; 13 | } 14 | 15 | root_type OS; 16 | -------------------------------------------------------------------------------- /system/version/flat/kernel.fbs: -------------------------------------------------------------------------------- 1 | // kernel.fbs 2 | namespace structs; 3 | 4 | table Kernel { 5 | OS:string; 6 | Version:string; 7 | CompileUser:string; 8 | GCC:string; 9 | OSGCC:string; 10 | Type:string; 11 | CompileDate:string; 12 | Arch:string; 13 | } 14 | 15 | root_type Kernel; 16 | -------------------------------------------------------------------------------- /cpu/README.md: -------------------------------------------------------------------------------- 1 | # joefriday/cpu 2 | Provides information about a system's CPUs and their utilization. CPU, in this context, means CPUs as reported by the system, not each individual physical processor. For information about a system's physical processors, see [processors](https://github.com/mohae/joefriday/tree/master/processors). -------------------------------------------------------------------------------- /cpu/cpufreq/flat/frequency.fbs: -------------------------------------------------------------------------------- 1 | // frequency.fbs 2 | namespace structs; 3 | 4 | table Frequency { 5 | Timestamp:long; 6 | Sockets:int; 7 | CPU:[CPU]; 8 | } 9 | 10 | table CPU { 11 | Processor:int; 12 | CPUMHz:float; 13 | PhysicalID:int; 14 | CoreID:int; 15 | APICID:int; 16 | } 17 | 18 | root_type Frequency; 19 | -------------------------------------------------------------------------------- /mem/membasic/flat/info.fbs: -------------------------------------------------------------------------------- 1 | //info.fbs 2 | namespace structs; 3 | 4 | table Info { 5 | Timestamp:long; 6 | Active:ulong; 7 | Inactive:ulong; 8 | Mapped:ulong; 9 | MemAvailable:ulong; 10 | MemFree:ulong; 11 | MemTotal:ulong; 12 | SwapCached:ulong; 13 | SwapFree:ulong; 14 | SwapTotal:ulong; 15 | } 16 | 17 | root_type Info; 18 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | *.swp 26 | *.bak 27 | *.json 28 | *.dat 29 | .tags 30 | -------------------------------------------------------------------------------- /cpu/cpux/flat/cpux.fbs: -------------------------------------------------------------------------------- 1 | // cpux.fbs 2 | namespace structs; 3 | 4 | table CPUs { 5 | Sockets:int; 6 | Possible:string; 7 | Present:string; 8 | Online:string; 9 | Offline:string; 10 | CPU:[CPU]; 11 | } 12 | 13 | table CPU { 14 | PhysicalPackageID:int; 15 | CoreID:int; 16 | MHzMin:float; 17 | MHzMax:float; 18 | Cache:[CacheInf]; 19 | } 20 | 21 | table CacheInf { 22 | ID:string; 23 | Size:string; 24 | } 25 | 26 | root_type CPUs; 27 | -------------------------------------------------------------------------------- /disk/structs/device.fbs: -------------------------------------------------------------------------------- 1 | // device.fbs 2 | namespace flat; 3 | 4 | table Device { 5 | Major:uint; 6 | Minor:uint; 7 | Name:string; 8 | ReadsCompleted:ulong; 9 | ReadsMerged:ulong; 10 | ReadSectors:ulong; 11 | ReadingTime:ulong; 12 | WritesCompleted:ulong; 13 | WritesMerged:ulong; 14 | WrittenSectors:ulong; 15 | WritingTime:ulong; 16 | IOInProgress:int; 17 | IOTime:ulong; 18 | WeightedIOTime:ulong; 19 | } 20 | 21 | root_type Device; 22 | -------------------------------------------------------------------------------- /net/structs/device.fbs: -------------------------------------------------------------------------------- 1 | // device.fbs 2 | namespace flat; 3 | 4 | table Device { 5 | Name:string; 6 | RBytes:long; 7 | RPackets:long; 8 | RErrs:long; 9 | RDrop:long; 10 | RFIFO:long; 11 | RFrame:long; 12 | RCompressed:long; 13 | RMulticast:long; 14 | TBytes:long; 15 | TPackets:long; 16 | TErrs:long; 17 | TDrop:long; 18 | TFIFO:long; 19 | TColls:long; 20 | TCarrier:long; 21 | TCompressed:long; 22 | } 23 | 24 | 25 | root_type Device; 26 | -------------------------------------------------------------------------------- /cpu/cpuutil/flat/cpuutil.fbs: -------------------------------------------------------------------------------- 1 | // cpuutil.fbs 2 | namespace structs; 3 | 4 | table CPUUtil { 5 | Timestamp:long; 6 | TimeDelta:long; 7 | BTimeDelta:int; 8 | CtxtDelta:long; 9 | Processes:int; 10 | CPU:[Utilization]; 11 | } 12 | 13 | table Utilization { 14 | ID:string; 15 | Usage:float; 16 | User:float; 17 | Nice:float; 18 | System:float; 19 | Idle:float; 20 | IOWait:float; 21 | } 22 | 23 | root_type CPUUtil; 24 | -------------------------------------------------------------------------------- /cmd/joebench/README.md: -------------------------------------------------------------------------------- 1 | #joebench 2 | 3 | JoeBench is used to run joefriday benchmarks and create formatted output. 4 | 5 | For comparative benchmarks with other packages that provide similar information, either compile and run [bench](https://github.com/mohae/joefriday/bench) or run the benchmarks in https://github.com/joefriday/bench using: 6 | 7 | go test -bench=. -benchmem. ./... 8 | 9 | These benchmarks are a subset of the information provided by [joefriday](https://github.com/mohae/joefriday). 10 | -------------------------------------------------------------------------------- /cpu/cpustats/flat/cpustats.fbs: -------------------------------------------------------------------------------- 1 | // cpustats.fbs 2 | namespace structs; 3 | 4 | table CPUStats { 5 | ClkTck:short; 6 | Timestamp:long; 7 | Ctxt:long; 8 | BTime:long; 9 | Processes:long; 10 | CPU:[CPU]; 11 | } 12 | 13 | table CPU { 14 | ID:string; 15 | User:long; 16 | Nice:long; 17 | System:long; 18 | Idle:long; 19 | IOWait:long; 20 | IRQ:long; 21 | SoftIRQ:long; 22 | Steal:long; 23 | Quest:long; 24 | QuestNice:long; 25 | } 26 | 27 | root_type CPUStats; 28 | -------------------------------------------------------------------------------- /cpu/cpuinfo/flat/cpuinfo.fbs: -------------------------------------------------------------------------------- 1 | // cpuinfo.fbs 2 | namespace structs; 3 | 4 | table CPUInfo { 5 | Timestamp:long; 6 | Sockets:int; 7 | CPU:[CPU]; 8 | } 9 | 10 | table CPU { 11 | Processor:int; 12 | VendorID:string; 13 | CPUFamily:string; 14 | Model:string; 15 | ModelName:string; 16 | Stepping:string; 17 | Microcode:string; 18 | CPUMHz:float; 19 | CacheSize:string; 20 | PhysicalID:int; 21 | Siblings:byte; 22 | CoreID:int; 23 | CPUCores:int; 24 | APICID:int; 25 | InitialAPICID:int; 26 | FPU:string; 27 | FPUException:string; 28 | CPUIDLevel:string; 29 | WP:string; 30 | Flags:[string]; 31 | Bugs:[string]; 32 | BogoMIPS:float; 33 | CLFlushSize:ushort; 34 | CacheAlignment:ushort; 35 | AddressSizes:[string]; 36 | PowerManagement:[string]; 37 | TLBSize:string; 38 | } 39 | 40 | root_type CPUInfo; 41 | -------------------------------------------------------------------------------- /sysinfo/sysinfo.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package sysinfo returns system information. Instead of using proc files, 15 | // syscalls are made. There is some overlap between the data that this package 16 | // provides and some of the other JoeFriday packages. 17 | package sysinfo 18 | -------------------------------------------------------------------------------- /processors/processors_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package processors 15 | 16 | import "testing" 17 | 18 | func TestEndianness(t *testing.T) { 19 | e := Endianness() 20 | if e == "" { 21 | t.Errorf("got empty string; want either %q or %q", LittleEndian, BigEndian) 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /processors/flat/processors.fbs: -------------------------------------------------------------------------------- 1 | // processors.fbs 2 | namespace structs; 3 | 4 | table Processors { 5 | Timestamp:long; 6 | Architecture:string; 7 | ByteOrder:string; 8 | Sockets:int; 9 | CPUs:int; 10 | Possible:string; 11 | Present:string; 12 | Offline:string; 13 | Online:string; 14 | CoresPerSocket:short; 15 | ThreadsPerCore:byte; 16 | VendorID:string; 17 | CPUFamily:string; 18 | Model:string; 19 | ModelName:string; 20 | Stepping:string; 21 | Microcode:string; 22 | CPUMHz:float; 23 | MHzMin:float; 24 | MHzMax:float; 25 | CacheSize:string; 26 | Cache:[CacheInf]; 27 | BogoMIPS:float; 28 | Flags:[string]; 29 | Bugs:[string]; 30 | OpModes:[string]; 31 | Virtualization:string; 32 | NumaNodes:int; 33 | NumaNodeCPUs:[Node]; 34 | } 35 | 36 | table CacheInf { 37 | ID:string; 38 | Size:string; 39 | } 40 | 41 | table Node { 42 | ID:int; 43 | CPUList:string; 44 | } 45 | 46 | root_type Processors; 47 | -------------------------------------------------------------------------------- /cpu/cpufreq/cpufreq_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpufreq 15 | 16 | import ( 17 | "testing" 18 | ) 19 | 20 | func BenchmarkGet(b *testing.B) { 21 | var f *Frequency 22 | p, _ := NewProfiler() 23 | b.ResetTimer() 24 | for i := 0; i < b.N; i++ { 25 | f, _ = p.Get() 26 | } 27 | _ = f 28 | } 29 | -------------------------------------------------------------------------------- /cpu/cpuinfo/cpuinfo_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpuinfo 15 | 16 | import ( 17 | "testing" 18 | ) 19 | 20 | func BenchmarkGet(b *testing.B) { 21 | var inf *CPUInfo 22 | p, _ := NewProfiler() 23 | b.ResetTimer() 24 | for i := 0; i < b.N; i++ { 25 | inf, _ = p.Get() 26 | } 27 | _ = inf 28 | } 29 | -------------------------------------------------------------------------------- /mem/meminfo/flat/info.fbs: -------------------------------------------------------------------------------- 1 | //info.fbs 2 | namespace structs; 3 | 4 | table Info { 5 | Timestamp:long; 6 | Active:ulong; 7 | ActiveAnon:ulong; 8 | ActiveFile:ulong; 9 | AnonHugePages:ulong; 10 | AnonPages:ulong; 11 | Bounce:ulong; 12 | Buffers:ulong; 13 | Cached:ulong; 14 | CommitLimit:ulong; 15 | CommittedAS:ulong; 16 | DirectMap4K:ulong; 17 | DirectMap2M:ulong; 18 | Dirty:ulong; 19 | HardwareCorrupted:ulong; 20 | HugePagesFree:ulong; 21 | HugePagesRsvd:ulong; 22 | HugePagesSize:ulong; 23 | HugePagesSurp:ulong; 24 | HugePagesTotal:ulong; 25 | Inactive:ulong; 26 | InactiveAnon:ulong; 27 | InactiveFile:ulong; 28 | KernelStack:ulong; 29 | Mapped:ulong; 30 | MemAvailable:ulong; 31 | MemFree:ulong; 32 | MemTotal:ulong; 33 | Mlocked:ulong; 34 | NFSUnstable:ulong; 35 | PageTables:ulong; 36 | Shmem:ulong; 37 | Slab:ulong; 38 | SReclaimable:ulong; 39 | SUnreclaim:ulong; 40 | SwapCached:ulong; 41 | SwapFree:ulong; 42 | SwapTotal:ulong; 43 | Unevictable:ulong; 44 | VmallocChunk:ulong; 45 | VmallocTotal:ulong; 46 | VmallocUsed:ulong; 47 | Writeback:ulong; 48 | WritebackTmp:ulong; 49 | } 50 | 51 | root_type Info; 52 | -------------------------------------------------------------------------------- /processors/README.md: -------------------------------------------------------------------------------- 1 | processors 2 | ======= 3 | 4 | Package `processors` provides information about a system's nodes, sockets, and physical processors. This information is gathered from both `/proc/cpuinfo` and the `sysfs`. For information gathered from `cpuinfo`, the first core entry for each physical CPU is used. 5 | 6 | For `x86/x86-64` systems, the `CPUMHz` field is not reliable as it is the current speed of the first core processed for each physical processor. Modern `x86\x86-64` processor core speeds are dynamic and fall within a range; there may be other cores on the same processor that are at higher or lower speeds than the reported value. For `x86\x86-64` processors, the `MHzMin` and `MHzMax` fields provide information on the processors min and max speeds. 7 | 8 | `CPUInfo` from the following processors were used for testing: 9 | * Intel I7 5600u 10 | * Intel Xeon E52690 w 2 sockets 11 | * AMD R7 1800x 12 | 13 | For testing, the `sysfs` stuff use generated files and data. Please file an issue or a pull request for any gaps encountered. 14 | 15 | Please file an issue or a pull request for any additional processors/architectures. 16 | 17 | -------------------------------------------------------------------------------- /node/flat/structs/Node.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Node struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *Node) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *Node) ID() int32 { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 21 | } 22 | return 0 23 | } 24 | 25 | func (rcv *Node) CPUList() []byte { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 29 | } 30 | return nil 31 | } 32 | 33 | func NodeStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 34 | func NodeAddID(builder *flatbuffers.Builder, ID int32) { builder.PrependInt32Slot(0, ID, 0) } 35 | func NodeAddCPUList(builder *flatbuffers.Builder, CPUList flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(CPUList), 0) } 36 | func NodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 37 | -------------------------------------------------------------------------------- /processors/flat/structs/Node.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Node struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *Node) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *Node) ID() int32 { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 21 | } 22 | return 0 23 | } 24 | 25 | func (rcv *Node) CPUList() []byte { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 29 | } 30 | return nil 31 | } 32 | 33 | func NodeStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 34 | func NodeAddID(builder *flatbuffers.Builder, ID int32) { builder.PrependInt32Slot(0, ID, 0) } 35 | func NodeAddCPUList(builder *flatbuffers.Builder, CPUList flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(CPUList), 0) } 36 | func NodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 37 | -------------------------------------------------------------------------------- /sysinfo/uptime/uptime_unix_test.go: -------------------------------------------------------------------------------- 1 | package uptime 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | ) 7 | 8 | func TestGet(t *testing.T) { 9 | u, err := Get() 10 | if err != nil { 11 | t.Error(err) 12 | } 13 | if u.Timestamp == 0 { 14 | t.Error("expected timestamp to have a non-zero value; was 0") 15 | } 16 | if u.Uptime == 0 { 17 | t.Error("expected uptime to have a non-zero value; was 0") 18 | } 19 | t.Logf("%d", u) 20 | } 21 | 22 | func TestTicker(t *testing.T) { 23 | tkr, err := NewTicker(time.Millisecond) 24 | if err != nil { 25 | t.Error(err) 26 | return 27 | } 28 | tk := tkr.(*Ticker) 29 | for i := 0; i < 5; i++ { 30 | select { 31 | case <-tk.Done: 32 | break 33 | case u, ok := <-tk.Data: 34 | if !ok { 35 | break 36 | } 37 | if u.Timestamp == 0 { 38 | t.Error("expected timestamp to have a non-zero value; was 0") 39 | } 40 | if u.Uptime == 0 { 41 | t.Error("expected uptime to have a non-zero value; was 0") 42 | } 43 | case err := <-tk.Errs: 44 | t.Errorf("unexpected error: %s", err) 45 | } 46 | } 47 | tk.Stop() 48 | tk.Close() 49 | } 50 | 51 | func BenchmarkGet(b *testing.B) { 52 | var u Uptime 53 | for i := 0; i < b.N; i++ { 54 | u, _ = Get() 55 | } 56 | _ = u 57 | } 58 | -------------------------------------------------------------------------------- /cpu/cpux/flat/structs/CacheInf.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CacheInf struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *CacheInf) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *CacheInf) ID() []byte { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 21 | } 22 | return nil 23 | } 24 | 25 | func (rcv *CacheInf) Size() []byte { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 29 | } 30 | return nil 31 | } 32 | 33 | func CacheInfStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 34 | func CacheInfAddID(builder *flatbuffers.Builder, ID flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ID), 0) } 35 | func CacheInfAddSize(builder *flatbuffers.Builder, Size flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(Size), 0) } 36 | func CacheInfEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 37 | -------------------------------------------------------------------------------- /processors/flat/structs/CacheInf.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CacheInf struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *CacheInf) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *CacheInf) ID() []byte { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 21 | } 22 | return nil 23 | } 24 | 25 | func (rcv *CacheInf) Size() []byte { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 29 | } 30 | return nil 31 | } 32 | 33 | func CacheInfStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 34 | func CacheInfAddID(builder *flatbuffers.Builder, ID flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ID), 0) } 35 | func CacheInfAddSize(builder *flatbuffers.Builder, Size flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(Size), 0) } 36 | func CacheInfEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 37 | -------------------------------------------------------------------------------- /sysinfo/mem/mem_unix_test.go: -------------------------------------------------------------------------------- 1 | package mem 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | ) 7 | 8 | func TestTicker(t *testing.T) { 9 | tkr, err := NewTicker(time.Millisecond) 10 | if err != nil { 11 | t.Error(err) 12 | return 13 | } 14 | tk := tkr.(*Ticker) 15 | for i := 0; i < 5; i++ { 16 | select { 17 | case <-tk.Done: 18 | break 19 | case v, ok := <-tk.Data: 20 | if !ok { 21 | break 22 | } 23 | checkMemInfo("ticker", v, t) 24 | case err := <-tk.Errs: 25 | t.Errorf("unexpected error: %s", err) 26 | } 27 | } 28 | tk.Stop() 29 | tk.Close() 30 | } 31 | 32 | func TestGetMemInfo(t *testing.T) { 33 | m, err := Get() 34 | if err != nil { 35 | t.Error(err) 36 | } 37 | checkMemInfo("get", m, t) 38 | } 39 | 40 | func checkMemInfo(n string, m MemInfo, t *testing.T) { 41 | if m.Timestamp == 0 { 42 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 43 | } 44 | if m.TotalRAM == 0 { 45 | t.Errorf("%s: expected the TotalRAM to be non-zero, was 0", n) 46 | } 47 | if m.FreeRAM == 0 { 48 | t.Errorf("%s: expected the FreeRAM to be non-zero, was 0", n) 49 | } 50 | t.Logf("%#v\n", m) 51 | } 52 | 53 | func BenchmarkMemInfo(b *testing.B) { 54 | var tmp MemInfo 55 | for i := 0; i < b.N; i++ { 56 | _ = tmp.Get() 57 | } 58 | _ = tmp 59 | } 60 | -------------------------------------------------------------------------------- /sysinfo/loadavg/loadavg_unix_test.go: -------------------------------------------------------------------------------- 1 | package loadavg 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | ) 7 | 8 | func TestGet(t *testing.T) { 9 | l, err := Get() 10 | if err != nil { 11 | t.Error(err) 12 | } 13 | checkLoadAvg("get", l, t) 14 | } 15 | 16 | func TestTicker(t *testing.T) { 17 | tkr, err := NewTicker(time.Millisecond) 18 | if err != nil { 19 | t.Error(err) 20 | return 21 | } 22 | tk := tkr.(*Ticker) 23 | for i := 0; i < 5; i++ { 24 | select { 25 | case <-tk.Done: 26 | break 27 | case v, ok := <-tk.Data: 28 | if !ok { 29 | break 30 | } 31 | checkLoadAvg("ticker", v, t) 32 | case err := <-tk.Errs: 33 | t.Errorf("unexpected error: %s", err) 34 | } 35 | } 36 | tk.Stop() 37 | tk.Close() 38 | } 39 | 40 | func checkLoadAvg(n string, l LoadAvg, t *testing.T) { 41 | if l.One == 0 { 42 | t.Errorf("%s: expected the 1 minute load avg to be non-zero, was 0", n) 43 | } 44 | if l.Five == 0 { 45 | t.Errorf("%s: expected the 5 minute load avg to be non-zero, was 0", n) 46 | } 47 | if l.Fifteen == 0 { 48 | t.Errorf("%s: expected the 15 minute load avg to be non-zero, was 0", n) 49 | } 50 | t.Logf("%#v\n", l) 51 | } 52 | 53 | func BenchmarkLoadAvg(b *testing.B) { 54 | var tmp LoadAvg 55 | for i := 0; i < b.N; i++ { 56 | _ = tmp.Get() 57 | } 58 | _ = tmp 59 | } 60 | -------------------------------------------------------------------------------- /sysinfo/uptime/flat/structs/Uptime.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Uptime struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsUptime(buf []byte, offset flatbuffers.UOffsetT) *Uptime { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &Uptime{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *Uptime) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *Uptime) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *Uptime) Uptime() int64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func UptimeStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 41 | func UptimeAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 42 | func UptimeAddUptime(builder *flatbuffers.Builder, Uptime int64) { builder.PrependInt64Slot(1, Uptime, 0) } 43 | func UptimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 44 | -------------------------------------------------------------------------------- /node/flat/structs/Nodes.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Nodes struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsNodes(buf []byte, offset flatbuffers.UOffsetT) *Nodes { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &Nodes{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *Nodes) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *Nodes) Node(obj *Node, j int) bool { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | x := rcv._tab.Vector(o) 28 | x += flatbuffers.UOffsetT(j) * 4 29 | x = rcv._tab.Indirect(x) 30 | if obj == nil { 31 | obj = new(Node) 32 | } 33 | obj.Init(rcv._tab.Bytes, x) 34 | return true 35 | } 36 | return false 37 | } 38 | 39 | func (rcv *Nodes) NodeLength() int { 40 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 41 | if o != 0 { 42 | return rcv._tab.VectorLen(o) 43 | } 44 | return 0 45 | } 46 | 47 | func NodesStart(builder *flatbuffers.Builder) { builder.StartObject(1) } 48 | func NodesAddNode(builder *flatbuffers.Builder, Node flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(Node), 0) } 49 | func NodesStartNodeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 50 | } 51 | func NodesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 52 | -------------------------------------------------------------------------------- /system/os/os_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package os 15 | 16 | import "testing" 17 | 18 | func TestGet(t *testing.T) { 19 | os, err := Get() 20 | if err != nil { 21 | t.Errorf("unexpected error: %s", err) 22 | } 23 | if os.Name == "" { 24 | t.Error("Name: expected a value; was empty") 25 | } 26 | if os.ID == "" { 27 | t.Error("ID: expected a value; was empty") 28 | } 29 | if os.PrettyName == "" { 30 | t.Error("PrettyName: expected a value; was empty") 31 | } 32 | if os.Version == "" { 33 | t.Error("Version: expected a value; was empty") 34 | } 35 | if os.VersionID == "" { 36 | t.Error("VersionID: expected a value; was empty") 37 | } 38 | if os.HomeURL == "" { 39 | t.Error("HomeURL: expected a value; was empty") 40 | } 41 | if os.BugReportURL == "" { 42 | t.Error("BugReportURL: expected a value; was empty") 43 | } 44 | t.Logf("%#v\n", os) 45 | } 46 | 47 | func BenchmarkGet(b *testing.B) { 48 | var os *OS 49 | for i := 0; i < b.N; i++ { 50 | os, _ = Get() 51 | } 52 | _ = os 53 | } 54 | -------------------------------------------------------------------------------- /system/uptime/flat/structs/Uptime.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Uptime struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsUptime(buf []byte, offset flatbuffers.UOffsetT) *Uptime { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &Uptime{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *Uptime) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *Uptime) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *Uptime) Total() float64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetFloat64(o + rcv._tab.Pos) 36 | } 37 | return 0.0 38 | } 39 | 40 | func (rcv *Uptime) Idle() float64 { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.GetFloat64(o + rcv._tab.Pos) 44 | } 45 | return 0.0 46 | } 47 | 48 | func UptimeStart(builder *flatbuffers.Builder) { builder.StartObject(3) } 49 | func UptimeAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 50 | func UptimeAddTotal(builder *flatbuffers.Builder, Total float64) { builder.PrependFloat64Slot(1, Total, 0.0) } 51 | func UptimeAddIdle(builder *flatbuffers.Builder, Idle float64) { builder.PrependFloat64Slot(2, Idle, 0.0) } 52 | func UptimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 53 | -------------------------------------------------------------------------------- /system/version/version_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package version 15 | 16 | import "testing" 17 | 18 | func TestGet(t *testing.T) { 19 | k, err := Get() 20 | if err != nil { 21 | t.Errorf("unexpected error: %s", err) 22 | } 23 | if k.OS == "" { 24 | t.Error("OS: wanted a non-empty value; was empty") 25 | } 26 | if k.Version == "" { 27 | t.Error("Version: wanted a non-empty value; was empty") 28 | } 29 | if k.CompileUser == "" { 30 | t.Error("CompileUser: wanted a non-empty value; was empty") 31 | } 32 | if k.GCC == "" { 33 | t.Error("GCC: wanted a non-empty value; was empty") 34 | } 35 | if k.OSGCC == "" { 36 | t.Error("OSGCC: wanted a non-empty value; was empty") 37 | } 38 | if k.Type == "" { 39 | t.Error("Type: wanted a non-empty value; was empty") 40 | } 41 | if k.CompileDate == "" { 42 | t.Error("CompileDate: wanted a non-empty value; was empty") 43 | } 44 | if k.Arch == "" { 45 | t.Error("Arch: wanted a non-empty value; was empty") 46 | } 47 | t.Logf("%#v\n", k) 48 | } 49 | 50 | func BenchmarkGet(b *testing.B) { 51 | var k *Kernel 52 | p, err := NewProfiler() 53 | if err != nil { 54 | return 55 | } 56 | b.ResetTimer() 57 | for i := 0; i < b.N; i++ { 58 | k, _ = p.Get() 59 | } 60 | _ = k 61 | } 62 | -------------------------------------------------------------------------------- /net/structs/flat/DevInfo.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package flat 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type DevInfo struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsDevInfo(buf []byte, offset flatbuffers.UOffsetT) *DevInfo { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &DevInfo{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *DevInfo) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *DevInfo) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *DevInfo) Device(obj *Device, j int) bool { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | x := rcv._tab.Vector(o) 36 | x += flatbuffers.UOffsetT(j) * 4 37 | x = rcv._tab.Indirect(x) 38 | if obj == nil { 39 | obj = new(Device) 40 | } 41 | obj.Init(rcv._tab.Bytes, x) 42 | return true 43 | } 44 | return false 45 | } 46 | 47 | func (rcv *DevInfo) DeviceLength() int { 48 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 49 | if o != 0 { 50 | return rcv._tab.VectorLen(o) 51 | } 52 | return 0 53 | } 54 | 55 | func DevInfoStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 56 | func DevInfoAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 57 | func DevInfoAddDevice(builder *flatbuffers.Builder, Device flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(Device), 0) } 58 | func DevInfoStartDeviceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 59 | } 60 | func DevInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 61 | -------------------------------------------------------------------------------- /disk/structs/structs.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package structs defines the data structures for disk. 15 | package structs 16 | 17 | // DiskStats holds the information for all of the block devices. 18 | type DiskStats struct { 19 | Timestamp int64 `json:"timestamp"` 20 | Device []Device `json:"device"` 21 | } 22 | 23 | // Device contains information for a given block device. 24 | type Device struct { 25 | Major uint32 26 | Minor uint32 27 | Name string `json:"name"` 28 | ReadsCompleted uint64 `json:"reads_completed"` 29 | ReadsMerged uint64 `json:"reads_merged"` 30 | ReadSectors uint64 `json:"read_sectors"` 31 | ReadingTime uint64 `json:"reading_time"` 32 | WritesCompleted uint64 `json:"writes_completed"` 33 | WritesMerged uint64 `json:"writes_merged"` 34 | WrittenSectors uint64 `json:"written_sectors"` 35 | WritingTime uint64 `json:"writing_time"` 36 | IOInProgress int32 `json:"io_in_progress"` 37 | IOTime uint64 `json:"io_time"` 38 | WeightedIOTime uint64 `json:"weighted_io_time"` 39 | } 40 | 41 | // DiskUsage holds the usage information for all of the block devices. 42 | type DiskUsage struct { 43 | Timestamp int64 `json:"timestamp"` 44 | TimeDelta int64 `json:"time_delta"` 45 | Device []Device `json:"device"` 46 | } 47 | -------------------------------------------------------------------------------- /disk/structs/flat/DiskStats.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package flat 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type DiskStats struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsDiskStats(buf []byte, offset flatbuffers.UOffsetT) *DiskStats { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &DiskStats{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *DiskStats) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *DiskStats) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *DiskStats) Device(obj *Device, j int) bool { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | x := rcv._tab.Vector(o) 36 | x += flatbuffers.UOffsetT(j) * 4 37 | x = rcv._tab.Indirect(x) 38 | if obj == nil { 39 | obj = new(Device) 40 | } 41 | obj.Init(rcv._tab.Bytes, x) 42 | return true 43 | } 44 | return false 45 | } 46 | 47 | func (rcv *DiskStats) DeviceLength() int { 48 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 49 | if o != 0 { 50 | return rcv._tab.VectorLen(o) 51 | } 52 | return 0 53 | } 54 | 55 | func DiskStatsStart(builder *flatbuffers.Builder) { builder.StartObject(2) } 56 | func DiskStatsAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 57 | func DiskStatsAddDevice(builder *flatbuffers.Builder, Device flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(Device), 0) } 58 | func DiskStatsStartDeviceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 59 | } 60 | func DiskStatsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 61 | -------------------------------------------------------------------------------- /cpu/cpuinfo/test/cpuinfo_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpuinfo 15 | 16 | import ( 17 | "testing" 18 | 19 | "github.com/mohae/joefriday" 20 | "github.com/mohae/joefriday/cpu/cpuinfo" 21 | "github.com/mohae/joefriday/testinfo" 22 | ) 23 | 24 | func TestGeti75600u(t *testing.T) { 25 | tProc, err := joefriday.NewTempFileProc("intel", "i75600u", testinfo.I75600uCPUInfo) 26 | if err != nil { 27 | t.Fatal(err) 28 | } 29 | defer tProc.Remove() 30 | prof, err := cpuinfo.NewProfiler() 31 | if err != nil { 32 | t.Fatal(err) 33 | } 34 | prof.Procer = tProc 35 | inf, err := prof.Get() 36 | if err != nil { 37 | t.Errorf("unexpected error: %s", err) 38 | } 39 | err = testinfo.ValidateI75600uCPUInfo(inf) 40 | if err != nil { 41 | t.Error(err) 42 | } 43 | t.Logf("%#v", inf) 44 | } 45 | 46 | func TestGetR71800x(t *testing.T) { 47 | tProc, err := joefriday.NewTempFileProc("amd", "r71800x", testinfo.R71800xCPUInfo) 48 | if err != nil { 49 | t.Fatal(err) 50 | } 51 | defer tProc.Remove() 52 | prof, err := cpuinfo.NewProfiler() 53 | if err != nil { 54 | t.Fatal(err) 55 | } 56 | prof.Procer = tProc 57 | inf, err := prof.Get() 58 | if err != nil { 59 | t.Errorf("unexpected error: %s", err) 60 | } 61 | err = testinfo.ValidateR71800xCPUInfo(inf) 62 | if err != nil { 63 | t.Error(err) 64 | } 65 | t.Log(inf) 66 | } 67 | -------------------------------------------------------------------------------- /sysinfo/loadavg/flat/structs/LoadAvg.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type LoadAvg struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsLoadAvg(buf []byte, offset flatbuffers.UOffsetT) *LoadAvg { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &LoadAvg{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *LoadAvg) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *LoadAvg) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *LoadAvg) One() float64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetFloat64(o + rcv._tab.Pos) 36 | } 37 | return 0.0 38 | } 39 | 40 | func (rcv *LoadAvg) Five() float64 { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.GetFloat64(o + rcv._tab.Pos) 44 | } 45 | return 0.0 46 | } 47 | 48 | func (rcv *LoadAvg) Fifteen() float64 { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.GetFloat64(o + rcv._tab.Pos) 52 | } 53 | return 0.0 54 | } 55 | 56 | func LoadAvgStart(builder *flatbuffers.Builder) { builder.StartObject(4) } 57 | func LoadAvgAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 58 | func LoadAvgAddOne(builder *flatbuffers.Builder, One float64) { builder.PrependFloat64Slot(1, One, 0.0) } 59 | func LoadAvgAddFive(builder *flatbuffers.Builder, Five float64) { builder.PrependFloat64Slot(2, Five, 0.0) } 60 | func LoadAvgAddFifteen(builder *flatbuffers.Builder, Fifteen float64) { builder.PrependFloat64Slot(3, Fifteen, 0.0) } 61 | func LoadAvgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 62 | -------------------------------------------------------------------------------- /system/uptime/uptime_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package uptime 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | ) 20 | 21 | func TestGet(t *testing.T) { 22 | u, err := Get() 23 | if err != nil { 24 | t.Errorf("unexpected error: %s", err) 25 | } 26 | checkUptime("get", u, t) 27 | t.Logf("%#v\n", u) 28 | } 29 | 30 | func TestTicker(t *testing.T) { 31 | tkr, err := NewTicker(time.Millisecond) 32 | if err != nil { 33 | t.Error(err) 34 | return 35 | } 36 | tk := tkr.(*Ticker) 37 | for i := 0; i < 5; i++ { 38 | select { 39 | case <-tk.Done: 40 | break 41 | case v, ok := <-tk.Data: 42 | if !ok { 43 | break 44 | } 45 | checkUptime("ticker", v, t) 46 | case err := <-tk.Errs: 47 | t.Errorf("unexpected error: %s", err) 48 | } 49 | } 50 | tk.Stop() 51 | tk.Close() 52 | } 53 | 54 | func checkUptime(n string, u Uptime, t *testing.T) { 55 | if u.Timestamp == 0 { 56 | t.Errorf("expected Timestamp to be a non-zero value; got 0") 57 | } 58 | if u.Total == 0 { 59 | t.Errorf("expected total to be a non-zero value; got 0") 60 | } 61 | if u.Idle == 0 { 62 | t.Errorf("expected idle to be a non-zero value; got 0") 63 | } 64 | } 65 | 66 | func BenchmarkGet(b *testing.B) { 67 | var u Uptime 68 | p, err := NewProfiler() 69 | if err != nil { 70 | return 71 | } 72 | b.ResetTimer() 73 | for i := 0; i < b.N; i++ { 74 | u, _ = p.Get() 75 | } 76 | _ = u 77 | } 78 | -------------------------------------------------------------------------------- /cpu/cpufreq/flat/structs/CPU.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CPU struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *CPU) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *CPU) Processor() int32 { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 21 | } 22 | return 0 23 | } 24 | 25 | func (rcv *CPU) CPUMHz() float32 { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 29 | } 30 | return 0.0 31 | } 32 | 33 | func (rcv *CPU) PhysicalID() int32 { 34 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 35 | if o != 0 { 36 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 37 | } 38 | return 0 39 | } 40 | 41 | func (rcv *CPU) CoreID() int32 { 42 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 43 | if o != 0 { 44 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 45 | } 46 | return 0 47 | } 48 | 49 | func (rcv *CPU) APICID() int32 { 50 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 51 | if o != 0 { 52 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 53 | } 54 | return 0 55 | } 56 | 57 | func CPUStart(builder *flatbuffers.Builder) { builder.StartObject(5) } 58 | func CPUAddProcessor(builder *flatbuffers.Builder, Processor int32) { builder.PrependInt32Slot(0, Processor, 0) } 59 | func CPUAddCPUMHz(builder *flatbuffers.Builder, CPUMHz float32) { builder.PrependFloat32Slot(1, CPUMHz, 0.0) } 60 | func CPUAddPhysicalID(builder *flatbuffers.Builder, PhysicalID int32) { builder.PrependInt32Slot(2, PhysicalID, 0) } 61 | func CPUAddCoreID(builder *flatbuffers.Builder, CoreID int32) { builder.PrependInt32Slot(3, CoreID, 0) } 62 | func CPUAddAPICID(builder *flatbuffers.Builder, APICID int32) { builder.PrependInt32Slot(4, APICID, 0) } 63 | func CPUEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 64 | -------------------------------------------------------------------------------- /bench/README.md: -------------------------------------------------------------------------------- 1 | bench 2 | ===== 3 | 4 | Comparison benchmarks for `joefriday` and other packages that provide similar information. Some of these 3rd party versions may not get the same information as the `joefriday` bench versions. 5 | 6 | ## Results 7 | ####CPU 8 | Name|Ops|ns/Op|Bytes/Op|Allocs/Op 9 | :--|--:|--:|--:|--: 10 | joefriday/cpu/facts.Get|100000|10481|800|18 11 | joefriday/cpu/stats.Get|200000|8346|264|4 12 | DataDog/gohai/cpu.Cpu.Collect|5000|306624|999877|822 13 | shirou/gopsutil/cpu.Info|50000|38845|9656|120 14 | shirou/gopsutil/cpu.Times|50000|31120|10512|28 15 | 16 | ####Memory 17 | Name|Ops|ns/Op|Bytes/Op|Allocs/Op 18 | :--|--:|--:|--:|--: 19 | joefriday/mem.Get|200000|9954|352|1 20 | joefriday/sysinfo/mem.Info.Get|10000000|189|0|0 21 | cloudfoundry/gosigar.Mem.Get|50000|33532|13912|108 22 | DataDog/gohai/memory.Memory.Collect|2000|1037399|3543120|2683 23 | guillermo/go.procmeminfo.MemInfo.Update|30000|42205|8216|133 24 | shirou/gopsutil/mem.VirtualMemory|30000|52938|12296|264 25 | 26 | ####Network 27 | Name|Ops|ns/Op|Bytes/Op|Allocs/Op 28 | :--|--:|--:|--:|--: 29 | joefriday/net/info.Get|300000|5002|328|4 30 | joefriday/net/usage.Get|300000|5544|664|6 31 | DataDog/gohai/network|10000|109043|55109|222 32 | shirou/gopsutil/net|30000|55134|25568|134 33 | shirou/gopsutil/net/IOCounters|100000|21182|6200|26 34 | 35 | ####Platform 36 | Name|Ops|ns/Op|Bytes/Op|Allocs/Op 37 | :--|--:|--:|--:|--: 38 | joefriday/platform/kernel.Get|1000000|1789|288|7 39 | joefriday/platform/release.Get|1000000|1771|229|7 40 | DataDog/gohai/platform.Platform.Collect|1000|1491460|177305|400 41 | joefriday/platform/loadavg.Get|1000000|1754|12|3 42 | joefriday/sysinfo/load.LoadAvg.Get|10000000|192|0|0 43 | cloudfoundry/gosigar.LoadAverage.Get|200000|8245|2440|9 44 | shirou/gopsutil/load.Avg|200000|9014|2488|11 45 | shirou/gopsutil/load.Misc|50000|34513|8744|20 46 | joefriday/platform/uptime.Get|1000000|1438|32|2 47 | joefriday/sysinfo/uptime.Uptime.Get|10000000|189|0|0 48 | cloudfoundry/gosigar.Uptime.Get|10000000|136|0|0 49 | -------------------------------------------------------------------------------- /net/netdev/netdev_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package netdev 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/net/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | inf, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | checkInfo("get", inf, t) 30 | t.Logf("%#v\n", inf) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case v, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | checkInfo("ticker", v, t) 49 | case err := <-tk.Errs: 50 | t.Errorf("unexpected error: %s", err) 51 | } 52 | } 53 | tk.Stop() 54 | tk.Close() 55 | } 56 | 57 | func checkInfo(n string, dev *structs.DevInfo, t *testing.T) { 58 | if dev.Timestamp == 0 { 59 | t.Errorf("%s: expected timestamp to be a non-zero value; was 0", n) 60 | } 61 | if len(dev.Device) == 0 { 62 | t.Errorf("%s: expected interfaces; got none", n) 63 | return 64 | } 65 | // check name 66 | for i, v := range dev.Device { 67 | if v.Name == "" { 68 | t.Errorf("%s: %d: expected inteface to have a name; was empty", n, i) 69 | } 70 | } 71 | } 72 | 73 | func BenchmarkGet(b *testing.B) { 74 | var inf *structs.DevInfo 75 | p, _ := NewProfiler() 76 | b.ResetTimer() 77 | for i := 0; i < b.N; i++ { 78 | inf, _ = p.Get() 79 | } 80 | _ = inf 81 | } 82 | -------------------------------------------------------------------------------- /net/netusage/netusage_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package netusage 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/net/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := NewProfiler() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | u, err := p.Get() 30 | if err != nil { 31 | t.Errorf("got %s, want nil", err) 32 | return 33 | } 34 | checkUsage("get", u, t) 35 | t.Logf("%#v\n", u) 36 | } 37 | 38 | func TestTicker(t *testing.T) { 39 | tkr, err := NewTicker(time.Millisecond) 40 | if err != nil { 41 | t.Error(err) 42 | return 43 | } 44 | tk := tkr.(*Ticker) 45 | for i := 0; i < 5; i++ { 46 | select { 47 | case <-tk.Done: 48 | break 49 | case v, ok := <-tk.Data: 50 | if !ok { 51 | break 52 | } 53 | checkUsage("ticker", v, t) 54 | case err := <-tk.Errs: 55 | t.Errorf("unexpected error: %s", err) 56 | } 57 | } 58 | tk.Stop() 59 | tk.Close() 60 | } 61 | 62 | func checkUsage(n string, u *structs.DevUsage, t *testing.T) { 63 | if u.Timestamp == 0 { 64 | t.Errorf("%s: expected timestamp to be a non-zero value; was 0", n) 65 | } 66 | if u.TimeDelta == 0 { 67 | t.Errorf("%s: expected TimeDelta to be a non-zero value; was 0", n) 68 | } 69 | if len(u.Device) == 0 { 70 | t.Errorf("%s: expected devices; got none", n) 71 | return 72 | } 73 | // check name 74 | for i, v := range u.Device { 75 | if v.Name == "" { 76 | t.Errorf("%s: %d: expected devices to have a name; was empty", n, i) 77 | } 78 | } 79 | } 80 | -------------------------------------------------------------------------------- /cpu/cpuinfo/flat/structs/CPUInfo.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CPUInfo struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsCPUInfo(buf []byte, offset flatbuffers.UOffsetT) *CPUInfo { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &CPUInfo{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *CPUInfo) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *CPUInfo) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *CPUInfo) Sockets() int32 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *CPUInfo) CPU(obj *CPU, j int) bool { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | x := rcv._tab.Vector(o) 44 | x += flatbuffers.UOffsetT(j) * 4 45 | x = rcv._tab.Indirect(x) 46 | if obj == nil { 47 | obj = new(CPU) 48 | } 49 | obj.Init(rcv._tab.Bytes, x) 50 | return true 51 | } 52 | return false 53 | } 54 | 55 | func (rcv *CPUInfo) CPULength() int { 56 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 57 | if o != 0 { 58 | return rcv._tab.VectorLen(o) 59 | } 60 | return 0 61 | } 62 | 63 | func CPUInfoStart(builder *flatbuffers.Builder) { builder.StartObject(3) } 64 | func CPUInfoAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 65 | func CPUInfoAddSockets(builder *flatbuffers.Builder, Sockets int32) { builder.PrependInt32Slot(1, Sockets, 0) } 66 | func CPUInfoAddCPU(builder *flatbuffers.Builder, CPU flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(CPU), 0) } 67 | func CPUInfoStartCPUVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 68 | } 69 | func CPUInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 70 | -------------------------------------------------------------------------------- /net/netusage/flat/netusage_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package netusage 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/net/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := NewProfiler() 25 | if err != nil { 26 | t.Errorf("unexpected error: %s", err) 27 | return 28 | } 29 | b, err := p.Get() 30 | if err != nil { 31 | t.Errorf("unexpected error: %s", err) 32 | return 33 | } 34 | u := Deserialize(b) 35 | t.Logf("%#v\n", u) 36 | checkUsage("get", u, t) 37 | } 38 | 39 | func TestTicker(t *testing.T) { 40 | tkr, err := NewTicker(time.Millisecond) 41 | if err != nil { 42 | t.Error(err) 43 | return 44 | } 45 | tk := tkr.(*Ticker) 46 | for i := 0; i < 5; i++ { 47 | select { 48 | case <-tk.Done: 49 | break 50 | case v, ok := <-tk.Data: 51 | if !ok { 52 | break 53 | } 54 | u := Deserialize(v) 55 | checkUsage("ticker", u, t) 56 | case err := <-tk.Errs: 57 | t.Errorf("unexpected error: %s", err) 58 | } 59 | } 60 | tk.Stop() 61 | tk.Close() 62 | } 63 | 64 | func checkUsage(n string, u *structs.DevUsage, t *testing.T) { 65 | if u.Timestamp == 0 { 66 | t.Errorf("%s: expected timestamp to be a non-zero value; was 0", n) 67 | } 68 | if u.TimeDelta == 0 { 69 | t.Errorf("%s: expected TimeDelta to be a non-zero value; was 0", n) 70 | } 71 | if len(u.Device) == 0 { 72 | t.Error("%s: expected devices; got none", n) 73 | return 74 | } 75 | // check name 76 | for i, v := range u.Device { 77 | if v.Name == "" { 78 | t.Errorf("%s: %d: expected device to have a name; was empty", n, i) 79 | } 80 | } 81 | } 82 | -------------------------------------------------------------------------------- /cpu/cpufreq/flat/structs/Frequency.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Frequency struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsFrequency(buf []byte, offset flatbuffers.UOffsetT) *Frequency { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &Frequency{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *Frequency) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *Frequency) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *Frequency) Sockets() int32 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *Frequency) CPU(obj *CPU, j int) bool { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | x := rcv._tab.Vector(o) 44 | x += flatbuffers.UOffsetT(j) * 4 45 | x = rcv._tab.Indirect(x) 46 | if obj == nil { 47 | obj = new(CPU) 48 | } 49 | obj.Init(rcv._tab.Bytes, x) 50 | return true 51 | } 52 | return false 53 | } 54 | 55 | func (rcv *Frequency) CPULength() int { 56 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 57 | if o != 0 { 58 | return rcv._tab.VectorLen(o) 59 | } 60 | return 0 61 | } 62 | 63 | func FrequencyStart(builder *flatbuffers.Builder) { builder.StartObject(3) } 64 | func FrequencyAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 65 | func FrequencyAddSockets(builder *flatbuffers.Builder, Sockets int32) { builder.PrependInt32Slot(1, Sockets, 0) } 66 | func FrequencyAddCPU(builder *flatbuffers.Builder, CPU flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(CPU), 0) } 67 | func FrequencyStartCPUVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 68 | } 69 | func FrequencyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 70 | -------------------------------------------------------------------------------- /net/structs/flat/DevUsage.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package flat 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type DevUsage struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsDevUsage(buf []byte, offset flatbuffers.UOffsetT) *DevUsage { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &DevUsage{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *DevUsage) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *DevUsage) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *DevUsage) TimeDelta() int64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *DevUsage) Device(obj *Device, j int) bool { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | x := rcv._tab.Vector(o) 44 | x += flatbuffers.UOffsetT(j) * 4 45 | x = rcv._tab.Indirect(x) 46 | if obj == nil { 47 | obj = new(Device) 48 | } 49 | obj.Init(rcv._tab.Bytes, x) 50 | return true 51 | } 52 | return false 53 | } 54 | 55 | func (rcv *DevUsage) DeviceLength() int { 56 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 57 | if o != 0 { 58 | return rcv._tab.VectorLen(o) 59 | } 60 | return 0 61 | } 62 | 63 | func DevUsageStart(builder *flatbuffers.Builder) { builder.StartObject(3) } 64 | func DevUsageAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 65 | func DevUsageAddTimeDelta(builder *flatbuffers.Builder, TimeDelta int64) { builder.PrependInt64Slot(1, TimeDelta, 0) } 66 | func DevUsageAddDevice(builder *flatbuffers.Builder, Device flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(Device), 0) } 67 | func DevUsageStartDeviceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 68 | } 69 | func DevUsageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 70 | -------------------------------------------------------------------------------- /net/structs/structs.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package structs defines the data structures for net. 15 | package structs 16 | 17 | // Device contains information for a given network device. 18 | type Device struct { 19 | Name string `json:"name"` 20 | RBytes int64 `json:"receive_bytes"` 21 | RPackets int64 `json:"receive_packets"` 22 | RErrs int64 `json:"receive_errs"` 23 | RDrop int64 `json:"receive_drop"` 24 | RFIFO int64 `json:"recieve_fifo"` 25 | RFrame int64 `json:"receive_frame"` 26 | RCompressed int64 `json:"receive_compressed"` 27 | RMulticast int64 `json:"receive_multicast"` 28 | TBytes int64 `json:"transmit_bytes"` 29 | TPackets int64 `json:"transmit_packets"` 30 | TErrs int64 `json:"transmit_errs"` 31 | TDrop int64 `json:"transmit_drop"` 32 | TFIFO int64 `json:"transmit_fifo"` 33 | TColls int64 `json:"transmit_colls"` 34 | TCarrier int64 `json:"transmit_carrier"` 35 | TCompressed int64 `json:"transmit_compressed"` 36 | } 37 | 38 | // DevInfo contains information about all current network devices. 39 | type DevInfo struct { 40 | Timestamp int64 `json:"timestamp"` 41 | Device []Device `json:"devices"` 42 | } 43 | 44 | // DevUsage contains information about the usage of all current network 45 | // devices. Usage is calculated as the delta between two /proc/net/dev 46 | // snapshots; the TimeDelta field holds the time elapsed between the 47 | // two snapshots used to calculate the usage. 48 | type DevUsage struct { 49 | Timestamp int64 `json:"timestamp"` 50 | TimeDelta int64 `json:"time_delta"` 51 | Device []Device `json:"devices"` 52 | } 53 | -------------------------------------------------------------------------------- /disk/diskstats/diskstats_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package diskstats 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/disk/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | s, err := Get() 25 | if err != nil { 26 | t.Errorf("unexpected error: %s", err) 27 | return 28 | } 29 | checkStats("get", s, t) 30 | } 31 | 32 | func TestTicker(t *testing.T) { 33 | tkr, err := NewTicker(time.Millisecond) 34 | if err != nil { 35 | t.Error(err) 36 | return 37 | } 38 | tk := tkr.(*Ticker) 39 | for i := 0; i < 5; i++ { 40 | select { 41 | case <-tk.Done: 42 | break 43 | case v, ok := <-tk.Data: 44 | if !ok { 45 | break 46 | } 47 | checkStats("ticker", v, t) 48 | case err := <-tk.Errs: 49 | t.Errorf("unexpected error: %s", err) 50 | } 51 | } 52 | tk.Stop() 53 | tk.Close() 54 | } 55 | 56 | func checkStats(n string, s *structs.DiskStats, t *testing.T) { 57 | if s.Timestamp == 0 { 58 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 59 | } 60 | if len(s.Device) == 0 { 61 | t.Errorf("%s: expected there to be devices; didn't get any", n) 62 | } 63 | for i := 0; i < len(s.Device); i++ { 64 | if s.Device[i].Major == 0 { 65 | t.Errorf("%s: Device %d: Major: wanted a non-zero value, was 0", n, i) 66 | } 67 | if s.Device[i].Name == "" { 68 | t.Errorf("%s: Device %d: Name: wanted a non-empty value; was empty", n, i) 69 | } 70 | } 71 | } 72 | 73 | var stts *structs.DiskStats 74 | 75 | func BenchmarkGet(b *testing.B) { 76 | p, _ := NewProfiler() 77 | b.ResetTimer() 78 | for i := 0; i < b.N; i++ { 79 | stts, _ = p.Get() 80 | } 81 | _ = stts 82 | } 83 | -------------------------------------------------------------------------------- /disk/structs/flat/DiskUsage.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package flat 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type DiskUsage struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsDiskUsage(buf []byte, offset flatbuffers.UOffsetT) *DiskUsage { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &DiskUsage{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *DiskUsage) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *DiskUsage) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *DiskUsage) TimeDelta() int64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *DiskUsage) Device(obj *Device, j int) bool { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | x := rcv._tab.Vector(o) 44 | x += flatbuffers.UOffsetT(j) * 4 45 | x = rcv._tab.Indirect(x) 46 | if obj == nil { 47 | obj = new(Device) 48 | } 49 | obj.Init(rcv._tab.Bytes, x) 50 | return true 51 | } 52 | return false 53 | } 54 | 55 | func (rcv *DiskUsage) DeviceLength() int { 56 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 57 | if o != 0 { 58 | return rcv._tab.VectorLen(o) 59 | } 60 | return 0 61 | } 62 | 63 | func DiskUsageStart(builder *flatbuffers.Builder) { builder.StartObject(3) } 64 | func DiskUsageAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 65 | func DiskUsageAddTimeDelta(builder *flatbuffers.Builder, TimeDelta int64) { builder.PrependInt64Slot(1, TimeDelta, 0) } 66 | func DiskUsageAddDevice(builder *flatbuffers.Builder, Device flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(Device), 0) } 67 | func DiskUsageStartDeviceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 68 | } 69 | func DiskUsageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 70 | -------------------------------------------------------------------------------- /disk/diskusage/diskusage_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package diskusage 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/disk/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := NewProfiler() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | time.Sleep(time.Duration(300) * time.Millisecond) 30 | st, err := p.Get() 31 | if err != nil { 32 | t.Errorf("got %s, want nil", err) 33 | return 34 | } 35 | checkUsage("get", st, t) 36 | } 37 | 38 | func TestTicker(t *testing.T) { 39 | tkr, err := NewTicker(time.Millisecond) 40 | if err != nil { 41 | t.Error(err) 42 | return 43 | } 44 | tk := tkr.(*Ticker) 45 | for i := 0; i < 5; i++ { 46 | select { 47 | case <-tk.Done: 48 | break 49 | case v, ok := <-tk.Data: 50 | if !ok { 51 | break 52 | } 53 | checkUsage("ticker", v, t) 54 | case err := <-tk.Errs: 55 | t.Errorf("unexpected error: %s", err) 56 | } 57 | } 58 | tk.Stop() 59 | tk.Close() 60 | } 61 | 62 | func checkUsage(n string, s *structs.DiskUsage, t *testing.T) { 63 | if s.Timestamp == 0 { 64 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 65 | } 66 | if s.TimeDelta == 0 { 67 | t.Errorf("%s: TimeDelta: wanted non-zero value; got 0", n) 68 | } 69 | if len(s.Device) == 0 { 70 | t.Errorf("%s: expected there to be devices; didn't get any", n) 71 | } 72 | for i := 0; i < len(s.Device); i++ { 73 | if s.Device[i].Major == 0 { 74 | t.Errorf("%s: Device %d: Major: wanted a non-zero value, was 0", n, i) 75 | } 76 | if s.Device[i].Name == "" { 77 | t.Errorf("%s: Device %d: Name: wanted a non-empty value; was empty", n, i) 78 | } 79 | } 80 | t.Logf("%#v\n", s) 81 | } 82 | -------------------------------------------------------------------------------- /sysinfo/uptime/json/uptime_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package uptime 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | up "github.com/mohae/joefriday/sysinfo/uptime" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | u, err := Deserialize(p) 30 | if err != nil { 31 | t.Errorf("unexpected error: %s", err) 32 | return 33 | } 34 | checkUptime("get", u, t) 35 | } 36 | 37 | func TestTicker(t *testing.T) { 38 | tkr, err := NewTicker(time.Millisecond) 39 | if err != nil { 40 | t.Error(err) 41 | return 42 | } 43 | tk := tkr.(*Ticker) 44 | for i := 0; i < 5; i++ { 45 | select { 46 | case <-tk.Done: 47 | break 48 | case p, ok := <-tk.Data: 49 | if !ok { 50 | break 51 | } 52 | u, err := Deserialize(p) 53 | if err != nil { 54 | t.Errorf("unexpected error: %s", err) 55 | continue 56 | } 57 | checkUptime("ticker", u, t) 58 | case err := <-tk.Errs: 59 | t.Errorf("unexpected error: %s", err) 60 | } 61 | } 62 | tk.Stop() 63 | tk.Close() 64 | } 65 | 66 | func checkUptime(n string, u *up.Uptime, t *testing.T) { 67 | if u.Timestamp == 0 { 68 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 69 | } 70 | if u.Uptime == 0 { 71 | t.Errorf("%s: expected the Uptime to be non-zero, was 0", n) 72 | } 73 | t.Logf("%#v\n", u) 74 | } 75 | 76 | func BenchmarkGet(b *testing.B) { 77 | var tmp []byte 78 | for i := 0; i < b.N; i++ { 79 | tmp, _ = Get() 80 | } 81 | _ = tmp 82 | } 83 | 84 | func BenchmarkDeserialize(b *testing.B) { 85 | var u *up.Uptime 86 | p, _ := Get() 87 | b.ResetTimer() 88 | for i := 0; i < b.N; i++ { 89 | u, _ = Deserialize(p) 90 | } 91 | _ = u 92 | } 93 | -------------------------------------------------------------------------------- /sysinfo/uptime/flat/uptime_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package uptime 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | up "github.com/mohae/joefriday/sysinfo/uptime" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | u := Deserialize(p) 30 | checkUptime("get", u, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case p, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | u := Deserialize(p) 49 | checkUptime("ticker", u, t) 50 | case err := <-tk.Errs: 51 | t.Errorf("unexpected error: %s", err) 52 | } 53 | } 54 | tk.Stop() 55 | tk.Close() 56 | } 57 | 58 | func checkUptime(n string, u *up.Uptime, t *testing.T) { 59 | if u.Timestamp == 0 { 60 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 61 | } 62 | if u.Uptime == 0 { 63 | t.Errorf("%s: expected the One to be non-zero, was 0", n) 64 | } 65 | t.Logf("%#v\n", u) 66 | } 67 | 68 | func BenchmarkGet(b *testing.B) { 69 | var tmp []byte 70 | for i := 0; i < b.N; i++ { 71 | tmp, _ = Get() 72 | } 73 | _ = tmp 74 | } 75 | 76 | func BenchmarkSerialize(b *testing.B) { 77 | var tmp []byte 78 | var u up.Uptime 79 | u.Get() 80 | b.ResetTimer() 81 | for i := 0; i < b.N; i++ { 82 | tmp = Serialize(&u) 83 | } 84 | _ = tmp 85 | } 86 | 87 | func BenchmarkDeserialize(b *testing.B) { 88 | var u *up.Uptime 89 | p, _ := Get() 90 | b.ResetTimer() 91 | for i := 0; i < b.N; i++ { 92 | u = Deserialize(p) 93 | } 94 | _ = u 95 | } 96 | -------------------------------------------------------------------------------- /system/loadavg/loadavg_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package loadavg 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | ) 20 | 21 | func TestGet(t *testing.T) { 22 | inf, err := Get() 23 | if err != nil { 24 | t.Errorf("unexpected error: %s", err) 25 | return 26 | } 27 | checkLoad("ticker", inf, t) 28 | t.Logf("%#v\n", inf) 29 | } 30 | 31 | func TestTicker(t *testing.T) { 32 | tkr, err := NewTicker(time.Millisecond) 33 | if err != nil { 34 | t.Error(err) 35 | return 36 | } 37 | tk := tkr.(*Ticker) 38 | for i := 0; i < 5; i++ { 39 | select { 40 | case <-tk.Done: 41 | break 42 | case v, ok := <-tk.Data: 43 | if !ok { 44 | break 45 | } 46 | checkLoad("ticker", v, t) 47 | case err := <-tk.Errs: 48 | t.Errorf("unexpected error: %s", err) 49 | } 50 | } 51 | tk.Stop() 52 | tk.Close() 53 | } 54 | 55 | func checkLoad(n string, la LoadAvg, t *testing.T) { 56 | if la.Timestamp == 0 { 57 | t.Errorf("%s: expected Timestamp to be a non-zero value; got 0", n) 58 | } 59 | if la.Minute == 0 { 60 | t.Errorf("%s: expected Minute to be a non-zero value; got 0", n) 61 | } 62 | if la.Five == 0 { 63 | t.Errorf("%s: expected Five to be a non-zero value; got 0", n) 64 | } 65 | if la.Fifteen == 0 { 66 | t.Errorf("%s: expected Fifteen to be a non-zero value; got 0", n) 67 | } 68 | if la.Running == 0 { 69 | t.Errorf("%s: expected Running to be a non-zero value; got 0", n) 70 | } 71 | if la.Total == 0 { 72 | t.Errorf("%s: expected Total to be a non-zero value; got 0", n) 73 | } 74 | if la.PID == 0 { 75 | t.Errorf("%s: expected PID to be a non-zero value; got 0", n) 76 | } 77 | } 78 | 79 | func BenchmarkGet(b *testing.B) { 80 | var la LoadAvg 81 | p, err := NewProfiler() 82 | if err != nil { 83 | return 84 | } 85 | b.ResetTimer() 86 | for i := 0; i < b.N; i++ { 87 | la, _ = p.Get() 88 | } 89 | _ = la 90 | } 91 | -------------------------------------------------------------------------------- /disk/diskusage/json/diskusage_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package diskusage 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/disk/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := NewProfiler() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | b, err := p.Get() 30 | if err != nil { 31 | t.Errorf("got %s, want nil", err) 32 | return 33 | } 34 | u, err := Unmarshal(b) 35 | if err != nil { 36 | t.Errorf("got %s, want nil", err) 37 | return 38 | } 39 | checkUsage("get", u, t) 40 | t.Logf("%#v\n", u) 41 | } 42 | 43 | func TestTicker(t *testing.T) { 44 | tkr, err := NewTicker(time.Millisecond) 45 | if err != nil { 46 | t.Error(err) 47 | return 48 | } 49 | tk := tkr.(*Ticker) 50 | for i := 0; i < 5; i++ { 51 | select { 52 | case <-tk.Done: 53 | break 54 | case v, ok := <-tk.Data: 55 | if !ok { 56 | break 57 | } 58 | u, err := Deserialize(v) 59 | if err != nil { 60 | t.Error(err) 61 | continue 62 | } 63 | checkUsage("ticker", u, t) 64 | case err := <-tk.Errs: 65 | t.Errorf("unexpected error: %s", err) 66 | } 67 | } 68 | tk.Stop() 69 | tk.Close() 70 | } 71 | 72 | func checkUsage(n string, u *structs.DiskUsage, t *testing.T) { 73 | if u.Timestamp == 0 { 74 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 75 | } 76 | if u.TimeDelta == 0 { 77 | t.Errorf("%s: TimeDelta: wanted non-zero value; got 0", n) 78 | } 79 | if len(u.Device) == 0 { 80 | t.Errorf("%s: expected there to be devices; didn't get any", n) 81 | } 82 | for i := 0; i < len(u.Device); i++ { 83 | if u.Device[i].Major == 0 { 84 | t.Errorf("%s: Device %d: Major: wanted a non-zero value, was 0", n, i) 85 | } 86 | if u.Device[i].Name == "" { 87 | t.Errorf("%s: Device %d: Name: wanted a non-empty value; was empty", n, i) 88 | } 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /sysinfo/mem/json/mem_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package mem 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | m "github.com/mohae/joefriday/sysinfo/mem" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | inf, err := Deserialize(p) 30 | if err != nil { 31 | t.Errorf("unexpected error: %s", err) 32 | return 33 | } 34 | checkMemInfo("get", inf, t) 35 | } 36 | 37 | func TestTicker(t *testing.T) { 38 | tkr, err := NewTicker(time.Millisecond) 39 | if err != nil { 40 | t.Error(err) 41 | return 42 | } 43 | tk := tkr.(*Ticker) 44 | for i := 0; i < 5; i++ { 45 | select { 46 | case <-tk.Done: 47 | break 48 | case p, ok := <-tk.Data: 49 | if !ok { 50 | break 51 | } 52 | inf, err := Deserialize(p) 53 | if err != nil { 54 | t.Errorf("unexpected error: %s", err) 55 | continue 56 | } 57 | checkMemInfo("ticker", inf, t) 58 | case err := <-tk.Errs: 59 | t.Errorf("unexpected error: %s", err) 60 | } 61 | } 62 | tk.Stop() 63 | tk.Close() 64 | } 65 | 66 | func checkMemInfo(n string, inf *m.MemInfo, t *testing.T) { 67 | if inf.Timestamp == 0 { 68 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 69 | } 70 | if inf.TotalRAM == 0 { 71 | t.Errorf("%s: expected the TotalRAM to be non-zero, was 0", n) 72 | } 73 | if inf.FreeRAM == 0 { 74 | t.Errorf("%s: expected the FreeRAM to be non-zero, was 0", n) 75 | } 76 | t.Logf("%#v\n", inf) 77 | } 78 | 79 | func BenchmarkGet(b *testing.B) { 80 | var tmp []byte 81 | for i := 0; i < b.N; i++ { 82 | tmp, _ = Get() 83 | } 84 | _ = tmp 85 | } 86 | 87 | var inf *m.MemInfo 88 | 89 | func BenchmarkDeserialize(b *testing.B) { 90 | p, _ := Get() 91 | b.ResetTimer() 92 | for i := 0; i < b.N; i++ { 93 | inf, _ = Deserialize(p) 94 | } 95 | _ = inf 96 | } 97 | -------------------------------------------------------------------------------- /mem/membasic/membasic_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package membasic 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | ) 20 | 21 | func TestGet(t *testing.T) { 22 | inf, err := Get() 23 | if err != nil { 24 | t.Errorf("got %s, want nil", err) 25 | return 26 | } 27 | checkInfo("get", *inf, t) 28 | } 29 | 30 | func TestTicker(t *testing.T) { 31 | tkr, err := NewTicker(time.Millisecond) 32 | if err != nil { 33 | t.Error(err) 34 | return 35 | } 36 | tk := tkr.(*Ticker) 37 | for i := 0; i < 5; i++ { 38 | select { 39 | case <-tk.Done: 40 | break 41 | case v, ok := <-tk.Data: 42 | if !ok { 43 | break 44 | } 45 | checkInfo("ticker", v, t) 46 | case err := <-tk.Errs: 47 | t.Errorf("unexpected error: %s", err) 48 | } 49 | } 50 | tk.Stop() 51 | tk.Close() 52 | } 53 | 54 | func checkInfo(n string, i Info, t *testing.T) { 55 | if i.Timestamp == 0 { 56 | t.Errorf("%s: expected timestamp to be a non-zero value, got 0", n) 57 | } 58 | if i.Active == 0 { 59 | t.Errorf("%s: expected Active to be a non-zero value, got 0", n) 60 | } 61 | if i.Inactive == 0 { 62 | t.Errorf("%s: expected Inactive to be a non-zero value, got 0", n) 63 | } 64 | if i.MemAvailable == 0 { 65 | t.Errorf("%s: expected MemAvailable to be a non-zero value, got 0", n) 66 | } 67 | if i.MemFree == 0 { 68 | t.Errorf("%s: expected MemFree to be a non-zero value, got 0", n) 69 | } 70 | if i.MemTotal == 0 { 71 | t.Errorf("%s: expected MemTotal to be a non-zero value, got 0", n) 72 | } 73 | if i.SwapFree == 0 { 74 | t.Errorf("%s: expected SwapFree to be a non-zero value, got 0", n) 75 | } 76 | if i.SwapTotal == 0 { 77 | t.Errorf("%s: expected SwapTotal to be a non-zero value, got 0", n) 78 | } 79 | t.Logf("%#v\n", i) 80 | } 81 | 82 | func BenchmarkGet(b *testing.B) { 83 | var inf *Info 84 | p, _ := NewProfiler() 85 | b.ResetTimer() 86 | for i := 0; i < b.N; i++ { 87 | inf, _ = p.Get() 88 | } 89 | _ = inf 90 | } 91 | -------------------------------------------------------------------------------- /sysinfo/uptime/uptime_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package uptime gets the system's uptime using syscall. 15 | package uptime 16 | 17 | import ( 18 | "syscall" 19 | "time" 20 | 21 | joe "github.com/mohae/joefriday" 22 | ) 23 | 24 | // Uptime holds the current uptime and timestamp. 25 | type Uptime struct { 26 | Timestamp int64 27 | Uptime int64 // sorry for the stutter 28 | } 29 | 30 | // Get gets the current uptime information. 31 | func (u *Uptime) Get() error { 32 | var sysinfo syscall.Sysinfo_t 33 | err := syscall.Sysinfo(&sysinfo) 34 | if err != nil { 35 | return err 36 | } 37 | u.Timestamp = time.Now().UTC().UnixNano() 38 | u.Uptime = sysinfo.Uptime 39 | return nil 40 | } 41 | 42 | // Get gets the current uptime information. 43 | func Get() (u Uptime, err error) { 44 | err = u.Get() 45 | return u, err 46 | } 47 | 48 | // Ticker deliivers the uptime at intervals. 49 | type Ticker struct { 50 | *joe.Ticker 51 | Data chan Uptime 52 | } 53 | 54 | // NewTicker returns a new Ticker containing a Data channel that delivers the 55 | // data at intervals and an error channel that delivers any errors encountered. 56 | // Stop the ticker to signal the ticker to stop running. Stopping the ticker 57 | // does not close the Data channel; call Close to close both the ticker and the 58 | // data channel. 59 | func NewTicker(d time.Duration) (joe.Tocker, error) { 60 | t := Ticker{Ticker: joe.NewTicker(d), Data: make(chan Uptime)} 61 | go t.Run() 62 | return &t, nil 63 | } 64 | 65 | // Run runs the ticker. 66 | func (t *Ticker) Run() { 67 | // read until done signal is received 68 | for { 69 | select { 70 | case <-t.Done: 71 | return 72 | case <-t.Ticker.C: 73 | u, err := Get() 74 | if err != nil { 75 | t.Errs <- err 76 | continue 77 | } 78 | t.Data <- u 79 | } 80 | } 81 | } 82 | 83 | // Close closes the ticker resources. 84 | func (t *Ticker) Close() { 85 | t.Ticker.Close() 86 | close(t.Data) 87 | } 88 | -------------------------------------------------------------------------------- /sysinfo/loadavg/json/loadavg_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package loadavg 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | load "github.com/mohae/joefriday/sysinfo/loadavg" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | l, err := Deserialize(p) 30 | if err != nil { 31 | t.Errorf("unexpected error: %s", err) 32 | return 33 | } 34 | checkMemInfo("get", l, t) 35 | } 36 | 37 | func TestTicker(t *testing.T) { 38 | tkr, err := NewTicker(time.Millisecond) 39 | if err != nil { 40 | t.Error(err) 41 | return 42 | } 43 | tk := tkr.(*Ticker) 44 | for i := 0; i < 5; i++ { 45 | select { 46 | case <-tk.Done: 47 | break 48 | case p, ok := <-tk.Data: 49 | if !ok { 50 | break 51 | } 52 | l, err := Deserialize(p) 53 | if err != nil { 54 | t.Errorf("unexpected error: %s", err) 55 | continue 56 | } 57 | checkMemInfo("ticker", l, t) 58 | case err := <-tk.Errs: 59 | t.Errorf("unexpected error: %s", err) 60 | } 61 | } 62 | tk.Stop() 63 | tk.Close() 64 | } 65 | 66 | func checkMemInfo(n string, l *load.LoadAvg, t *testing.T) { 67 | if l.Timestamp == 0 { 68 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 69 | } 70 | if l.One == 0 { 71 | t.Errorf("%s: expected the One to be non-zero, was 0", n) 72 | } 73 | if l.Five == 0 { 74 | t.Errorf("%s: expected the Five to be non-zero, was 0", n) 75 | } 76 | if l.Fifteen == 0 { 77 | t.Errorf("%s: expected the Fifteen to be non-zero, was 0", n) 78 | } 79 | t.Logf("%#v\n", l) 80 | } 81 | 82 | func BenchmarkGet(b *testing.B) { 83 | var tmp []byte 84 | for i := 0; i < b.N; i++ { 85 | tmp, _ = Get() 86 | } 87 | _ = tmp 88 | } 89 | 90 | func BenchmarkDeserialize(b *testing.B) { 91 | var l *load.LoadAvg 92 | p, _ := Get() 93 | b.ResetTimer() 94 | for i := 0; i < b.N; i++ { 95 | l, _ = Deserialize(p) 96 | } 97 | _ = l 98 | } 99 | -------------------------------------------------------------------------------- /system/version/flat/version_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package version 15 | 16 | import ( 17 | "testing" 18 | 19 | v "github.com/mohae/joefriday/system/version" 20 | ) 21 | 22 | func TestSerializeDeserialize(t *testing.T) { 23 | p, err := Get() 24 | if err != nil { 25 | t.Errorf("Get(): got %s, want nil", err) 26 | return 27 | } 28 | k, err := v.Get() 29 | if err != nil { 30 | t.Errorf("version.Get(): got %s, want nil", err) 31 | return 32 | } 33 | kD := Deserialize(p) 34 | if k.OS != kD.OS { 35 | t.Errorf("OS: got %s; want %s", kD.OS, k.OS) 36 | } 37 | if k.Version != kD.Version { 38 | t.Errorf("Version: got %s; want %s", kD.Version, k.Version) 39 | } 40 | if k.CompileUser != kD.CompileUser { 41 | t.Errorf("CompileUser: got %s; want %s", kD.CompileUser, k.CompileUser) 42 | } 43 | if k.GCC != kD.GCC { 44 | t.Errorf("GCC: got %s; want %s", kD.GCC, k.GCC) 45 | } 46 | if k.OSGCC != kD.OSGCC { 47 | t.Errorf("Version: got %s; want %s", kD.OSGCC, k.OSGCC) 48 | } 49 | if k.Type != kD.Type { 50 | t.Errorf("Version: got %s; want %s", kD.Type, k.Type) 51 | } 52 | if k.CompileDate != kD.CompileDate { 53 | t.Errorf("CompileDate: got %s; want %s", kD.CompileDate, k.CompileDate) 54 | } 55 | if k.Arch != kD.Arch { 56 | t.Errorf("Arch: got %s; want %s", kD.Arch, k.Arch) 57 | } 58 | } 59 | 60 | func BenchmarkGet(b *testing.B) { 61 | var tmp []byte 62 | p, _ := NewProfiler() 63 | b.ResetTimer() 64 | for i := 0; i < b.N; i++ { 65 | tmp, _ = p.Get() 66 | } 67 | _ = tmp 68 | } 69 | 70 | func BenchmarkSerialize(b *testing.B) { 71 | var tmp []byte 72 | p, _ := NewProfiler() 73 | inf, _ := p.Profiler.Get() 74 | b.ResetTimer() 75 | for i := 0; i < b.N; i++ { 76 | tmp, _ = Serialize(inf) 77 | } 78 | _ = tmp 79 | } 80 | 81 | func BenchmarkDeserialize(b *testing.B) { 82 | var k *v.Kernel 83 | p, _ := NewProfiler() 84 | tmp, _ := p.Get() 85 | b.ResetTimer() 86 | for i := 0; i < b.N; i++ { 87 | k = Deserialize(tmp) 88 | } 89 | _ = k 90 | } 91 | -------------------------------------------------------------------------------- /cpu/cpuutil/cpuutil_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpuutil 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | ) 20 | 21 | func TestGet(t *testing.T) { 22 | p, err := NewProfiler() 23 | if err != nil { 24 | t.Errorf("unexpected error: %s", err) 25 | return 26 | } 27 | time.Sleep(time.Duration(200) * time.Millisecond) 28 | u, err := p.Get() 29 | if err != nil { 30 | t.Errorf("unexpected error: %s", err) 31 | return 32 | } 33 | checkCPUUtil("get", u, t) 34 | } 35 | 36 | func TestTicker(t *testing.T) { 37 | tkr, err := NewTicker(time.Millisecond) 38 | if err != nil { 39 | t.Error(err) 40 | return 41 | } 42 | tk := tkr.(*Ticker) 43 | for i := 0; i < 5; i++ { 44 | select { 45 | case <-tk.Done: 46 | break 47 | case v, ok := <-tk.Data: 48 | if !ok { 49 | break 50 | } 51 | checkCPUUtil("ticker", v, t) 52 | case err := <-tk.Errs: 53 | t.Errorf("unexpected error: %s", err) 54 | } 55 | } 56 | tk.Stop() 57 | tk.Close() 58 | } 59 | 60 | func checkCPUUtil(name string, u *CPUUtil, t *testing.T) { 61 | if u.Timestamp == 0 { 62 | t.Errorf("%s: timestamp: expected on-zero", name) 63 | } 64 | if u.TimeDelta == 0 { 65 | t.Errorf("%s: TimeDelta: expected non-zero value, got 0", name) 66 | } 67 | if u.CtxtDelta == 0 { 68 | t.Errorf("%s: CtxtDelta: expected non-zero value, got 0", name) 69 | } 70 | if u.BTimeDelta == 0 { 71 | t.Errorf("%s: BTimeDelta: expected non-zero value, got 0", name) 72 | } 73 | if u.Processes == 0 { 74 | t.Errorf("%s: Processes: expected non-zero value, got 0", name) 75 | } 76 | if len(u.CPU) < 2 { 77 | t.Errorf("%s: cpu: got %d, want at least 2", name, len(u.CPU)) 78 | } 79 | for i, v := range u.CPU { 80 | if v.ID == "" { 81 | t.Errorf("%s: %d: expected ID to have a value, was empty", name, i) 82 | } 83 | } 84 | } 85 | 86 | func BenchmarkCPUUtil(b *testing.B) { 87 | var u *CPUUtil 88 | p, _ := NewProfiler() 89 | b.ResetTimer() 90 | for i := 0; i < b.N; i++ { 91 | u, _ = p.Get() 92 | } 93 | _ = u 94 | } 95 | -------------------------------------------------------------------------------- /sysinfo/mem/flat/mem_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package mem 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | m "github.com/mohae/joefriday/sysinfo/mem" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | m := Deserialize(p) 30 | checkMemInfo("get", m, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case p, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | m := Deserialize(p) 49 | checkMemInfo("ticker", m, t) 50 | case err := <-tk.Errs: 51 | t.Errorf("unexpected error: %s", err) 52 | } 53 | } 54 | tk.Stop() 55 | tk.Close() 56 | } 57 | 58 | func checkMemInfo(n string, inf *m.MemInfo, t *testing.T) { 59 | if inf.Timestamp == 0 { 60 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 61 | } 62 | if inf.TotalRAM == 0 { 63 | t.Errorf("%s: expected the TotalRAM to be non-zero, was 0", n) 64 | } 65 | if inf.FreeRAM == 0 { 66 | t.Errorf("%s: expected the FreeRAM to be non-zero, was 0", n) 67 | } 68 | t.Logf("%#v\n", inf) 69 | } 70 | 71 | func BenchmarkGet(b *testing.B) { 72 | var tmp []byte 73 | for i := 0; i < b.N; i++ { 74 | tmp, _ = Get() 75 | } 76 | _ = tmp 77 | } 78 | 79 | func BenchmarkSerialize(b *testing.B) { 80 | var tmp []byte 81 | var inf m.MemInfo 82 | inf.Get() 83 | b.ResetTimer() 84 | for i := 0; i < b.N; i++ { 85 | tmp = Serialize(&inf) 86 | } 87 | _ = tmp 88 | } 89 | 90 | var inf *m.MemInfo 91 | 92 | func BenchmarkDeserialize(b *testing.B) { 93 | p, _ := Get() 94 | b.ResetTimer() 95 | for i := 0; i < b.N; i++ { 96 | inf = Deserialize(p) 97 | } 98 | _ = inf 99 | } 100 | -------------------------------------------------------------------------------- /cpu/cpux/flat/structs/CPU.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CPU struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *CPU) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *CPU) PhysicalPackageID() int32 { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 21 | } 22 | return 0 23 | } 24 | 25 | func (rcv *CPU) CoreID() int32 { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 29 | } 30 | return 0 31 | } 32 | 33 | func (rcv *CPU) MHzMin() float32 { 34 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 35 | if o != 0 { 36 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 37 | } 38 | return 0.0 39 | } 40 | 41 | func (rcv *CPU) MHzMax() float32 { 42 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 43 | if o != 0 { 44 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 45 | } 46 | return 0.0 47 | } 48 | 49 | func (rcv *CPU) Cache(obj *CacheInf, j int) bool { 50 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 51 | if o != 0 { 52 | x := rcv._tab.Vector(o) 53 | x += flatbuffers.UOffsetT(j) * 4 54 | x = rcv._tab.Indirect(x) 55 | if obj == nil { 56 | obj = new(CacheInf) 57 | } 58 | obj.Init(rcv._tab.Bytes, x) 59 | return true 60 | } 61 | return false 62 | } 63 | 64 | func (rcv *CPU) CacheLength() int { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 66 | if o != 0 { 67 | return rcv._tab.VectorLen(o) 68 | } 69 | return 0 70 | } 71 | 72 | func CPUStart(builder *flatbuffers.Builder) { builder.StartObject(5) } 73 | func CPUAddPhysicalPackageID(builder *flatbuffers.Builder, PhysicalPackageID int32) { builder.PrependInt32Slot(0, PhysicalPackageID, 0) } 74 | func CPUAddCoreID(builder *flatbuffers.Builder, CoreID int32) { builder.PrependInt32Slot(1, CoreID, 0) } 75 | func CPUAddMHzMin(builder *flatbuffers.Builder, MHzMin float32) { builder.PrependFloat32Slot(2, MHzMin, 0.0) } 76 | func CPUAddMHzMax(builder *flatbuffers.Builder, MHzMax float32) { builder.PrependFloat32Slot(3, MHzMax, 0.0) } 77 | func CPUAddCache(builder *flatbuffers.Builder, Cache flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(Cache), 0) } 78 | func CPUStartCacheVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 79 | } 80 | func CPUEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 81 | -------------------------------------------------------------------------------- /system/os/flat/os_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package os 15 | 16 | import ( 17 | "testing" 18 | 19 | o "github.com/mohae/joefriday/system/os" 20 | ) 21 | 22 | func TestSerializeDeserialize(t *testing.T) { 23 | p, err := Get() 24 | if err != nil { 25 | t.Errorf("Get(): got %s, want nil", err) 26 | return 27 | } 28 | os, err := o.Get() 29 | if err != nil { 30 | t.Errorf("release.Get(): got %s, want nil", err) 31 | return 32 | } 33 | osD := Deserialize(p) 34 | if os.Name != osD.Name { 35 | t.Errorf("Name: got %s; want %s", osD.Name, os.Name) 36 | } 37 | if os.ID != osD.ID { 38 | t.Errorf("ID: got %s; want %s", osD.ID, os.ID) 39 | } 40 | if os.IDLike != osD.IDLike { 41 | t.Errorf("IDLike: got %s; want %s", osD.IDLike, os.IDLike) 42 | } 43 | if os.PrettyName != osD.PrettyName { 44 | t.Errorf("PrettyName: got %s; want %s", osD.PrettyName, os.PrettyName) 45 | } 46 | if os.Version != osD.Version { 47 | t.Errorf("Version: got %s; want %s", osD.Version, os.Version) 48 | } 49 | if os.VersionID != osD.VersionID { 50 | t.Errorf("VersionID: got %s; want %s", osD.VersionID, os.VersionID) 51 | } 52 | if os.HomeURL != osD.HomeURL { 53 | t.Errorf("HomeURL: got %s; want %s", osD.HomeURL, os.HomeURL) 54 | } 55 | if os.BugReportURL != osD.BugReportURL { 56 | t.Errorf("BugReportURL: got %s; want %s", osD.BugReportURL, os.BugReportURL) 57 | } 58 | } 59 | 60 | func BenchmarkGet(b *testing.B) { 61 | var tmp []byte 62 | p, _ := NewProfiler() 63 | b.ResetTimer() 64 | for i := 0; i < b.N; i++ { 65 | tmp, _ = p.Get() 66 | } 67 | _ = tmp 68 | } 69 | 70 | func BenchmarkSerialize(b *testing.B) { 71 | var tmp []byte 72 | p, _ := NewProfiler() 73 | k, _ := p.Profiler.Get() 74 | b.ResetTimer() 75 | for i := 0; i < b.N; i++ { 76 | tmp, _ = Serialize(k) 77 | } 78 | _ = tmp 79 | } 80 | 81 | func BenchmarkDeserialize(b *testing.B) { 82 | var os *o.OS 83 | p, _ := NewProfiler() 84 | tmp, _ := p.Get() 85 | b.ResetTimer() 86 | for i := 0; i < b.N; i++ { 87 | os = Deserialize(tmp) 88 | } 89 | _ = os 90 | } 91 | -------------------------------------------------------------------------------- /system/uptime/flat/uptime_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package uptime 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | u "github.com/mohae/joefriday/system/uptime" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("Get(): got %s, want nil", err) 27 | return 28 | } 29 | u := Deserialize(p) 30 | checkUptime("ticker", u, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case v, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | u := Deserialize(v) 49 | checkUptime("ticker", u, t) 50 | case err := <-tk.Errs: 51 | t.Errorf("unexpected error: %s", err) 52 | } 53 | } 54 | tk.Stop() 55 | tk.Close() 56 | } 57 | 58 | func checkUptime(n string, up u.Uptime, t *testing.T) { 59 | if up.Timestamp == 0 { 60 | t.Errorf("expected Timestamp to be a non-zero value; got 0") 61 | } 62 | if up.Total == 0 { 63 | t.Errorf("expected total to be a non-zero value; got 0") 64 | } 65 | if up.Idle == 0 { 66 | t.Errorf("expected idle to be a non-zero value; got 0") 67 | } 68 | } 69 | 70 | func BenchmarkGet(b *testing.B) { 71 | var tmp []byte 72 | p, _ := NewProfiler() 73 | b.ResetTimer() 74 | for i := 0; i < b.N; i++ { 75 | tmp, _ = p.Get() 76 | } 77 | _ = tmp 78 | } 79 | 80 | func BenchmarkSerialize(b *testing.B) { 81 | var tmp []byte 82 | p, _ := NewProfiler() 83 | k, _ := p.Profiler.Get() 84 | b.ResetTimer() 85 | for i := 0; i < b.N; i++ { 86 | tmp, _ = Serialize(k) 87 | } 88 | _ = tmp 89 | } 90 | 91 | func BenchmarkDeserialize(b *testing.B) { 92 | var up u.Uptime 93 | p, _ := NewProfiler() 94 | tmp, _ := p.Get() 95 | b.ResetTimer() 96 | for i := 0; i < b.N; i++ { 97 | up = Deserialize(tmp) 98 | } 99 | _ = up 100 | } 101 | -------------------------------------------------------------------------------- /sysinfo/loadavg/flat/loadavg_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package loadavg 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | load "github.com/mohae/joefriday/sysinfo/loadavg" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | l := Deserialize(p) 30 | checkLoadAvg("get", l, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case p, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | l := Deserialize(p) 49 | checkLoadAvg("ticker", l, t) 50 | case err := <-tk.Errs: 51 | t.Errorf("unexpected error: %s", err) 52 | } 53 | } 54 | tk.Stop() 55 | tk.Close() 56 | } 57 | 58 | func checkLoadAvg(n string, l *load.LoadAvg, t *testing.T) { 59 | if l.Timestamp == 0 { 60 | t.Errorf("%s: expected the Timestamp to be non-zero, was 0", n) 61 | } 62 | if l.One == 0 { 63 | t.Errorf("%s: expected the One to be non-zero, was 0", n) 64 | } 65 | if l.Five == 0 { 66 | t.Errorf("%s: expected the Five to be non-zero, was 0", n) 67 | } 68 | if l.Fifteen == 0 { 69 | t.Errorf("%s: expected the Fifteen to be non-zero, was 0", n) 70 | } 71 | t.Logf("%#v\n", l) 72 | } 73 | 74 | func BenchmarkGet(b *testing.B) { 75 | var tmp []byte 76 | for i := 0; i < b.N; i++ { 77 | tmp, _ = Get() 78 | } 79 | _ = tmp 80 | } 81 | 82 | func BenchmarkSerialize(b *testing.B) { 83 | var tmp []byte 84 | var l load.LoadAvg 85 | l.Get() 86 | b.ResetTimer() 87 | for i := 0; i < b.N; i++ { 88 | tmp = Serialize(&l) 89 | } 90 | _ = tmp 91 | } 92 | 93 | func BenchmarkDeserialize(b *testing.B) { 94 | var l *load.LoadAvg 95 | p, _ := Get() 96 | b.ResetTimer() 97 | for i := 0; i < b.N; i++ { 98 | l = Deserialize(p) 99 | } 100 | _ = l 101 | } 102 | -------------------------------------------------------------------------------- /node/test/node_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package node 15 | 16 | import ( 17 | "os" 18 | "testing" 19 | 20 | "github.com/mohae/joefriday/node" 21 | "github.com/mohae/joefriday/testinfo" 22 | ) 23 | 24 | func TestNoNode(t *testing.T) { 25 | prof := node.NewProfiler() 26 | // local relative path can be used to make sure it doesn't exist 27 | prof.SysFSSystemPath("") 28 | n, err := prof.Get() 29 | if !os.IsNotExist(err) { 30 | t.Errorf("got %q; want ErrNotExist", err) 31 | } 32 | if n != nil { 33 | t.Errorf("got %#v; want nil", n) 34 | } 35 | 36 | } 37 | 38 | func TestNodeX(t *testing.T) { 39 | tests := []struct { 40 | sockets int32 41 | cores int32 42 | threads int32 43 | expectedList []string 44 | }{ 45 | {1, 2, 2, []string{"0-3"}}, 46 | {2, 8, 2, []string{"0-15", "16-31"}}, 47 | } 48 | tSysFS := testinfo.NewTempSysFS() 49 | // use a randomly generated temp dir 50 | err := tSysFS.SetSysFS("") 51 | if err != nil { 52 | t.Fatalf("settiing up sysfs tree: %s", err) 53 | } 54 | defer tSysFS.Clean() 55 | prof := node.NewProfiler() 56 | prof.SysFSSystemPath(tSysFS.Path()) 57 | 58 | for _, test := range tests { 59 | tSysFS.PhysicalPackageCount = test.sockets 60 | tSysFS.CoresPerPhysicalPackage = test.cores 61 | tSysFS.ThreadsPerCore = test.threads 62 | err = tSysFS.CreateNode() 63 | if err != nil { 64 | t.Errorf("%d sockets test setup: unexpected err: %s", test.sockets, err) 65 | continue 66 | } 67 | n, err := prof.Get() 68 | if err != nil { 69 | t.Errorf("%d sockets get: unexpected err: %s", test.sockets, err) 70 | continue 71 | } 72 | if int32(len(n.Node)) != test.sockets { 73 | t.Errorf("%d sockets: got %d nodes; want %d", test.sockets, len(n.Node), test.sockets) 74 | continue 75 | } 76 | 77 | for i, v := range n.Node { 78 | if v.CPUList != test.expectedList[i] { 79 | t.Errorf("%d socket test: node %d: got %q; want %q", test.sockets, i, v.CPUList, test.expectedList[i]) 80 | } 81 | if v.ID != int32(i) { 82 | t.Errorf("%d socket test: node %d: ID: got %d; want %d", test.sockets, i, v.ID, i) 83 | } 84 | } 85 | 86 | tSysFS.CleanNode() 87 | } 88 | } 89 | -------------------------------------------------------------------------------- /bench/cpu/bench_cpu.go: -------------------------------------------------------------------------------- 1 | package cpu 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/DataDog/gohai/cpu" 7 | "github.com/mohae/benchutil" 8 | "github.com/mohae/joefriday/cpu/cpuinfo" 9 | "github.com/mohae/joefriday/cpu/cpustats" 10 | gopsutilcpu "github.com/shirou/gopsutil/cpu" 11 | ) 12 | 13 | const CPUGroup = "CPU" 14 | 15 | func BenchJoeFridayGetCPUInfo(b *testing.B) { 16 | var inf *cpuinfo.CPUInfo 17 | p, _ := cpuinfo.NewProfiler() 18 | b.ResetTimer() 19 | for i := 0; i < b.N; i++ { 20 | inf, _ = p.Get() 21 | } 22 | _ = inf 23 | } 24 | 25 | func JoeFridayGetCPUInfo() benchutil.Bench { 26 | bench := benchutil.NewBench("joefriday/cpu/cpuinfo.Get") 27 | bench.Group = CPUGroup 28 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchJoeFridayGetCPUInfo)) 29 | return bench 30 | } 31 | 32 | func BenchJoeFridayGetCPUStats(b *testing.B) { 33 | var st *cpustats.CPUStats 34 | p, _ := cpustats.NewProfiler() 35 | b.ResetTimer() 36 | for i := 0; i < b.N; i++ { 37 | st, _ = p.Get() 38 | } 39 | _ = st 40 | } 41 | 42 | func JoeFridayGetCPUStats() benchutil.Bench { 43 | bench := benchutil.NewBench("joefriday/cpu/cpustats.Get") 44 | bench.Group = CPUGroup 45 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchJoeFridayGetCPUStats)) 46 | return bench 47 | } 48 | 49 | func BenchDataDogGohaiCPU(b *testing.B) { 50 | type Collector interface { 51 | Name() string 52 | Collect() (interface{}, error) 53 | } 54 | var collector = &cpu.Cpu{} 55 | var c interface{} 56 | for i := 0; i < b.N; i++ { 57 | c, _ = collector.Collect() 58 | } 59 | _ = c 60 | } 61 | 62 | func DataDogGohaiCPU() benchutil.Bench { 63 | bench := benchutil.NewBench("DataDog/gohai/cpu.Cpu.Collect") 64 | bench.Group = CPUGroup 65 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchDataDogGohaiCPU)) 66 | return bench 67 | } 68 | 69 | func BenchShirouGopsutilInfoStat(b *testing.B) { 70 | var st []gopsutilcpu.InfoStat 71 | for i := 0; i < b.N; i++ { 72 | st, _ = gopsutilcpu.Info() 73 | } 74 | _ = st 75 | } 76 | 77 | func ShirouGopsutilInfoStat() benchutil.Bench { 78 | bench := benchutil.NewBench("shirou/gopsutil/cpu.Info") 79 | bench.Group = CPUGroup 80 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchShirouGopsutilInfoStat)) 81 | return bench 82 | } 83 | 84 | func BenchShirouGopsutilTimeStat(b *testing.B) { 85 | var st []gopsutilcpu.TimesStat 86 | for i := 0; i < b.N; i++ { 87 | st, _ = gopsutilcpu.Times(true) 88 | } 89 | _ = st 90 | } 91 | 92 | func ShirouGopsutilTimeStat() benchutil.Bench { 93 | bench := benchutil.NewBench("shirou/gopsutil/cpu.Times") 94 | bench.Group = CPUGroup 95 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchShirouGopsutilTimeStat)) 96 | return bench 97 | } 98 | -------------------------------------------------------------------------------- /node/flat/node_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License 13 | package node 14 | 15 | import ( 16 | "os" 17 | "testing" 18 | 19 | "github.com/mohae/joefriday/node" 20 | "github.com/mohae/joefriday/testinfo" 21 | ) 22 | 23 | func TestNoNode(t *testing.T) { 24 | prof := node.NewProfiler() 25 | // local relative path can be used to make sure it doesn't exist 26 | prof.SysFSSystemPath("") 27 | n, err := prof.Get() 28 | if !os.IsNotExist(err) { 29 | t.Errorf("got %q; want ErrNotExist", err) 30 | } 31 | if n != nil { 32 | t.Errorf("got %#v; want nil", n) 33 | } 34 | 35 | } 36 | 37 | func TestNodeX(t *testing.T) { 38 | tests := []struct { 39 | sockets int32 40 | cores int32 41 | threads int32 42 | expectedList []string 43 | }{ 44 | {1, 2, 2, []string{"0-3"}}, 45 | {2, 8, 2, []string{"0-15", "16-31"}}, 46 | } 47 | tSysFS := testinfo.NewTempSysFS() 48 | // use a randomly generated temp dir 49 | err := tSysFS.SetSysFS("") 50 | if err != nil { 51 | t.Fatalf("settiing up sysfs tree: %s", err) 52 | } 53 | defer tSysFS.Clean() 54 | prof := NewProfiler() 55 | prof.SysFSSystemPath(tSysFS.Path()) 56 | 57 | for _, test := range tests { 58 | tSysFS.PhysicalPackageCount = test.sockets 59 | tSysFS.CoresPerPhysicalPackage = test.cores 60 | tSysFS.ThreadsPerCore = test.threads 61 | err = tSysFS.CreateNode() 62 | if err != nil { 63 | t.Errorf("%d sockets test setup: unexpected err: %s", test.sockets, err) 64 | continue 65 | } 66 | p, err := prof.Get() 67 | if err != nil { 68 | t.Errorf("%d sockets get: unexpected err: %s", test.sockets, err) 69 | continue 70 | } 71 | n := Deserialize(p) 72 | 73 | if int32(len(n.Node)) != test.sockets { 74 | t.Errorf("%d sockets: got %d nodes; want %d", test.sockets, len(n.Node), test.sockets) 75 | continue 76 | } 77 | 78 | for i, v := range n.Node { 79 | if v.CPUList != test.expectedList[i] { 80 | t.Errorf("%d socket test: node %d: got %q; want %q", test.sockets, i, v.CPUList, test.expectedList[i]) 81 | } 82 | if v.ID != int32(i) { 83 | t.Errorf("%d socket test: node %d: ID: got %d; want %d", test.sockets, i, v.ID, i) 84 | } 85 | } 86 | 87 | tSysFS.CleanNode() 88 | } 89 | } 90 | -------------------------------------------------------------------------------- /cpu/cpuutil/flat/structs/Utilization.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Utilization struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func (rcv *Utilization) Init(buf []byte, i flatbuffers.UOffsetT) { 13 | rcv._tab.Bytes = buf 14 | rcv._tab.Pos = i 15 | } 16 | 17 | func (rcv *Utilization) ID() []byte { 18 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 19 | if o != 0 { 20 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 21 | } 22 | return nil 23 | } 24 | 25 | func (rcv *Utilization) Usage() float32 { 26 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 27 | if o != 0 { 28 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 29 | } 30 | return 0.0 31 | } 32 | 33 | func (rcv *Utilization) User() float32 { 34 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 35 | if o != 0 { 36 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 37 | } 38 | return 0.0 39 | } 40 | 41 | func (rcv *Utilization) Nice() float32 { 42 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 43 | if o != 0 { 44 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 45 | } 46 | return 0.0 47 | } 48 | 49 | func (rcv *Utilization) System() float32 { 50 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 51 | if o != 0 { 52 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 53 | } 54 | return 0.0 55 | } 56 | 57 | func (rcv *Utilization) Idle() float32 { 58 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 59 | if o != 0 { 60 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 61 | } 62 | return 0.0 63 | } 64 | 65 | func (rcv *Utilization) IOWait() float32 { 66 | o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) 67 | if o != 0 { 68 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 69 | } 70 | return 0.0 71 | } 72 | 73 | func UtilizationStart(builder *flatbuffers.Builder) { builder.StartObject(7) } 74 | func UtilizationAddID(builder *flatbuffers.Builder, ID flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ID), 0) } 75 | func UtilizationAddUsage(builder *flatbuffers.Builder, Usage float32) { builder.PrependFloat32Slot(1, Usage, 0.0) } 76 | func UtilizationAddUser(builder *flatbuffers.Builder, User float32) { builder.PrependFloat32Slot(2, User, 0.0) } 77 | func UtilizationAddNice(builder *flatbuffers.Builder, Nice float32) { builder.PrependFloat32Slot(3, Nice, 0.0) } 78 | func UtilizationAddSystem(builder *flatbuffers.Builder, System float32) { builder.PrependFloat32Slot(4, System, 0.0) } 79 | func UtilizationAddIdle(builder *flatbuffers.Builder, Idle float32) { builder.PrependFloat32Slot(5, Idle, 0.0) } 80 | func UtilizationAddIOWait(builder *flatbuffers.Builder, IOWait float32) { builder.PrependFloat32Slot(6, IOWait, 0.0) } 81 | func UtilizationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 82 | -------------------------------------------------------------------------------- /sysinfo/loadavg/loadavg_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package loadavg provides the system's loadavg information using a syscall. 15 | package loadavg 16 | 17 | import ( 18 | "syscall" 19 | "time" 20 | 21 | joe "github.com/mohae/joefriday" 22 | ) 23 | 24 | const LoadsScale = 65536 25 | 26 | // LoadAvg holds loadavg information and the timestamp of the data. 27 | type LoadAvg struct { 28 | Timestamp int64 29 | One float64 30 | Five float64 31 | Fifteen float64 32 | } 33 | 34 | // Get the load average for the last 1, 5, and 15 minutes. 35 | func (l *LoadAvg) Get() error { 36 | var sysinfo syscall.Sysinfo_t 37 | err := syscall.Sysinfo(&sysinfo) 38 | if err != nil { 39 | return err 40 | } 41 | l.Timestamp = time.Now().UTC().UnixNano() 42 | l.One = float64(sysinfo.Loads[0]) / LoadsScale 43 | l.Five = float64(sysinfo.Loads[1]) / LoadsScale 44 | l.Fifteen = float64(sysinfo.Loads[2]) / LoadsScale 45 | return nil 46 | } 47 | 48 | // Get returns LoadAvg populated with the 1, 5, and 15 minute values. 49 | func Get() (LoadAvg, error) { 50 | var l LoadAvg 51 | err := l.Get() 52 | return l, err 53 | } 54 | 55 | // Ticker delivers the LoadAvg at intervals. 56 | type Ticker struct { 57 | *joe.Ticker 58 | Data chan LoadAvg 59 | } 60 | 61 | // NewTicker returns a new Ticker containing a Data channel that delivers the 62 | // data at intervals and an error channel that delivers any errors encountered. 63 | // Stop the ticker to signal the ticker to stop running. Stopping the ticker 64 | // does not close the Data channel; call Close to close both the ticker and the 65 | // data channel. 66 | func NewTicker(d time.Duration) (joe.Tocker, error) { 67 | t := Ticker{Ticker: joe.NewTicker(d), Data: make(chan LoadAvg)} 68 | go t.Run() 69 | return &t, nil 70 | } 71 | 72 | // Run runs the ticker. 73 | func (t *Ticker) Run() { 74 | // read until done signal is received 75 | for { 76 | select { 77 | case <-t.Done: 78 | return 79 | case <-t.Ticker.C: 80 | s, err := Get() 81 | if err != nil { 82 | t.Errs <- err 83 | continue 84 | } 85 | t.Data <- s 86 | } 87 | } 88 | } 89 | 90 | // Close closes the ticker resources. 91 | func (t *Ticker) Close() { 92 | t.Ticker.Close() 93 | close(t.Data) 94 | } 95 | -------------------------------------------------------------------------------- /net/netdev/flat/netdev_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package netdev 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/net/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | b, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | inf := Deserialize(b) 30 | checkInfo("get", inf, t) 31 | t.Logf("%#v\n", inf) 32 | } 33 | 34 | func TestTicker(t *testing.T) { 35 | tkr, err := NewTicker(time.Millisecond) 36 | if err != nil { 37 | t.Error(err) 38 | return 39 | } 40 | tk := tkr.(*Ticker) 41 | for i := 0; i < 5; i++ { 42 | select { 43 | case <-tk.Done: 44 | break 45 | case v, ok := <-tk.Data: 46 | if !ok { 47 | break 48 | } 49 | inf := Deserialize(v) 50 | if err != nil { 51 | t.Error(err) 52 | continue 53 | } 54 | checkInfo("ticker", inf, t) 55 | case err := <-tk.Errs: 56 | t.Errorf("unexpected error: %s", err) 57 | } 58 | } 59 | tk.Stop() 60 | tk.Close() 61 | } 62 | 63 | func checkInfo(n string, inf *structs.DevInfo, t *testing.T) { 64 | if inf.Timestamp == 0 { 65 | t.Errorf("%s: expected timestamp to be a non-zero value; was 0", n) 66 | } 67 | if len(inf.Device) == 0 { 68 | t.Errorf("%s: expected devices; got none", n) 69 | return 70 | } 71 | // check name 72 | for i, v := range inf.Device { 73 | if v.Name == "" { 74 | t.Errorf("%s: %d: expected device to have a name; was empty", n, i) 75 | } 76 | } 77 | } 78 | 79 | func BenchmarkGet(b *testing.B) { 80 | var tmp []byte 81 | p, _ := NewProfiler() 82 | b.ResetTimer() 83 | for i := 0; i < b.N; i++ { 84 | tmp, _ = p.Get() 85 | } 86 | _ = tmp 87 | } 88 | 89 | var inf *structs.DevInfo 90 | 91 | func BenchmarkSerialize(b *testing.B) { 92 | var tmp []byte 93 | p, _ := NewProfiler() 94 | inf, _ := p.Profiler.Get() 95 | b.ResetTimer() 96 | for i := 0; i < b.N; i++ { 97 | tmp, _ = Serialize(inf) 98 | } 99 | _ = tmp 100 | } 101 | 102 | func BenchmarkDeserialize(b *testing.B) { 103 | p, _ := NewProfiler() 104 | tmp, _ := p.Get() 105 | b.ResetTimer() 106 | for i := 0; i < b.N; i++ { 107 | inf = Deserialize(tmp) 108 | } 109 | _ = inf 110 | } 111 | -------------------------------------------------------------------------------- /bench/net/bench_net.go: -------------------------------------------------------------------------------- 1 | package net 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/DataDog/gohai/network" 7 | "github.com/mohae/benchutil" 8 | "github.com/mohae/joefriday/net/netdev" 9 | "github.com/mohae/joefriday/net/structs" 10 | "github.com/mohae/joefriday/net/netusage" 11 | gopsutilnet "github.com/shirou/gopsutil/net" 12 | ) 13 | 14 | const NetGroup = "Network" 15 | 16 | func BenchJoeFridayGetNetDev(b *testing.B) { 17 | var inf *structs.DevInfo 18 | p, _ := netdev.NewProfiler() 19 | b.ResetTimer() 20 | for i := 0; i < b.N; i++ { 21 | inf, _ = p.Get() 22 | } 23 | _ = inf 24 | } 25 | 26 | func JoeFridayGetNetDev() benchutil.Bench { 27 | bench := benchutil.NewBench("joefriday/net/netdev.Get") 28 | bench.Group = NetGroup 29 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchJoeFridayGetNetDev)) 30 | return bench 31 | } 32 | 33 | func BenchJoeFridayGetNetUsage(b *testing.B) { 34 | var u *structs.DevUsage 35 | p, _ := netusage.NewProfiler() 36 | b.ResetTimer() 37 | for i := 0; i < b.N; i++ { 38 | u, _ = p.Get() 39 | } 40 | _ = u 41 | } 42 | 43 | func JoeFridayGetNetUsage() benchutil.Bench { 44 | bench := benchutil.NewBench("joefriday/net/netusage.Get") 45 | bench.Group = NetGroup 46 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchJoeFridayGetNetUsage)) 47 | return bench 48 | } 49 | 50 | func BenchDataDogGohaiNetwork(b *testing.B) { 51 | type Collector interface { 52 | Name() string 53 | Collect() (interface{}, error) 54 | } 55 | var collector = &network.Network{} 56 | var c interface{} 57 | for i := 0; i < b.N; i++ { 58 | c, _ = collector.Collect() 59 | } 60 | _ = c 61 | } 62 | 63 | func DataDogGohaiNetwork() benchutil.Bench { 64 | bench := benchutil.NewBench("DataDog/gohai/network") 65 | bench.Group = NetGroup 66 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchDataDogGohaiNetwork)) 67 | return bench 68 | } 69 | 70 | func BenchShirouGopsutilNetInterfaces(b *testing.B) { 71 | var st []gopsutilnet.InterfaceStat 72 | for i := 0; i < b.N; i++ { 73 | st, _ = gopsutilnet.Interfaces() 74 | } 75 | _ = st 76 | } 77 | 78 | func ShirouGopsutilNetInterfaces() benchutil.Bench { 79 | bench := benchutil.NewBench("shirou/gopsutil/net") 80 | bench.Group = NetGroup 81 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchShirouGopsutilNetInterfaces)) 82 | return bench 83 | } 84 | 85 | func BenchShirouGopsutilIOCounters(b *testing.B) { 86 | var st []gopsutilnet.IOCountersStat 87 | for i := 0; i < b.N; i++ { 88 | st, _ = gopsutilnet.IOCounters(true) 89 | } 90 | _ = st 91 | } 92 | 93 | func ShirouGopsutilIOCounters() benchutil.Bench { 94 | bench := benchutil.NewBench("shirou/gopsutil/net/IOCounters") 95 | bench.Group = NetGroup 96 | bench.Result = benchutil.ResultFromBenchmarkResult(testing.Benchmark(BenchShirouGopsutilIOCounters)) 97 | return bench 98 | } 99 | -------------------------------------------------------------------------------- /node/json/node_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package node 15 | 16 | import ( 17 | "os" 18 | "testing" 19 | 20 | "github.com/mohae/joefriday/node" 21 | "github.com/mohae/joefriday/testinfo" 22 | ) 23 | 24 | func TestNoNode(t *testing.T) { 25 | prof := node.NewProfiler() 26 | // local relative path can be used to make sure it doesn't exist 27 | prof.SysFSSystemPath("") 28 | n, err := prof.Get() 29 | if !os.IsNotExist(err) { 30 | t.Errorf("got %q; want ErrNotExist", err) 31 | } 32 | if n != nil { 33 | t.Errorf("got %#v; want nil", n) 34 | } 35 | 36 | } 37 | 38 | func TestNodeX(t *testing.T) { 39 | tests := []struct { 40 | sockets int32 41 | cores int32 42 | threads int32 43 | expectedList []string 44 | }{ 45 | {1, 2, 2, []string{"0-3"}}, 46 | {2, 8, 2, []string{"0-15", "16-31"}}, 47 | } 48 | tSysFS := testinfo.NewTempSysFS() 49 | // use a randomly generated temp dir 50 | err := tSysFS.SetSysFS("") 51 | if err != nil { 52 | t.Fatalf("settiing up sysfs tree: %s", err) 53 | } 54 | defer tSysFS.Clean() 55 | prof := NewProfiler() 56 | prof.SysFSSystemPath(tSysFS.Path()) 57 | 58 | for _, test := range tests { 59 | tSysFS.PhysicalPackageCount = test.sockets 60 | tSysFS.CoresPerPhysicalPackage = test.cores 61 | tSysFS.ThreadsPerCore = test.threads 62 | err = tSysFS.CreateNode() 63 | if err != nil { 64 | t.Errorf("%d sockets test setup: unexpected err: %s", test.sockets, err) 65 | continue 66 | } 67 | p, err := prof.Get() 68 | if err != nil { 69 | t.Errorf("%d sockets get: unexpected err: %s", test.sockets, err) 70 | continue 71 | } 72 | n, err := Deserialize(p) 73 | if err != nil { 74 | t.Error("%d sockets: unexpected deserialize err: %s", err) 75 | } 76 | 77 | if int32(len(n.Node)) != test.sockets { 78 | t.Errorf("%d sockets: got %d nodes; want %d", test.sockets, len(n.Node), test.sockets) 79 | continue 80 | } 81 | 82 | for i, v := range n.Node { 83 | if v.CPUList != test.expectedList[i] { 84 | t.Errorf("%d socket test: node %d: got %q; want %q", test.sockets, i, v.CPUList, test.expectedList[i]) 85 | } 86 | if v.ID != int32(i) { 87 | t.Errorf("%d socket test: node %d: ID: got %d; want %d", test.sockets, i, v.ID, i) 88 | } 89 | } 90 | 91 | tSysFS.CleanNode() 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /sysinfo/mem/mem_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package mem returns memory information using syscalls. Only basic memory 15 | // information is provided by this package. 16 | package mem 17 | 18 | import ( 19 | "syscall" 20 | "time" 21 | 22 | joe "github.com/mohae/joefriday" 23 | ) 24 | 25 | // MemInfo holds information about system memory. 26 | type MemInfo struct { 27 | Timestamp int64 28 | TotalRAM uint64 29 | FreeRAM uint64 30 | SharedRAM uint64 31 | BufferRAM uint64 32 | TotalSwap uint64 33 | FreeSwap uint64 34 | } 35 | 36 | // Get gets the system's memory information. 37 | func (m *MemInfo) Get() error { 38 | var sysinfo syscall.Sysinfo_t 39 | err := syscall.Sysinfo(&sysinfo) 40 | if err != nil { 41 | return err 42 | } 43 | m.Timestamp = time.Now().UTC().UnixNano() 44 | m.TotalRAM = sysinfo.Totalram 45 | m.FreeRAM = sysinfo.Freeram 46 | m.SharedRAM = sysinfo.Sharedram 47 | m.BufferRAM = sysinfo.Bufferram 48 | m.TotalSwap = sysinfo.Totalswap 49 | m.FreeSwap = sysinfo.Freeswap 50 | return nil 51 | } 52 | 53 | // Get gets the system's memory information. 54 | func Get() (m MemInfo, err error) { 55 | err = m.Get() 56 | return m, err 57 | } 58 | 59 | // Ticker delivers the system's memory information at intervals. 60 | type Ticker struct { 61 | *joe.Ticker 62 | Data chan MemInfo 63 | } 64 | 65 | // NewTicker returns a new Ticker containing a Data channel that delivers the 66 | // data at intervals and an error channel that delivers any errors encountered. 67 | // Stop the ticker to signal the ticker to stop running. Stopping the ticker 68 | // does not close the Data channel; call Close to close both the ticker and the 69 | // data channel. 70 | func NewTicker(d time.Duration) (joe.Tocker, error) { 71 | t := Ticker{Ticker: joe.NewTicker(d), Data: make(chan MemInfo)} 72 | go t.Run() 73 | return &t, nil 74 | } 75 | 76 | // Run runs the ticker. 77 | func (t *Ticker) Run() { 78 | // read until done signal is received 79 | for { 80 | select { 81 | case <-t.Done: 82 | return 83 | case <-t.Ticker.C: 84 | s, err := Get() 85 | if err != nil { 86 | t.Errs <- err 87 | continue 88 | } 89 | t.Data <- s 90 | } 91 | } 92 | } 93 | 94 | // Close closes the ticker resources. 95 | func (t *Ticker) Close() { 96 | t.Ticker.Close() 97 | close(t.Data) 98 | } 99 | -------------------------------------------------------------------------------- /disk/diskusage/flat/diskusage_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package diskusage 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/disk/structs" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := NewProfiler() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | b, err := p.Get() 30 | if err != nil { 31 | t.Errorf("unexpected error: %s", err) 32 | return 33 | } 34 | u := Deserialize(b) 35 | checkUsage("get", u, t) 36 | } 37 | 38 | func TestTicker(t *testing.T) { 39 | tkr, err := NewTicker(time.Millisecond) 40 | if err != nil { 41 | t.Error(err) 42 | return 43 | } 44 | tk := tkr.(*Ticker) 45 | for i := 0; i < 5; i++ { 46 | select { 47 | case <-tk.Done: 48 | break 49 | case v, ok := <-tk.Data: 50 | if !ok { 51 | break 52 | } 53 | u := Deserialize(v) 54 | checkUsage("ticker", u, t) 55 | case err := <-tk.Errs: 56 | t.Errorf("unexpected error: %s", err) 57 | } 58 | } 59 | tk.Stop() 60 | tk.Close() 61 | } 62 | 63 | func checkUsage(n string, u *structs.DiskUsage, t *testing.T) { 64 | if u.Timestamp == 0 { 65 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 66 | } 67 | if u.TimeDelta == 0 { 68 | t.Errorf("%s: TimeDelta: wanted non-zero value; got 0", n) 69 | } 70 | if len(u.Device) == 0 { 71 | t.Errorf("%s: expected there to be devices; didn't get any", n) 72 | } 73 | for i := 0; i < len(u.Device); i++ { 74 | if u.Device[i].Major == 0 { 75 | t.Errorf("%s: Device %d: Major: wanted a non-zero value, was 0", n, i) 76 | } 77 | if u.Device[i].Name == "" { 78 | t.Errorf("%s: Device %d: Name: wanted a non-empty value; was empty", n, i) 79 | } 80 | } 81 | } 82 | 83 | func BenchmarkSerialize(b *testing.B) { 84 | var tmp []byte 85 | p, _ := NewProfiler() 86 | u, _ := p.Profiler.Get() 87 | b.ResetTimer() 88 | for i := 0; i < b.N; i++ { 89 | tmp, _ = Serialize(u) 90 | } 91 | _ = tmp 92 | } 93 | 94 | func BenchmarkDeserialize(b *testing.B) { 95 | var u *structs.DiskUsage 96 | p, _ := NewProfiler() 97 | tmp, _ := p.Get() 98 | b.ResetTimer() 99 | for i := 0; i < b.N; i++ { 100 | u = Deserialize(tmp) 101 | } 102 | _ = u 103 | } 104 | -------------------------------------------------------------------------------- /system/loadavg/flat/structs/LoadAvg.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type LoadAvg struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsLoadAvg(buf []byte, offset flatbuffers.UOffsetT) *LoadAvg { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &LoadAvg{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *LoadAvg) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *LoadAvg) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *LoadAvg) Minute() float32 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 36 | } 37 | return 0.0 38 | } 39 | 40 | func (rcv *LoadAvg) Five() float32 { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 44 | } 45 | return 0.0 46 | } 47 | 48 | func (rcv *LoadAvg) Fifteen() float32 { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.GetFloat32(o + rcv._tab.Pos) 52 | } 53 | return 0.0 54 | } 55 | 56 | func (rcv *LoadAvg) Running() int32 { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 60 | } 61 | return 0 62 | } 63 | 64 | func (rcv *LoadAvg) Total() int32 { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 68 | } 69 | return 0 70 | } 71 | 72 | func (rcv *LoadAvg) PID() int32 { 73 | o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) 74 | if o != 0 { 75 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 76 | } 77 | return 0 78 | } 79 | 80 | func LoadAvgStart(builder *flatbuffers.Builder) { builder.StartObject(7) } 81 | func LoadAvgAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 82 | func LoadAvgAddMinute(builder *flatbuffers.Builder, Minute float32) { builder.PrependFloat32Slot(1, Minute, 0.0) } 83 | func LoadAvgAddFive(builder *flatbuffers.Builder, Five float32) { builder.PrependFloat32Slot(2, Five, 0.0) } 84 | func LoadAvgAddFifteen(builder *flatbuffers.Builder, Fifteen float32) { builder.PrependFloat32Slot(3, Fifteen, 0.0) } 85 | func LoadAvgAddRunning(builder *flatbuffers.Builder, Running int32) { builder.PrependInt32Slot(4, Running, 0) } 86 | func LoadAvgAddTotal(builder *flatbuffers.Builder, Total int32) { builder.PrependInt32Slot(5, Total, 0) } 87 | func LoadAvgAddPID(builder *flatbuffers.Builder, PID int32) { builder.PrependInt32Slot(6, PID, 0) } 88 | func LoadAvgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 89 | -------------------------------------------------------------------------------- /disk/diskstats/flat/diskstats_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package diskstats 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/disk/structs" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("unexpected error: %s", err) 27 | return 28 | } 29 | statsD := Deserialize(p) 30 | checkStats("get", statsD, t) 31 | t.Logf("%#v\n", statsD) 32 | } 33 | 34 | func TestTicker(t *testing.T) { 35 | tkr, err := NewTicker(time.Millisecond) 36 | if err != nil { 37 | t.Error(err) 38 | return 39 | } 40 | tk := tkr.(*Ticker) 41 | for i := 0; i < 5; i++ { 42 | select { 43 | case <-tk.Done: 44 | break 45 | case v, ok := <-tk.Data: 46 | if !ok { 47 | break 48 | } 49 | st := Deserialize(v) 50 | checkStats("ticker", st, t) 51 | case err := <-tk.Errs: 52 | t.Errorf("unexpected error: %s", err) 53 | } 54 | } 55 | tk.Stop() 56 | tk.Close() 57 | } 58 | 59 | func checkStats(n string, s *structs.DiskStats, t *testing.T) { 60 | if s.Timestamp == 0 { 61 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 62 | } 63 | if len(s.Device) == 0 { 64 | t.Errorf("%s: expected there to be devices; didn't get any", n) 65 | } 66 | for i := 0; i < len(s.Device); i++ { 67 | if s.Device[i].Major == 0 { 68 | t.Errorf("%s: Device %d: Major: wanted a non-zero value, was 0", n, i) 69 | } 70 | if s.Device[i].Name == "" { 71 | t.Errorf("%s: Device %d: Name: wanted a non-empty value; was empty", n, i) 72 | } 73 | } 74 | } 75 | 76 | func BenchmarkGet(b *testing.B) { 77 | var tmp []byte 78 | p, _ := NewProfiler() 79 | b.ResetTimer() 80 | for i := 0; i < b.N; i++ { 81 | tmp, _ = p.Get() 82 | } 83 | _ = tmp 84 | } 85 | 86 | func BenchmarkSerialize(b *testing.B) { 87 | var tmp []byte 88 | p, _ := NewProfiler() 89 | st, _ := p.Profiler.Get() 90 | b.ResetTimer() 91 | for i := 0; i < b.N; i++ { 92 | tmp, _ = Serialize(st) 93 | } 94 | _ = tmp 95 | } 96 | 97 | var st *structs.DiskStats 98 | 99 | func BenchmarkDeserialize(b *testing.B) { 100 | p, _ := NewProfiler() 101 | tmp, _ := p.Get() 102 | b.ResetTimer() 103 | for i := 0; i < b.N; i++ { 104 | st = Deserialize(tmp) 105 | } 106 | _ = st 107 | } 108 | -------------------------------------------------------------------------------- /sysinfo/uptime/json/uptime_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package uptime gets the system's uptime using syscall. Instead of returning 15 | // a Go struct, it returns JSON serialized bytes. A function to deserialize the 16 | // JSON serialized bytes into a uptime.Uptime struct is provided. 17 | // 18 | // Note: the package name is uptime and not the final element of the import 19 | // path (json). 20 | package uptime 21 | 22 | import ( 23 | "encoding/json" 24 | "time" 25 | 26 | joe "github.com/mohae/joefriday" 27 | up "github.com/mohae/joefriday/sysinfo/uptime" 28 | ) 29 | 30 | // Get returns the current uptime as JSON serialized bytes. 31 | func Get() (p []byte, err error) { 32 | var u up.Uptime 33 | err = u.Get() 34 | if err != nil { 35 | return nil, err 36 | } 37 | return json.Marshal(&u) 38 | } 39 | 40 | // Deserialize takes some JSON serialized bytes and unmarshals them as 41 | // uptime.Uptime. 42 | func Deserialize(p []byte) (*up.Uptime, error) { 43 | var u up.Uptime 44 | err := json.Unmarshal(p, &u) 45 | if err != nil { 46 | return nil, err 47 | } 48 | return &u, nil 49 | } 50 | 51 | // Unmarshal is an alias for Deserialize. 52 | func Unmarshal(p []byte) (*up.Uptime, error) { 53 | return Deserialize(p) 54 | } 55 | 56 | // Ticker delivers uptime.Uptime as JSON serialized bytes at intervals. 57 | type Ticker struct { 58 | *joe.Ticker 59 | Data chan []byte 60 | } 61 | 62 | // NewTicker returns a new Ticker containing a Data channel that delivers the 63 | // data at intervals and an error channel that delivers any errors encountered. 64 | // Stop the ticker to signal the ticker to stop running. Stopping the ticker 65 | // does not close the Data channel; call Close to close both the ticker and the 66 | // data channel. 67 | func NewTicker(d time.Duration) (joe.Tocker, error) { 68 | t := Ticker{Ticker: joe.NewTicker(d), Data: make(chan []byte)} 69 | go t.Run() 70 | return &t, nil 71 | } 72 | 73 | func (t *Ticker) Run() { 74 | // read until done signal is received 75 | for { 76 | select { 77 | case <-t.Done: 78 | return 79 | case <-t.Ticker.C: 80 | p, err := Get() 81 | if err != nil { 82 | t.Errs <- err 83 | continue 84 | } 85 | t.Data <- p 86 | } 87 | } 88 | } 89 | 90 | // Close closes the ticker resources. 91 | func (t *Ticker) Close() { 92 | t.Ticker.Close() 93 | close(t.Data) 94 | } 95 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | joefriday 2 | ========= 3 | [![GoDoc](https://godoc.org/github.com/mohae/joefriday?status.svg)](https://godoc.org/github.com/mohae/joefriday)[![Build Status](https://travis-ci.org/mohae/joefriday.png)](https://travis-ci.org/mohae/joefriday) 4 | > "All we want are the facts, ma'am" 5 | > - Joe Friday 6 | 7 | JoeFriday is a group of libraries that gathers system information: cpu, disk, memory, network, system, etc. This information can be returned as Go structs, Flatbuffers serialized bytes, or JSON serialized bytes. For Flatbuffers and JSON, deserialization convenience methods are provided. When it makes sense, a Ticker based implementation is provided to enable periodic gathering of information. 8 | 9 | JoeFriday seeks to minimize allocations and time spent gathering the information. For minimal resource usage, use the sysinfo implementations, if appropriate, as the data provided by those implementations use syscalls, which are at least an order of magnitude faster than processing the proc files. 10 | 11 | This library only supports Linux. 12 | 13 | See package specific READMEs for information about what those packages provide. 14 | 15 | ## Benchmarks 16 | ### Comparative Benchmarks 17 | The `bench` package provides comparative benchmarks; showing how JoeFriday implementations compare with some other libraries that provide similar information. 18 | 19 | The information provided by the various libraries are not the same; that should also be factored into the decision as to which library best suits your requirements. 20 | 21 | Either a benchmark app can be compiled with `go build` or they can be run using `go test -bench=. [flags]`. 22 | 23 | The benchmark app's output includes group, e.g. CPU, Memory, etc, package name and function called, Ops, ns/Op, B/op, and Allocs/Op. The output can be formatted as text lines (default), CSV, or Markdown Table and written to a file. 24 | 25 | ### JoeBench 26 | JoeBench is an app that runs benchmarks of JoeFriday functionality, including serialization implementations, and generates formatted output. Output includes group, e.g. CPU, Memory, etc, package name and function called, Ops, ns/Op, B/op, and Allocs/Op. The output can be formatted as text lines (default), CSV, or Markdown Table and written to a file. 27 | 28 | ## Notes: 29 | A big thanks to [Eric Lagergren](https://github.com/EricLagergren) for all of his help and his contributions. 30 | 31 | ## `alpha-1` branch: 32 | The alpha-1 branch has the original JoeFriday implementation. If your code relies on the package's state prior to 7/2017, this branch should be used if you don't want to change your existing code to work with the refactored JoeFriday. 33 | 34 | ## TODO 35 | * Provide protobuf implementations. 36 | * Add CPU speed info: min, max, current. 37 | * For utilization and usage, add output of deltas between snapshots. 38 | * For utilization and usage revisit calculations and algorithms used, maybe add additional algorithms, where appropriate. This may be a separate library. -------------------------------------------------------------------------------- /sysinfo/mem/flat/structs/MemInfo.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type MemInfo struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsMemInfo(buf []byte, offset flatbuffers.UOffsetT) *MemInfo { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &MemInfo{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *MemInfo) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *MemInfo) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *MemInfo) TotalRAM() uint64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetUint64(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *MemInfo) FreeRAM() uint64 { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.GetUint64(o + rcv._tab.Pos) 44 | } 45 | return 0 46 | } 47 | 48 | func (rcv *MemInfo) SharedRAM() uint64 { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.GetUint64(o + rcv._tab.Pos) 52 | } 53 | return 0 54 | } 55 | 56 | func (rcv *MemInfo) BufferRAM() uint64 { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.GetUint64(o + rcv._tab.Pos) 60 | } 61 | return 0 62 | } 63 | 64 | func (rcv *MemInfo) TotalSwap() uint64 { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | return rcv._tab.GetUint64(o + rcv._tab.Pos) 68 | } 69 | return 0 70 | } 71 | 72 | func (rcv *MemInfo) FreeSwap() uint64 { 73 | o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) 74 | if o != 0 { 75 | return rcv._tab.GetUint64(o + rcv._tab.Pos) 76 | } 77 | return 0 78 | } 79 | 80 | func MemInfoStart(builder *flatbuffers.Builder) { builder.StartObject(7) } 81 | func MemInfoAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 82 | func MemInfoAddTotalRAM(builder *flatbuffers.Builder, TotalRAM uint64) { builder.PrependUint64Slot(1, TotalRAM, 0) } 83 | func MemInfoAddFreeRAM(builder *flatbuffers.Builder, FreeRAM uint64) { builder.PrependUint64Slot(2, FreeRAM, 0) } 84 | func MemInfoAddSharedRAM(builder *flatbuffers.Builder, SharedRAM uint64) { builder.PrependUint64Slot(3, SharedRAM, 0) } 85 | func MemInfoAddBufferRAM(builder *flatbuffers.Builder, BufferRAM uint64) { builder.PrependUint64Slot(4, BufferRAM, 0) } 86 | func MemInfoAddTotalSwap(builder *flatbuffers.Builder, TotalSwap uint64) { builder.PrependUint64Slot(5, TotalSwap, 0) } 87 | func MemInfoAddFreeSwap(builder *flatbuffers.Builder, FreeSwap uint64) { builder.PrependUint64Slot(6, FreeSwap, 0) } 88 | func MemInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 89 | -------------------------------------------------------------------------------- /sysinfo/mem/json/mem_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package mem returns memory information using syscalls. Instead of returning 15 | // a Go struct, it returns JSON serialized bytes. A function to deserialize the 16 | // JSON serialized bytes into a mem.MemInfo struct is provided. 17 | // 18 | // Note: the package name is mem and not the final element of the import path 19 | // (json). 20 | package mem 21 | 22 | import ( 23 | "encoding/json" 24 | "time" 25 | 26 | joe "github.com/mohae/joefriday" 27 | m "github.com/mohae/joefriday/sysinfo/mem" 28 | ) 29 | 30 | // Get returns the system's memory information as JSON serialized bytes. 31 | func Get() (p []byte, err error) { 32 | var inf m.MemInfo 33 | err = inf.Get() 34 | if err != nil { 35 | return nil, err 36 | } 37 | return json.Marshal(&inf) 38 | } 39 | 40 | // Deserialize takes some JSON serialized bytes and unmarshals them as 41 | // mem.MemInfo. 42 | func Deserialize(p []byte) (*m.MemInfo, error) { 43 | var inf m.MemInfo 44 | err := json.Unmarshal(p, &inf) 45 | if err != nil { 46 | return nil, err 47 | } 48 | return &inf, nil 49 | } 50 | 51 | // Unmarshal is an alias for Deserialize. 52 | func Unmarshal(p []byte) (*m.MemInfo, error) { 53 | return Deserialize(p) 54 | } 55 | 56 | // Ticker delivers mem.MemInfo as JSON serialized bytes at intervals. 57 | type Ticker struct { 58 | *joe.Ticker 59 | Data chan []byte 60 | } 61 | 62 | // NewTicker returns a new Ticker containing a Data channel that delivers the 63 | // data at intervals and an error channel that delivers any errors encountered. 64 | // Stop the ticker to signal the ticker to stop running. Stopping the ticker 65 | // does not close the Data channel; call Close to close both the ticker and the 66 | // data channel. 67 | func NewTicker(d time.Duration) (joe.Tocker, error) { 68 | t := Ticker{Ticker: joe.NewTicker(d), Data: make(chan []byte)} 69 | go t.Run() 70 | return &t, nil 71 | } 72 | 73 | // Run runs the ticker. 74 | func (t *Ticker) Run() { 75 | // read until done signal is received 76 | for { 77 | select { 78 | case <-t.Done: 79 | return 80 | case <-t.Ticker.C: 81 | s, err := Get() 82 | if err != nil { 83 | t.Errs <- err 84 | continue 85 | } 86 | t.Data <- s 87 | } 88 | } 89 | } 90 | 91 | // Close closes the ticker resources. 92 | func (t *Ticker) Close() { 93 | t.Ticker.Close() 94 | close(t.Data) 95 | } 96 | -------------------------------------------------------------------------------- /sysinfo/loadavg/json/loadavg_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package loadavg provides the system's loadavg information using a syscall. 15 | // Instead of returning a Go struct, it returns JSON serialized bytes. A 16 | // function to deserialize the JSON serialized bytes into a loadavg.LoadAvg 17 | // struct is provided. 18 | // 19 | // Note: the package name is loadavg and not the final element of the import 20 | // path (json). 21 | package loadavg 22 | 23 | import ( 24 | "encoding/json" 25 | "time" 26 | 27 | joe "github.com/mohae/joefriday" 28 | load "github.com/mohae/joefriday/sysinfo/loadavg" 29 | ) 30 | 31 | // Get returns the current LoadAvg as JSON serialized bytes. 32 | func Get() (p []byte, err error) { 33 | var l load.LoadAvg 34 | err = l.Get() 35 | if err != nil { 36 | return nil, err 37 | } 38 | return json.Marshal(&l) 39 | } 40 | 41 | // Deserialize takes some JSON serialized bytes and unmarshals them as 42 | // loadavg.Loadavg. 43 | func Deserialize(p []byte) (*load.LoadAvg, error) { 44 | var l load.LoadAvg 45 | err := json.Unmarshal(p, &l) 46 | if err != nil { 47 | return nil, err 48 | } 49 | return &l, nil 50 | } 51 | 52 | // Unmarshal is an alias for Deserialize. 53 | func Unmarshal(p []byte) (*load.LoadAvg, error) { 54 | return Deserialize(p) 55 | } 56 | 57 | // Ticker delivers loadavg.LoadAvg as JSON serialized bytes at intervals. 58 | type Ticker struct { 59 | *joe.Ticker 60 | Data chan []byte 61 | } 62 | 63 | // NewTicker returns a new Ticker containing a Data channel that delivers the 64 | // data at intervals and an error channel that delivers any errors encountered. 65 | // Stop the ticker to signal the ticker to stop running. Stopping the ticker 66 | // does not close the Data channel; call Close to close both the ticker and the 67 | // data channel. 68 | func NewTicker(d time.Duration) (joe.Tocker, error) { 69 | t := Ticker{Ticker: joe.NewTicker(d), Data: make(chan []byte)} 70 | go t.Run() 71 | return &t, nil 72 | } 73 | 74 | // Run runs the ticker. 75 | func (t *Ticker) Run() { 76 | // read until done signal is received 77 | for { 78 | select { 79 | case <-t.Done: 80 | return 81 | case <-t.Ticker.C: 82 | p, err := Get() 83 | if err != nil { 84 | t.Errs <- err 85 | continue 86 | } 87 | t.Data <- p 88 | } 89 | } 90 | } 91 | 92 | // Close closes the ticker resources. 93 | func (t *Ticker) Close() { 94 | t.Ticker.Close() 95 | close(t.Data) 96 | } 97 | -------------------------------------------------------------------------------- /cpu/cpustats/cpustats_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpustats 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | ) 21 | 22 | func TestClkTck(t *testing.T) { 23 | err := ClkTck() 24 | if err != nil { 25 | t.Errorf("expected error to be nil; got %s", err) 26 | } 27 | if CLK_TCK == 0 { 28 | t.Errorf("got %d, want a value > 0", CLK_TCK) 29 | } 30 | } 31 | 32 | func TestGet(t *testing.T) { 33 | s, err := Get() 34 | if err != nil { 35 | t.Errorf("unexpected error: %s", err) 36 | return 37 | } 38 | checkStats("get", s, t) 39 | } 40 | 41 | func TestTicker(t *testing.T) { 42 | tkr, err := NewTicker(time.Millisecond) 43 | if err != nil { 44 | t.Error(err) 45 | return 46 | } 47 | tk := tkr.(*Ticker) 48 | for i := 0; i < 5; i++ { 49 | select { 50 | case <-tk.Done: 51 | break 52 | case v, ok := <-tk.Data: 53 | if !ok { 54 | break 55 | } 56 | checkStats("ticker", v, t) 57 | case err := <-tk.Errs: 58 | t.Errorf("unexpected error: %s", err) 59 | } 60 | } 61 | tk.Stop() 62 | tk.Close() 63 | } 64 | 65 | func checkStats(n string, s *CPUStats, t *testing.T) { 66 | if int16(CLK_TCK) != s.ClkTck { 67 | t.Errorf("%s: ClkTck: got %s; want %s", n, s.ClkTck, CLK_TCK) 68 | } 69 | if s.Timestamp == 0 { 70 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 71 | } 72 | if s.Ctxt == 0 { 73 | t.Errorf("%s: Ctxt: wanted non-zero value; got 0", n) 74 | } 75 | if s.BTime == 0 { 76 | t.Errorf("%s: BTime: wanted non-zero value; got 0", n) 77 | } 78 | if s.Processes == 0 { 79 | t.Errorf("%s: Processes: wanted non-zero value; got 0", n) 80 | } 81 | if len(s.CPU) < 2 { 82 | t.Errorf("%s: expected stats for at least 2 CPU entries, got %d", n, len(s.CPU)) 83 | } 84 | for i := 0; i < len(s.CPU); i++ { 85 | if s.CPU[i].ID == "" { 86 | t.Errorf("%s: CPU %d: ID: wanted a non-empty value; was empty", n, i) 87 | } 88 | if s.CPU[i].User == 0 { 89 | t.Errorf("%s: CPU %d: User: wanted a non-zero value, was 0", n, i) 90 | } 91 | if s.CPU[i].System == 0 { 92 | t.Errorf("%s: CPU %d: System: wanted a non-xero value, was 0", n, i) 93 | } 94 | } 95 | } 96 | 97 | var stts *CPUStats 98 | 99 | func BenchmarkGet(b *testing.B) { 100 | p, _ := NewProfiler() 101 | b.ResetTimer() 102 | for i := 0; i < b.N; i++ { 103 | stts, _ = p.Get() 104 | } 105 | _ = stts 106 | } 107 | -------------------------------------------------------------------------------- /cpu/cpustats/flat/structs/CPUStats.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CPUStats struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsCPUStats(buf []byte, offset flatbuffers.UOffsetT) *CPUStats { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &CPUStats{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *CPUStats) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *CPUStats) ClkTck() int16 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt16(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *CPUStats) Timestamp() int64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *CPUStats) Ctxt() int64 { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 44 | } 45 | return 0 46 | } 47 | 48 | func (rcv *CPUStats) BTime() int64 { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 52 | } 53 | return 0 54 | } 55 | 56 | func (rcv *CPUStats) Processes() int64 { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 60 | } 61 | return 0 62 | } 63 | 64 | func (rcv *CPUStats) CPU(obj *CPU, j int) bool { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | x := rcv._tab.Vector(o) 68 | x += flatbuffers.UOffsetT(j) * 4 69 | x = rcv._tab.Indirect(x) 70 | if obj == nil { 71 | obj = new(CPU) 72 | } 73 | obj.Init(rcv._tab.Bytes, x) 74 | return true 75 | } 76 | return false 77 | } 78 | 79 | func (rcv *CPUStats) CPULength() int { 80 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 81 | if o != 0 { 82 | return rcv._tab.VectorLen(o) 83 | } 84 | return 0 85 | } 86 | 87 | func CPUStatsStart(builder *flatbuffers.Builder) { builder.StartObject(6) } 88 | func CPUStatsAddClkTck(builder *flatbuffers.Builder, ClkTck int16) { builder.PrependInt16Slot(0, ClkTck, 0) } 89 | func CPUStatsAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(1, Timestamp, 0) } 90 | func CPUStatsAddCtxt(builder *flatbuffers.Builder, Ctxt int64) { builder.PrependInt64Slot(2, Ctxt, 0) } 91 | func CPUStatsAddBTime(builder *flatbuffers.Builder, BTime int64) { builder.PrependInt64Slot(3, BTime, 0) } 92 | func CPUStatsAddProcesses(builder *flatbuffers.Builder, Processes int64) { builder.PrependInt64Slot(4, Processes, 0) } 93 | func CPUStatsAddCPU(builder *flatbuffers.Builder, CPU flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(CPU), 0) } 94 | func CPUStatsStartCPUVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 95 | } 96 | func CPUStatsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 97 | -------------------------------------------------------------------------------- /system/loadavg/flat/loadavg_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package loadavg 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | l "github.com/mohae/joefriday/system/loadavg" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("Get(): got %s, want nil", err) 27 | return 28 | } 29 | l := Deserialize(p) 30 | checkLoad("get", l, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case v, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | inf := Deserialize(v) 49 | if err != nil { 50 | t.Error(err) 51 | continue 52 | } 53 | checkLoad("ticker", inf, t) 54 | case err := <-tk.Errs: 55 | t.Errorf("unexpected error: %s", err) 56 | } 57 | } 58 | tk.Stop() 59 | tk.Close() 60 | } 61 | 62 | func checkLoad(n string, la l.LoadAvg, t *testing.T) { 63 | if la.Timestamp == 0 { 64 | t.Errorf("%s: expected Timestamp to be a non-zero value; got 0", n) 65 | } 66 | if la.Minute == 0 { 67 | t.Errorf("%s: expected Minute to be a non-zero value; got 0", n) 68 | } 69 | if la.Five == 0 { 70 | t.Errorf("%s: expected Five to be a non-zero value; got 0", n) 71 | } 72 | if la.Fifteen == 0 { 73 | t.Errorf("%s: expected Fifteen to be a non-zero value; got 0", n) 74 | } 75 | if la.Running == 0 { 76 | t.Errorf("%s: expected Running to be a non-zero value; got 0", n) 77 | } 78 | if la.Total == 0 { 79 | t.Errorf("%s: expected Total to be a non-zero value; got 0", n) 80 | } 81 | if la.PID == 0 { 82 | t.Errorf("%s: expected PID to be a non-zero value; got 0", n) 83 | } 84 | } 85 | 86 | func BenchmarkGet(b *testing.B) { 87 | var tmp []byte 88 | p, _ := NewProfiler() 89 | b.ResetTimer() 90 | for i := 0; i < b.N; i++ { 91 | tmp, _ = p.Get() 92 | } 93 | _ = tmp 94 | } 95 | 96 | func BenchmarkSerialize(b *testing.B) { 97 | var tmp []byte 98 | p, _ := NewProfiler() 99 | l, _ := p.Profiler.Get() 100 | b.ResetTimer() 101 | for i := 0; i < b.N; i++ { 102 | tmp, _ = Serialize(l) 103 | } 104 | _ = tmp 105 | } 106 | 107 | func BenchmarkDeserialize(b *testing.B) { 108 | var la l.LoadAvg 109 | p, _ := NewProfiler() 110 | tmp, _ := p.Get() 111 | b.ResetTimer() 112 | for i := 0; i < b.N; i++ { 113 | la = Deserialize(tmp) 114 | } 115 | _ = la 116 | } 117 | -------------------------------------------------------------------------------- /cpu/cpuutil/flat/structs/CPUUtil.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CPUUtil struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsCPUUtil(buf []byte, offset flatbuffers.UOffsetT) *CPUUtil { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &CPUUtil{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *CPUUtil) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *CPUUtil) Timestamp() int64 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *CPUUtil) TimeDelta() int64 { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 36 | } 37 | return 0 38 | } 39 | 40 | func (rcv *CPUUtil) BTimeDelta() int32 { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 44 | } 45 | return 0 46 | } 47 | 48 | func (rcv *CPUUtil) CtxtDelta() int64 { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.GetInt64(o + rcv._tab.Pos) 52 | } 53 | return 0 54 | } 55 | 56 | func (rcv *CPUUtil) Processes() int32 { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 60 | } 61 | return 0 62 | } 63 | 64 | func (rcv *CPUUtil) CPU(obj *Utilization, j int) bool { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | x := rcv._tab.Vector(o) 68 | x += flatbuffers.UOffsetT(j) * 4 69 | x = rcv._tab.Indirect(x) 70 | if obj == nil { 71 | obj = new(Utilization) 72 | } 73 | obj.Init(rcv._tab.Bytes, x) 74 | return true 75 | } 76 | return false 77 | } 78 | 79 | func (rcv *CPUUtil) CPULength() int { 80 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 81 | if o != 0 { 82 | return rcv._tab.VectorLen(o) 83 | } 84 | return 0 85 | } 86 | 87 | func CPUUtilStart(builder *flatbuffers.Builder) { builder.StartObject(6) } 88 | func CPUUtilAddTimestamp(builder *flatbuffers.Builder, Timestamp int64) { builder.PrependInt64Slot(0, Timestamp, 0) } 89 | func CPUUtilAddTimeDelta(builder *flatbuffers.Builder, TimeDelta int64) { builder.PrependInt64Slot(1, TimeDelta, 0) } 90 | func CPUUtilAddBTimeDelta(builder *flatbuffers.Builder, BTimeDelta int32) { builder.PrependInt32Slot(2, BTimeDelta, 0) } 91 | func CPUUtilAddCtxtDelta(builder *flatbuffers.Builder, CtxtDelta int64) { builder.PrependInt64Slot(3, CtxtDelta, 0) } 92 | func CPUUtilAddProcesses(builder *flatbuffers.Builder, Processes int32) { builder.PrependInt32Slot(4, Processes, 0) } 93 | func CPUUtilAddCPU(builder *flatbuffers.Builder, CPU flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(CPU), 0) } 94 | func CPUUtilStartCPUVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 95 | } 96 | func CPUUtilEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 97 | -------------------------------------------------------------------------------- /cpu/cpux/flat/structs/CPUs.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type CPUs struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsCPUs(buf []byte, offset flatbuffers.UOffsetT) *CPUs { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &CPUs{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *CPUs) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *CPUs) Sockets() int32 { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.GetInt32(o + rcv._tab.Pos) 28 | } 29 | return 0 30 | } 31 | 32 | func (rcv *CPUs) Possible() []byte { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 36 | } 37 | return nil 38 | } 39 | 40 | func (rcv *CPUs) Present() []byte { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 44 | } 45 | return nil 46 | } 47 | 48 | func (rcv *CPUs) Online() []byte { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 52 | } 53 | return nil 54 | } 55 | 56 | func (rcv *CPUs) Offline() []byte { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 60 | } 61 | return nil 62 | } 63 | 64 | func (rcv *CPUs) CPU(obj *CPU, j int) bool { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | x := rcv._tab.Vector(o) 68 | x += flatbuffers.UOffsetT(j) * 4 69 | x = rcv._tab.Indirect(x) 70 | if obj == nil { 71 | obj = new(CPU) 72 | } 73 | obj.Init(rcv._tab.Bytes, x) 74 | return true 75 | } 76 | return false 77 | } 78 | 79 | func (rcv *CPUs) CPULength() int { 80 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 81 | if o != 0 { 82 | return rcv._tab.VectorLen(o) 83 | } 84 | return 0 85 | } 86 | 87 | func CPUsStart(builder *flatbuffers.Builder) { builder.StartObject(6) } 88 | func CPUsAddSockets(builder *flatbuffers.Builder, Sockets int32) { builder.PrependInt32Slot(0, Sockets, 0) } 89 | func CPUsAddPossible(builder *flatbuffers.Builder, Possible flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(Possible), 0) } 90 | func CPUsAddPresent(builder *flatbuffers.Builder, Present flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(Present), 0) } 91 | func CPUsAddOnline(builder *flatbuffers.Builder, Online flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(Online), 0) } 92 | func CPUsAddOffline(builder *flatbuffers.Builder, Offline flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(Offline), 0) } 93 | func CPUsAddCPU(builder *flatbuffers.Builder, CPU flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(CPU), 0) } 94 | func CPUsStartCPUVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) 95 | } 96 | func CPUsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 97 | -------------------------------------------------------------------------------- /system/version/json/version_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package version 15 | 16 | import ( 17 | "testing" 18 | 19 | v "github.com/mohae/joefriday/system/version" 20 | ) 21 | 22 | func TestGet(t *testing.T) { 23 | p, err := Get() 24 | if err != nil { 25 | t.Errorf("got %s, want nil", err) 26 | return 27 | } 28 | k, err := v.Get() 29 | if err != nil { 30 | t.Errorf("version.Get(): got %s, want nil", err) 31 | return 32 | } 33 | kD, err := Deserialize(p) 34 | if err != nil { 35 | t.Errorf("deserialize: unexpected error: %s", err) 36 | return 37 | } 38 | if k.OS != kD.OS { 39 | t.Errorf("OS: got %s; want %s", kD.OS, k.OS) 40 | } 41 | if k.Version != kD.Version { 42 | t.Errorf("Version: got %s; want %s", kD.Version, k.Version) 43 | } 44 | if k.CompileUser != kD.CompileUser { 45 | t.Errorf("CompileUser: got %s; want %s", kD.CompileUser, k.CompileUser) 46 | } 47 | if k.GCC != kD.GCC { 48 | t.Errorf("GCC: got %s; want %s", kD.GCC, k.GCC) 49 | } 50 | if k.OSGCC != kD.OSGCC { 51 | t.Errorf("Version: got %s; want %s", kD.OSGCC, k.OSGCC) 52 | } 53 | if k.Type != kD.Type { 54 | t.Errorf("Version: got %s; want %s", kD.Type, k.Type) 55 | } 56 | if k.CompileDate != kD.CompileDate { 57 | t.Errorf("CompileDate: got %s; want %s", kD.CompileDate, k.CompileDate) 58 | } 59 | if k.Arch != kD.Arch { 60 | t.Errorf("Arch: got %s; want %s", kD.Arch, k.Arch) 61 | } 62 | } 63 | 64 | func BenchmarkGet(b *testing.B) { 65 | var jsn []byte 66 | p, _ := NewProfiler() 67 | b.ResetTimer() 68 | for i := 0; i < b.N; i++ { 69 | jsn, _ = p.Get() 70 | } 71 | _ = jsn 72 | } 73 | 74 | func BenchmarkSerialize(b *testing.B) { 75 | var jsn []byte 76 | p, _ := NewProfiler() 77 | v, _ := p.Profiler.Get() 78 | b.ResetTimer() 79 | for i := 0; i < b.N; i++ { 80 | jsn, _ = p.Serialize(v) 81 | } 82 | _ = jsn 83 | } 84 | 85 | func BenchmarkMarshal(b *testing.B) { 86 | var jsn []byte 87 | p, _ := NewProfiler() 88 | v, _ := p.Profiler.Get() 89 | b.ResetTimer() 90 | for i := 0; i < b.N; i++ { 91 | jsn, _ = p.Marshal(v) 92 | } 93 | _ = jsn 94 | } 95 | 96 | func BenchmarkDeserialize(b *testing.B) { 97 | var k *v.Kernel 98 | p, _ := NewProfiler() 99 | tmp, _ := p.Get() 100 | b.ResetTimer() 101 | for i := 0; i < b.N; i++ { 102 | k, _ = Deserialize(tmp) 103 | } 104 | _ = k 105 | } 106 | 107 | func BenchmarkUnmarshal(b *testing.B) { 108 | var k *v.Kernel 109 | p, _ := NewProfiler() 110 | tmp, _ := p.Get() 111 | b.ResetTimer() 112 | for i := 0; i < b.N; i++ { 113 | k, _ = Unmarshal(tmp) 114 | } 115 | _ = k 116 | } 117 | -------------------------------------------------------------------------------- /system/os/json/os_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package os 15 | 16 | import ( 17 | "testing" 18 | 19 | o "github.com/mohae/joefriday/system/os" 20 | ) 21 | 22 | func TestGet(t *testing.T) { 23 | p, err := Get() 24 | if err != nil { 25 | t.Errorf("got %s, want nil", err) 26 | return 27 | } 28 | os, err := o.Get() 29 | if err != nil { 30 | t.Errorf("release.Get(): got %s, want nil", err) 31 | return 32 | } 33 | osD, err := Deserialize(p) 34 | if err != nil { 35 | t.Errorf("deserialize: unexpected error: %s", err) 36 | return 37 | } 38 | if os.Name != osD.Name { 39 | t.Errorf("Name: got %s; want %s", osD.Name, os.Name) 40 | } 41 | if os.ID != osD.ID { 42 | t.Errorf("ID: got %s; want %s", osD.ID, os.ID) 43 | } 44 | if os.IDLike != osD.IDLike { 45 | t.Errorf("IDLike: got %s; want %s", osD.IDLike, os.IDLike) 46 | } 47 | if os.PrettyName != osD.PrettyName { 48 | t.Errorf("PrettyName: got %s; want %s", osD.PrettyName, os.PrettyName) 49 | } 50 | if os.Version != osD.Version { 51 | t.Errorf("Version: got %s; want %s", osD.Version, os.Version) 52 | } 53 | if os.VersionID != osD.VersionID { 54 | t.Errorf("VersionID: got %s; want %s", osD.VersionID, os.VersionID) 55 | } 56 | if os.HomeURL != osD.HomeURL { 57 | t.Errorf("HomeURL: got %s; want %s", osD.HomeURL, os.HomeURL) 58 | } 59 | if os.BugReportURL != osD.BugReportURL { 60 | t.Errorf("BugReportURL: got %s; want %s", osD.BugReportURL, os.BugReportURL) 61 | } 62 | } 63 | 64 | func BenchmarkGet(b *testing.B) { 65 | var jsn []byte 66 | p, _ := NewProfiler() 67 | b.ResetTimer() 68 | for i := 0; i < b.N; i++ { 69 | jsn, _ = p.Get() 70 | } 71 | _ = jsn 72 | } 73 | 74 | func BenchmarkSerialize(b *testing.B) { 75 | var jsn []byte 76 | p, _ := NewProfiler() 77 | v, _ := p.Profiler.Get() 78 | b.ResetTimer() 79 | for i := 0; i < b.N; i++ { 80 | jsn, _ = p.Serialize(v) 81 | } 82 | _ = jsn 83 | } 84 | 85 | func BenchmarkMarshal(b *testing.B) { 86 | var jsn []byte 87 | p, _ := NewProfiler() 88 | v, _ := p.Profiler.Get() 89 | b.ResetTimer() 90 | for i := 0; i < b.N; i++ { 91 | jsn, _ = p.Marshal(v) 92 | } 93 | _ = jsn 94 | } 95 | 96 | func BenchmarkDeserialize(b *testing.B) { 97 | var os *o.OS 98 | p, _ := NewProfiler() 99 | tmp, _ := p.Get() 100 | b.ResetTimer() 101 | for i := 0; i < b.N; i++ { 102 | os, _ = Deserialize(tmp) 103 | } 104 | _ = os 105 | } 106 | 107 | func BenchmarkUnmarshal(b *testing.B) { 108 | var os *o.OS 109 | p, _ := NewProfiler() 110 | tmp, _ := p.Get() 111 | b.ResetTimer() 112 | for i := 0; i < b.N; i++ { 113 | os, _ = Unmarshal(tmp) 114 | } 115 | _ = os 116 | } 117 | -------------------------------------------------------------------------------- /cpu/cpuutil/flat/cpuutil_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpuutil 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | util "github.com/mohae/joefriday/cpu/cpuutil" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := NewProfiler() 25 | if err != nil { 26 | t.Errorf("unexpected error: %s", err) 27 | return 28 | } 29 | time.Sleep(time.Duration(300) * time.Millisecond) 30 | b, err := p.Get() 31 | if err != nil { 32 | t.Errorf("unexpected error: %s", err) 33 | return 34 | } 35 | u := Deserialize(b) 36 | checkCPUUtil("get", u, t) 37 | } 38 | 39 | func TestTicker(t *testing.T) { 40 | tkr, err := NewTicker(time.Millisecond) 41 | if err != nil { 42 | t.Error(err) 43 | return 44 | } 45 | tk := tkr.(*Ticker) 46 | for i := 0; i < 5; i++ { 47 | select { 48 | case <-tk.Done: 49 | break 50 | case v, ok := <-tk.Data: 51 | if !ok { 52 | break 53 | } 54 | u := Deserialize(v) 55 | checkCPUUtil("ticker", u, t) 56 | case err := <-tk.Errs: 57 | t.Errorf("unexpected error: %s", err) 58 | } 59 | } 60 | tk.Stop() 61 | tk.Close() 62 | } 63 | 64 | func checkCPUUtil(name string, u *util.CPUUtil, t *testing.T) { 65 | if u.Timestamp == 0 { 66 | t.Errorf("%s: timestamp: expected on-zero", name) 67 | } 68 | if u.TimeDelta == 0 { 69 | t.Errorf("%s: TimeDelta: expected non-zero value, got 0", name) 70 | } 71 | if u.CtxtDelta == 0 { 72 | t.Errorf("%s: CtxtDelta: expected non-zero value, got 0", name) 73 | } 74 | if u.BTimeDelta == 0 { 75 | t.Errorf("%s: BTimeDelta: expected non-zero value, got 0", name) 76 | } 77 | if u.Processes == 0 { 78 | t.Errorf("%s: Processes: expected non-zero value, got 0", name) 79 | } 80 | if len(u.CPU) < 2 { 81 | t.Errorf("%s: cpu: got %d, want at least 2", name, len(u.CPU)) 82 | } 83 | for i, v := range u.CPU { 84 | if v.ID == "" { 85 | t.Errorf("%s: %d: expected ID to have a value, was empty", name, i) 86 | } 87 | } 88 | } 89 | 90 | func BenchmarkGet(b *testing.B) { 91 | var tmp []byte 92 | p, _ := NewProfiler() 93 | b.ResetTimer() 94 | for i := 0; i < b.N; i++ { 95 | tmp, _ = p.Get() 96 | } 97 | _ = tmp 98 | } 99 | 100 | func BenchmarkSerialize(b *testing.B) { 101 | var tmp []byte 102 | p, _ := NewProfiler() 103 | st, _ := p.Profiler.Get() 104 | b.ResetTimer() 105 | for i := 0; i < b.N; i++ { 106 | tmp, _ = Serialize(st) 107 | } 108 | _ = tmp 109 | } 110 | 111 | func BenchmarkDeserialize(b *testing.B) { 112 | var u *util.CPUUtil 113 | p, _ := NewProfiler() 114 | tmp, _ := p.Get() 115 | b.ResetTimer() 116 | for i := 0; i < b.N; i++ { 117 | u = Deserialize(tmp) 118 | } 119 | _ = u 120 | } 121 | -------------------------------------------------------------------------------- /system/uptime/json/uptime_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package uptime 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | u "github.com/mohae/joefriday/system/uptime" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("Get(): got %s, want nil", err) 27 | return 28 | } 29 | up, err := Deserialize(p) 30 | if err != nil { 31 | t.Errorf("unexpected error: %s", err) 32 | return 33 | } 34 | checkUptime("get", up, t) 35 | } 36 | 37 | func TestTicker(t *testing.T) { 38 | tkr, err := NewTicker(time.Millisecond) 39 | if err != nil { 40 | t.Error(err) 41 | return 42 | } 43 | tk := tkr.(*Ticker) 44 | for i := 0; i < 5; i++ { 45 | select { 46 | case <-tk.Done: 47 | break 48 | case v, ok := <-tk.Data: 49 | if !ok { 50 | break 51 | } 52 | up, err := Deserialize(v) 53 | if err != nil { 54 | t.Errorf("unexpected error: %s", err) 55 | continue 56 | } 57 | checkUptime("ticker", up, t) 58 | case err := <-tk.Errs: 59 | t.Errorf("unexpected error: %s", err) 60 | } 61 | } 62 | tk.Stop() 63 | tk.Close() 64 | } 65 | 66 | func checkUptime(n string, up u.Uptime, t *testing.T) { 67 | if up.Timestamp == 0 { 68 | t.Errorf("expected Timestamp to be a non-zero value; got 0") 69 | } 70 | if up.Total == 0 { 71 | t.Errorf("expected total to be a non-zero value; got 0") 72 | } 73 | if up.Idle == 0 { 74 | t.Errorf("expected idle to be a non-zero value; got 0") 75 | } 76 | } 77 | 78 | func BenchmarkGet(b *testing.B) { 79 | var jsn []byte 80 | p, _ := NewProfiler() 81 | b.ResetTimer() 82 | for i := 0; i < b.N; i++ { 83 | jsn, _ = p.Get() 84 | } 85 | _ = jsn 86 | } 87 | 88 | func BenchmarkSerialize(b *testing.B) { 89 | var jsn []byte 90 | p, _ := NewProfiler() 91 | v, _ := p.Profiler.Get() 92 | b.ResetTimer() 93 | for i := 0; i < b.N; i++ { 94 | jsn, _ = p.Serialize(v) 95 | } 96 | _ = jsn 97 | } 98 | 99 | func BenchmarkMarshal(b *testing.B) { 100 | var jsn []byte 101 | p, _ := NewProfiler() 102 | v, _ := p.Profiler.Get() 103 | b.ResetTimer() 104 | for i := 0; i < b.N; i++ { 105 | jsn, _ = p.Marshal(v) 106 | } 107 | _ = jsn 108 | } 109 | 110 | func BenchmarkDeserialize(b *testing.B) { 111 | var up u.Uptime 112 | p, _ := NewProfiler() 113 | tmp, _ := p.Get() 114 | b.ResetTimer() 115 | for i := 0; i < b.N; i++ { 116 | up, _ = Deserialize(tmp) 117 | } 118 | _ = up 119 | } 120 | 121 | func BenchmarkUnmarshal(b *testing.B) { 122 | var up u.Uptime 123 | p, _ := NewProfiler() 124 | tmp, _ := p.Get() 125 | b.ResetTimer() 126 | for i := 0; i < b.N; i++ { 127 | up, _ = Unmarshal(tmp) 128 | } 129 | _ = up 130 | } 131 | -------------------------------------------------------------------------------- /mem/membasic/flat/membasic_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package membasic 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | basic "github.com/mohae/joefriday/mem/membasic" 21 | ) 22 | 23 | func TestSerializeDeserialize(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | inf := Deserialize(p) 30 | checkInfo("get", *inf, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case v, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | inf := Deserialize(v) 49 | checkInfo("ticker", *inf, t) 50 | case err := <-tk.Errs: 51 | t.Errorf("unexpected error: %s", err) 52 | } 53 | } 54 | tk.Stop() 55 | tk.Close() 56 | } 57 | 58 | func checkInfo(n string, i basic.Info, t *testing.T) { 59 | if i.Timestamp == 0 { 60 | t.Errorf("%s: expected timestamp to be a non-zero value, got 0", n) 61 | } 62 | if i.Active == 0 { 63 | t.Errorf("%s: expected Active to be a non-zero value, got 0", n) 64 | } 65 | if i.Inactive == 0 { 66 | t.Errorf("%s: expected Inactive to be a non-zero value, got 0", n) 67 | } 68 | if i.Mapped == 0 { 69 | t.Errorf("%s: expected Mapped to be a non-zero value, got 0", n) 70 | } 71 | if i.MemAvailable == 0 { 72 | t.Errorf("%s: expected MemAvailable to be a non-zero value, got 0", n) 73 | } 74 | if i.MemFree == 0 { 75 | t.Errorf("%s: expected MemFree to be a non-zero value, got 0", n) 76 | } 77 | if i.MemTotal == 0 { 78 | t.Errorf("%s: expected MemTotal to be a non-zero value, got 0", n) 79 | } 80 | if i.SwapFree == 0 { 81 | t.Errorf("%s: expected SwapFree to be a non-zero value, got 0", n) 82 | } 83 | if i.SwapTotal == 0 { 84 | t.Errorf("%s: expected SwapTotal to be a non-zero value, got 0", n) 85 | } 86 | t.Logf("%#v\n", i) 87 | } 88 | 89 | func BenchmarkGet(b *testing.B) { 90 | var tmp []byte 91 | p, _ := NewProfiler() 92 | b.ResetTimer() 93 | for i := 0; i < b.N; i++ { 94 | tmp, _ = p.Get() 95 | } 96 | _ = tmp 97 | } 98 | 99 | func BenchmarkSerialize(b *testing.B) { 100 | var tmp []byte 101 | p, _ := NewProfiler() 102 | inf, _ := p.Profiler.Get() 103 | b.ResetTimer() 104 | for i := 0; i < b.N; i++ { 105 | tmp, _ = Serialize(inf) 106 | } 107 | _ = tmp 108 | } 109 | 110 | var inf *basic.Info 111 | 112 | func BenchmarkDeserialize(b *testing.B) { 113 | p, _ := NewProfiler() 114 | tmp, _ := p.Get() 115 | b.ResetTimer() 116 | for i := 0; i < b.N; i++ { 117 | inf = Deserialize(tmp) 118 | } 119 | _ = inf 120 | } 121 | -------------------------------------------------------------------------------- /cpu/cpustats/flat/cpustats_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpustats 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | stats "github.com/mohae/joefriday/cpu/cpustats" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | p, err := Get() 25 | if err != nil { 26 | t.Errorf("unexpected error: %s", err) 27 | return 28 | } 29 | statsD := Deserialize(p) 30 | checkStats("get", statsD, t) 31 | } 32 | 33 | func TestTicker(t *testing.T) { 34 | tkr, err := NewTicker(time.Millisecond) 35 | if err != nil { 36 | t.Error(err) 37 | return 38 | } 39 | tk := tkr.(*Ticker) 40 | for i := 0; i < 5; i++ { 41 | select { 42 | case <-tk.Done: 43 | break 44 | case v, ok := <-tk.Data: 45 | if !ok { 46 | break 47 | } 48 | st := Deserialize(v) 49 | checkStats("ticker", st, t) 50 | case err := <-tk.Errs: 51 | t.Errorf("unexpected error: %s", err) 52 | } 53 | } 54 | tk.Stop() 55 | tk.Close() 56 | } 57 | 58 | func checkStats(n string, s *stats.CPUStats, t *testing.T) { 59 | if int16(stats.CLK_TCK) != s.ClkTck { 60 | t.Errorf("ClkTck: got %s; want %s", n, s.ClkTck, stats.CLK_TCK) 61 | } 62 | if s.Timestamp == 0 { 63 | t.Errorf("%s: Timestamp: wanted non-zero value; got 0", n) 64 | } 65 | if s.Ctxt == 0 { 66 | t.Errorf("%s: Ctxt: wanted non-zero value; got 0", n) 67 | } 68 | if s.BTime == 0 { 69 | t.Errorf("%s: BTime: wanted non-zero value; got 0", n) 70 | } 71 | if s.Processes == 0 { 72 | t.Errorf("%s: Processes: wanted non-zero value; got 0", n) 73 | } 74 | if len(s.CPU) < 2 { 75 | t.Errorf("%s: expected stats for at least 2 CPU entries, got %d", n, len(s.CPU)) 76 | } 77 | for i := 0; i < len(s.CPU); i++ { 78 | if s.CPU[i].ID == "" { 79 | t.Errorf("%s: CPU %d: ID: wanted a non-empty value; was empty", n, i) 80 | } 81 | if s.CPU[i].User == 0 { 82 | t.Errorf("%s: CPU %d: User: wanted a non-zero value, was 0", n, i) 83 | } 84 | if s.CPU[i].System == 0 { 85 | t.Errorf("%s: CPU %d: System: wanted a non-xero value, was 0", n, i) 86 | } 87 | } 88 | } 89 | 90 | func BenchmarkGet(b *testing.B) { 91 | var tmp []byte 92 | p, _ := NewProfiler() 93 | b.ResetTimer() 94 | for i := 0; i < b.N; i++ { 95 | tmp, _ = p.Get() 96 | } 97 | _ = tmp 98 | } 99 | 100 | func BenchmarkSerialize(b *testing.B) { 101 | var tmp []byte 102 | p, _ := NewProfiler() 103 | st, _ := p.Profiler.Get() 104 | b.ResetTimer() 105 | for i := 0; i < b.N; i++ { 106 | tmp, _ = Serialize(st) 107 | } 108 | _ = tmp 109 | } 110 | 111 | func BenchmarkDeserialize(b *testing.B) { 112 | var st *stats.CPUStats 113 | p, _ := NewProfiler() 114 | tmp, _ := p.Get() 115 | b.ResetTimer() 116 | for i := 0; i < b.N; i++ { 117 | st = Deserialize(tmp) 118 | } 119 | _ = st 120 | } 121 | -------------------------------------------------------------------------------- /cpu/cpuinfo/json/cpuinfo_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package cpuinfo 15 | 16 | import ( 17 | "testing" 18 | 19 | "github.com/mohae/joefriday" 20 | "github.com/mohae/joefriday/cpu/cpuinfo" 21 | "github.com/mohae/joefriday/testinfo" 22 | ) 23 | 24 | func TestGeti75600u(t *testing.T) { 25 | tProc, err := joefriday.NewTempFileProc("intel", "i9700u", testinfo.I75600uCPUInfo) 26 | if err != nil { 27 | t.Fatal(err) 28 | } 29 | defer tProc.Remove() 30 | prof, err := NewProfiler() 31 | if err != nil { 32 | t.Fatal(err) 33 | } 34 | prof.Profiler.Procer = tProc 35 | inf, err := prof.Get() 36 | if err != nil { 37 | t.Errorf("unexpected error: %s", err) 38 | } 39 | info, err := Unmarshal(inf) 40 | if err != nil { 41 | t.Errorf("unexpected error: %s", err) 42 | } 43 | err = testinfo.ValidateI75600uCPUInfo(info) 44 | if err != nil { 45 | t.Error(err) 46 | } 47 | } 48 | 49 | func TestGetR71800xJSON(t *testing.T) { 50 | tProc, err := joefriday.NewTempFileProc("amd", "r71800x", testinfo.R71800xCPUInfo) 51 | if err != nil { 52 | t.Fatal(err) 53 | } 54 | defer tProc.Remove() 55 | prof, err := NewProfiler() 56 | if err != nil { 57 | t.Fatal(err) 58 | } 59 | prof.Procer = tProc 60 | inf, err := prof.Get() 61 | if err != nil { 62 | t.Errorf("unexpected error: %s", err) 63 | } 64 | info, err := Unmarshal(inf) 65 | if err != nil { 66 | t.Errorf("unexpected error: %s", err) 67 | } 68 | err = testinfo.ValidateR71800xCPUInfo(info) 69 | if err != nil { 70 | t.Error(err) 71 | } 72 | t.Log(info) 73 | } 74 | 75 | func BenchmarkGet(b *testing.B) { 76 | var jsn []byte 77 | p, _ := NewProfiler() 78 | b.ResetTimer() 79 | for i := 0; i < b.N; i++ { 80 | jsn, _ = p.Get() 81 | } 82 | _ = jsn 83 | } 84 | 85 | func BenchmarkSerialize(b *testing.B) { 86 | var jsn []byte 87 | p, _ := NewProfiler() 88 | v, _ := p.Profiler.Get() 89 | b.ResetTimer() 90 | for i := 0; i < b.N; i++ { 91 | jsn, _ = p.Serialize(v) 92 | } 93 | _ = jsn 94 | } 95 | 96 | func BenchmarkMarshal(b *testing.B) { 97 | var jsn []byte 98 | p, _ := NewProfiler() 99 | v, _ := p.Profiler.Get() 100 | b.ResetTimer() 101 | for i := 0; i < b.N; i++ { 102 | jsn, _ = p.Marshal(v) 103 | } 104 | _ = jsn 105 | } 106 | 107 | func BenchmarkDeserialize(b *testing.B) { 108 | var inf *cpuinfo.CPUInfo 109 | p, _ := NewProfiler() 110 | infB, _ := p.Get() 111 | b.ResetTimer() 112 | for i := 0; i < b.N; i++ { 113 | inf, _ = Deserialize(infB) 114 | } 115 | _ = inf 116 | } 117 | 118 | func BenchmarkUnmarshal(b *testing.B) { 119 | var inf *cpuinfo.CPUInfo 120 | p, _ := NewProfiler() 121 | infB, _ := p.Get() 122 | b.ResetTimer() 123 | for i := 0; i < b.N; i++ { 124 | inf, _ = Unmarshal(infB) 125 | } 126 | _ = inf 127 | } 128 | -------------------------------------------------------------------------------- /net/netdev/json/netdev_unix_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | package netdev 15 | 16 | import ( 17 | "testing" 18 | "time" 19 | 20 | "github.com/mohae/joefriday/net/structs" 21 | ) 22 | 23 | func TestGet(t *testing.T) { 24 | nf, err := Get() 25 | if err != nil { 26 | t.Errorf("got %s, want nil", err) 27 | return 28 | } 29 | info, err := Deserialize(nf) 30 | if err != nil { 31 | t.Errorf("got %s, want nil", err) 32 | return 33 | } 34 | checkInfo("get", info, t) 35 | t.Logf("%#v\n", info) 36 | } 37 | 38 | func TestTicker(t *testing.T) { 39 | tkr, err := NewTicker(time.Millisecond) 40 | if err != nil { 41 | t.Error(err) 42 | return 43 | } 44 | tk := tkr.(*Ticker) 45 | for i := 0; i < 5; i++ { 46 | select { 47 | case <-tk.Done: 48 | break 49 | case v, ok := <-tk.Data: 50 | if !ok { 51 | break 52 | } 53 | inf, err := Deserialize(v) 54 | if err != nil { 55 | t.Error(err) 56 | continue 57 | } 58 | checkInfo("ticker", inf, t) 59 | case err := <-tk.Errs: 60 | t.Errorf("unexpected error: %s", err) 61 | } 62 | } 63 | tk.Stop() 64 | tk.Close() 65 | } 66 | 67 | func checkInfo(n string, inf *structs.DevInfo, t *testing.T) { 68 | if inf.Timestamp == 0 { 69 | t.Errorf("%s: expected timestamp to be a non-zero value; was 0", n) 70 | } 71 | if len(inf.Device) == 0 { 72 | t.Errorf("%s: expected devices; got none", n) 73 | return 74 | } 75 | // check name 76 | for i, v := range inf.Device { 77 | if v.Name == "" { 78 | t.Errorf("%s: %d: expected device to have a name; was empty", n, i) 79 | } 80 | } 81 | } 82 | 83 | func BenchmarkGet(b *testing.B) { 84 | var jsn []byte 85 | p, _ := NewProfiler() 86 | b.ResetTimer() 87 | for i := 0; i < b.N; i++ { 88 | jsn, _ = p.Get() 89 | } 90 | _ = jsn 91 | } 92 | 93 | func BenchmarkSerialize(b *testing.B) { 94 | var jsn []byte 95 | p, _ := NewProfiler() 96 | v, _ := p.Profiler.Get() 97 | b.ResetTimer() 98 | for i := 0; i < b.N; i++ { 99 | jsn, _ = p.Serialize(v) 100 | } 101 | _ = jsn 102 | } 103 | 104 | func BenchmarkMarshal(b *testing.B) { 105 | var jsn []byte 106 | p, _ := NewProfiler() 107 | v, _ := p.Profiler.Get() 108 | b.ResetTimer() 109 | for i := 0; i < b.N; i++ { 110 | jsn, _ = p.Marshal(v) 111 | } 112 | _ = jsn 113 | } 114 | 115 | func BenchmarkDeserialize(b *testing.B) { 116 | var inf *structs.DevInfo 117 | p, _ := NewProfiler() 118 | tmp, _ := p.Get() 119 | b.ResetTimer() 120 | for i := 0; i < b.N; i++ { 121 | inf, _ = Deserialize(tmp) 122 | } 123 | _ = inf 124 | } 125 | 126 | func BenchmarkUnmarshal(b *testing.B) { 127 | var inf *structs.DevInfo 128 | p, _ := NewProfiler() 129 | tmp, _ := p.Get() 130 | b.ResetTimer() 131 | for i := 0; i < b.N; i++ { 132 | inf, _ = Unmarshal(tmp) 133 | } 134 | _ = inf 135 | } 136 | -------------------------------------------------------------------------------- /system/os/flat/structs/OS.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type OS struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsOS(buf []byte, offset flatbuffers.UOffsetT) *OS { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &OS{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *OS) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *OS) Name() []byte { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 28 | } 29 | return nil 30 | } 31 | 32 | func (rcv *OS) ID() []byte { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 36 | } 37 | return nil 38 | } 39 | 40 | func (rcv *OS) IDLike() []byte { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 44 | } 45 | return nil 46 | } 47 | 48 | func (rcv *OS) PrettyName() []byte { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 52 | } 53 | return nil 54 | } 55 | 56 | func (rcv *OS) Version() []byte { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 60 | } 61 | return nil 62 | } 63 | 64 | func (rcv *OS) VersionID() []byte { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 68 | } 69 | return nil 70 | } 71 | 72 | func (rcv *OS) HomeURL() []byte { 73 | o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) 74 | if o != 0 { 75 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 76 | } 77 | return nil 78 | } 79 | 80 | func (rcv *OS) BugReportURL() []byte { 81 | o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) 82 | if o != 0 { 83 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 84 | } 85 | return nil 86 | } 87 | 88 | func OSStart(builder *flatbuffers.Builder) { builder.StartObject(8) } 89 | func OSAddName(builder *flatbuffers.Builder, Name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(Name), 0) } 90 | func OSAddID(builder *flatbuffers.Builder, ID flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(ID), 0) } 91 | func OSAddIDLike(builder *flatbuffers.Builder, IDLike flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(IDLike), 0) } 92 | func OSAddPrettyName(builder *flatbuffers.Builder, PrettyName flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(PrettyName), 0) } 93 | func OSAddVersion(builder *flatbuffers.Builder, Version flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(Version), 0) } 94 | func OSAddVersionID(builder *flatbuffers.Builder, VersionID flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(VersionID), 0) } 95 | func OSAddHomeURL(builder *flatbuffers.Builder, HomeURL flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(HomeURL), 0) } 96 | func OSAddBugReportURL(builder *flatbuffers.Builder, BugReportURL flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(BugReportURL), 0) } 97 | func OSEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 98 | -------------------------------------------------------------------------------- /bench/cpu/cpu_test.go: -------------------------------------------------------------------------------- 1 | package cpu 2 | 3 | import ( 4 | "encoding/json" 5 | "testing" 6 | 7 | "github.com/DataDog/gohai/cpu" 8 | "github.com/mohae/joefriday/cpu/cpuinfo" 9 | "github.com/mohae/joefriday/cpu/cpustats" 10 | gopsutilcpu "github.com/shirou/gopsutil/cpu" 11 | ) 12 | 13 | func BenchmarkJoeFridayGetInfo(b *testing.B) { 14 | var inf *cpuinfo.CPUInfo 15 | p, _ := cpuinfo.NewProfiler() 16 | b.ResetTimer() 17 | for i := 0; i < b.N; i++ { 18 | inf, _ = p.Get() 19 | } 20 | _ = inf 21 | } 22 | 23 | func BenchmarkJoeFridayGetStats(b *testing.B) { 24 | var st *cpustats.CPUStats 25 | p, _ := cpustats.NewProfiler() 26 | b.ResetTimer() 27 | for i := 0; i < b.N; i++ { 28 | st, _ = p.Get() 29 | } 30 | _ = st 31 | } 32 | 33 | func BenchmarkDataDogGohaiCPU(b *testing.B) { 34 | type Collector interface { 35 | Name() string 36 | Collect() (interface{}, error) 37 | } 38 | var collector = &cpu.Cpu{} 39 | var c interface{} 40 | for i := 0; i < b.N; i++ { 41 | c, _ = collector.Collect() 42 | } 43 | _ = c 44 | } 45 | 46 | func BenchmarkShirouGopsutilInfoStat(b *testing.B) { 47 | var st []gopsutilcpu.InfoStat 48 | for i := 0; i < b.N; i++ { 49 | st, _ = gopsutilcpu.Info() 50 | } 51 | _ = st 52 | } 53 | 54 | func BenchmarkShirouGopsutilTimeStat(b *testing.B) { 55 | var st []gopsutilcpu.TimesStat 56 | for i := 0; i < b.N; i++ { 57 | st, _ = gopsutilcpu.Times(true) 58 | } 59 | _ = st 60 | } 61 | 62 | // These tests exist to print out the data that is collected; not to test the 63 | // methods themselves. Run with the -v flag. 64 | func TestJoeFridayGetCPUInfo(t *testing.T) { 65 | prof, err := cpuinfo.NewProfiler() 66 | if err != nil { 67 | t.Error(err) 68 | return 69 | } 70 | inf, err := prof.Get() 71 | if err != nil { 72 | t.Error(err) 73 | return 74 | } 75 | p, err := json.MarshalIndent(inf, "", "\t") 76 | if err != nil { 77 | t.Error(err) 78 | return 79 | } 80 | t.Logf("%s\n", string(p)) 81 | } 82 | 83 | func TestJoeFridayGetCPUStats(t *testing.T) { 84 | prof, err := cpustats.NewProfiler() 85 | if err != nil { 86 | t.Error(err) 87 | return 88 | } 89 | st, err := prof.Get() 90 | if err != nil { 91 | t.Error(err) 92 | return 93 | } 94 | p, err := json.MarshalIndent(st, "", "\t") 95 | if err != nil { 96 | t.Error(err) 97 | return 98 | } 99 | t.Logf("%s\n", string(p)) 100 | } 101 | 102 | func TestDataDogGohaiCPU(t *testing.T) { 103 | type Collector interface { 104 | Name() string 105 | Collect() (interface{}, error) 106 | } 107 | var collector = &cpu.Cpu{} 108 | c, err := collector.Collect() 109 | if err != nil { 110 | t.Error(err) 111 | return 112 | } 113 | p, err := json.MarshalIndent(c, "", "\t") 114 | if err != nil { 115 | t.Error(err) 116 | return 117 | } 118 | t.Logf("%s\n", string(p)) 119 | } 120 | 121 | func TestShirouGopsutilInfoStat(t *testing.T) { 122 | st, err := gopsutilcpu.Info() 123 | if err != nil { 124 | t.Error(err) 125 | return 126 | } 127 | p, err := json.MarshalIndent(st, "", "\t") 128 | if err != nil { 129 | t.Error(err) 130 | return 131 | } 132 | t.Logf("%s\n", string(p)) 133 | } 134 | 135 | func TestShirouGopsutilTimeStat(t *testing.T) { 136 | st, err := gopsutilcpu.Times(true) 137 | if err != nil { 138 | t.Error(err) 139 | return 140 | } 141 | p, err := json.MarshalIndent(st, "", "\t") 142 | if err != nil { 143 | t.Error(err) 144 | return 145 | } 146 | t.Logf("%s\n", string(p)) 147 | } 148 | -------------------------------------------------------------------------------- /system/version/flat/structs/Kernel.go: -------------------------------------------------------------------------------- 1 | // automatically generated by the FlatBuffers compiler, do not modify 2 | 3 | package structs 4 | 5 | import ( 6 | flatbuffers "github.com/google/flatbuffers/go" 7 | ) 8 | type Kernel struct { 9 | _tab flatbuffers.Table 10 | } 11 | 12 | func GetRootAsKernel(buf []byte, offset flatbuffers.UOffsetT) *Kernel { 13 | n := flatbuffers.GetUOffsetT(buf[offset:]) 14 | x := &Kernel{} 15 | x.Init(buf, n + offset) 16 | return x 17 | } 18 | 19 | func (rcv *Kernel) Init(buf []byte, i flatbuffers.UOffsetT) { 20 | rcv._tab.Bytes = buf 21 | rcv._tab.Pos = i 22 | } 23 | 24 | func (rcv *Kernel) OS() []byte { 25 | o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) 26 | if o != 0 { 27 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 28 | } 29 | return nil 30 | } 31 | 32 | func (rcv *Kernel) Version() []byte { 33 | o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) 34 | if o != 0 { 35 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 36 | } 37 | return nil 38 | } 39 | 40 | func (rcv *Kernel) CompileUser() []byte { 41 | o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) 42 | if o != 0 { 43 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 44 | } 45 | return nil 46 | } 47 | 48 | func (rcv *Kernel) GCC() []byte { 49 | o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) 50 | if o != 0 { 51 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 52 | } 53 | return nil 54 | } 55 | 56 | func (rcv *Kernel) OSGCC() []byte { 57 | o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) 58 | if o != 0 { 59 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 60 | } 61 | return nil 62 | } 63 | 64 | func (rcv *Kernel) Type() []byte { 65 | o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) 66 | if o != 0 { 67 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 68 | } 69 | return nil 70 | } 71 | 72 | func (rcv *Kernel) CompileDate() []byte { 73 | o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) 74 | if o != 0 { 75 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 76 | } 77 | return nil 78 | } 79 | 80 | func (rcv *Kernel) Arch() []byte { 81 | o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) 82 | if o != 0 { 83 | return rcv._tab.ByteVector(o + rcv._tab.Pos) 84 | } 85 | return nil 86 | } 87 | 88 | func KernelStart(builder *flatbuffers.Builder) { builder.StartObject(8) } 89 | func KernelAddOS(builder *flatbuffers.Builder, OS flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(OS), 0) } 90 | func KernelAddVersion(builder *flatbuffers.Builder, Version flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(Version), 0) } 91 | func KernelAddCompileUser(builder *flatbuffers.Builder, CompileUser flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(CompileUser), 0) } 92 | func KernelAddGCC(builder *flatbuffers.Builder, GCC flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(GCC), 0) } 93 | func KernelAddOSGCC(builder *flatbuffers.Builder, OSGCC flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(OSGCC), 0) } 94 | func KernelAddType(builder *flatbuffers.Builder, Type flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(Type), 0) } 95 | func KernelAddCompileDate(builder *flatbuffers.Builder, CompileDate flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(CompileDate), 0) } 96 | func KernelAddArch(builder *flatbuffers.Builder, Arch flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(Arch), 0) } 97 | func KernelEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } 98 | -------------------------------------------------------------------------------- /system/os/json/os_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package os provides OS Release information, /etc/os-release. Instead of 15 | // returning a Go struct, it returns JSON serialized bytes. A function to 16 | // deserialize the JSON serialized bytes into am os.OS struct is provided. 17 | // 18 | // Note: the package name is os and not the final element of the import 19 | // path (json). 20 | package os 21 | 22 | import ( 23 | "encoding/json" 24 | "sync" 25 | 26 | o "github.com/mohae/joefriday/system/os" 27 | ) 28 | 29 | // Profiler processes the OS release information, /etc/os-release, 30 | // using JSON. 31 | type Profiler struct { 32 | *o.Profiler 33 | } 34 | 35 | // Returns an initialized Profiler; ready to use. 36 | func NewProfiler() (prof *Profiler, err error) { 37 | p, err := o.NewProfiler() 38 | if err != nil { 39 | return nil, err 40 | } 41 | return &Profiler{Profiler: p}, nil 42 | } 43 | 44 | // Get gets the OS release information, /etc/os-release, as JSON serialized 45 | // bytes. 46 | func (prof *Profiler) Get() (p []byte, err error) { 47 | k, err := prof.Profiler.Get() 48 | if err != nil { 49 | return nil, err 50 | } 51 | return prof.Serialize(k) 52 | } 53 | 54 | var std *Profiler 55 | var stdMu sync.Mutex //protects standard to prevent a data race on checking/instantiation 56 | 57 | // Get gets the OS release information, /etc/os-release, as JSON serialized 58 | // bytes using the package's global Profiler. 59 | func Get() (p []byte, err error) { 60 | stdMu.Lock() 61 | defer stdMu.Unlock() 62 | if std == nil { 63 | std, err = NewProfiler() 64 | if err != nil { 65 | return nil, err 66 | } 67 | } 68 | return std.Get() 69 | } 70 | 71 | // Serialize os.OS as JSON 72 | func (prof *Profiler) Serialize(os *o.OS) ([]byte, error) { 73 | return json.Marshal(os) 74 | } 75 | 76 | // Serialize os.OS as JSON using the package's global Profiler. 77 | func Serialize(os *o.OS) (p []byte, err error) { 78 | stdMu.Lock() 79 | defer stdMu.Unlock() 80 | if std == nil { 81 | std, err = NewProfiler() 82 | if err != nil { 83 | return nil, err 84 | } 85 | } 86 | return std.Serialize(os) 87 | } 88 | 89 | // Marshal is an alias for Serialize. 90 | func (prof *Profiler) Marshal(os *o.OS) ([]byte, error) { 91 | return prof.Serialize(os) 92 | } 93 | 94 | // Marshal is an alias for Serialize using the package's global profiler. 95 | func Marshal(os *o.OS) ([]byte, error) { 96 | return Serialize(os) 97 | } 98 | 99 | // Deserialize takes some JSON serialized bytes and unmarshals them as os.OS. 100 | func Deserialize(p []byte) (*o.OS, error) { 101 | os := &o.OS{} 102 | err := json.Unmarshal(p, os) 103 | if err != nil { 104 | return nil, err 105 | } 106 | return os, nil 107 | } 108 | 109 | // Unmarshal is an alias for Deserialize. 110 | func Unmarshal(p []byte) (*o.OS, error) { 111 | return Deserialize(p) 112 | } 113 | -------------------------------------------------------------------------------- /node/json/node_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Joel Scoble and The JoeFriday authors. 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package node gets information about the system's NUMA nodes. This looks 15 | // at the sysfs's node tree and extracts information about each node. If the 16 | // node tree doesn't exist on the system, instead of node information, an 17 | // os.ErrNotExist will be returned. Instead of returning a Go struct, JSON 18 | // serialized bytes are returned. A function to deserialize the JSON serialized 19 | // bytes into a node.Nodes struct is provided. 20 | // 21 | // Note: the package name is node and not the final element of the import path 22 | // (json). 23 | package node 24 | 25 | import ( 26 | "encoding/json" 27 | "sync" 28 | 29 | numa "github.com/mohae/joefriday/node" 30 | ) 31 | 32 | // Profiler is used to process the node information. 33 | type Profiler struct { 34 | *numa.Profiler 35 | } 36 | 37 | // Initializes and returns a cpuinfo profiler. 38 | func NewProfiler() (prof *Profiler) { 39 | p := numa.NewProfiler() 40 | return &Profiler{Profiler: p} 41 | } 42 | 43 | // Get returns the current cpuinfo as JSON serialized bytes. 44 | func (prof *Profiler) Get() (p []byte, err error) { 45 | inf, err := prof.Profiler.Get() 46 | if err != nil { 47 | return nil, err 48 | } 49 | return prof.Serialize(inf) 50 | } 51 | 52 | var std *Profiler 53 | var stdMu sync.Mutex //protects standard to prevent data race on checking/instantiation 54 | 55 | // Get returns the current node as JSON serialized bytes using the package's 56 | // global Profiler. 57 | func Get() (p []byte, err error) { 58 | stdMu.Lock() 59 | defer stdMu.Unlock() 60 | if std == nil { 61 | std = NewProfiler() 62 | } 63 | return std.Get() 64 | } 65 | 66 | // Serialize node.Nodes as JSON. 67 | func (prof *Profiler) Serialize(nodes *numa.Nodes) ([]byte, error) { 68 | return json.Marshal(nodes) 69 | } 70 | 71 | // Serialize node.Nodes as JSON using package globals. 72 | func Serialize(nodes *numa.Nodes) (p []byte, err error) { 73 | stdMu.Lock() 74 | defer stdMu.Unlock() 75 | if std == nil { 76 | std = NewProfiler() 77 | } 78 | return std.Serialize(nodes) 79 | } 80 | 81 | // Marshal is an alias for serialize. 82 | func (prof *Profiler) Marshal(nodes *numa.Nodes) ([]byte, error) { 83 | return prof.Serialize(nodes) 84 | } 85 | 86 | // Marshal is an alias for Serialize using package globals. 87 | func Marshal(nodes *numa.Nodes) ([]byte, error) { 88 | return std.Serialize(nodes) 89 | } 90 | 91 | // Deserialize takes some JSON serialized bytes and unmarshals them as 92 | // node.Nodes. 93 | func Deserialize(p []byte) (*numa.Nodes, error) { 94 | nodes := &numa.Nodes{} 95 | err := json.Unmarshal(p, nodes) 96 | if err != nil { 97 | return nil, err 98 | } 99 | return nodes, nil 100 | } 101 | 102 | // Unmarshal is an alias for Deserialize using package globals. 103 | func Unmarshal(p []byte) (*numa.Nodes, error) { 104 | return Deserialize(p) 105 | } 106 | --------------------------------------------------------------------------------