// Get CPU information.
func Get() (CPU, error) {
c := CPU{}
m, err := parse.ExecRegexpMap("/usr/sbin/sysctl", []string{"-a"}, ":", "\\S+:\\s\\S+")
if err != nil {
return CPU{}, err
}
c.CoresPerSocket, err = parse.StrToInt(m, "machdep.cpu.core_count")
if err != nil {
return CPU{}, err
}
c.Physical, err = parse.StrToInt(m, "hw.physicalcpu_max")
if err != nil {
return CPU{}, err
}
c.Logical, err = parse.StrToInt(m, "hw.logicalcpu_max")
if err != nil {
return CPU{}, err
}
c.Sockets = c.Physical / c.CoresPerSocket
c.ThreadsPerCore = c.Logical / c.Sockets / c.CoresPerSocket
c.Model = m["machdep.cpu.brand_string"]
c.Flags = strings.ToLower(m["machdep.cpu.features"])
return c, nil
}
func Get() (System, error) {
s := System{}
m, err := parse.ExecRegexpMap("/usr/sbin/system_profiler", []string{"SPHardwareDataType"}, ":", "\\S+:\\s\\S+")
if err != nil {
return System{}, err
}
host, err := os.Hostname()
if err != nil {
return System{}, err
}
s.Hostname = host
s.ShortHostname = strings.Split(host, ".")[0]
s.PeekabooVersion = version.Version
s.Manufacturer = "Apple Inc."
s.Product = m["Model Name"]
s.ProductVersion = m["Model Identifier"]
s.SerialNumber = m["Serial Number (system)"]
s.BootROMVersion = m["Boot ROM Version"]
s.SMCVersion = m["SMC Version (system)"]
return s, nil
}
func Get() (Memory, error) {
mem := Memory{}
m, err := parse.ExecRegexpMap("/usr/sbin/sysctl", []string{"-a"}, ":", "\\S+:\\s\\S+")
if err != nil {
return Memory{}, err
}
mem.TotalKB, err = parse.StrToInt(m, "hw.memsize")
if err != nil {
return Memory{}, err
}
mem.TotalKB = mem.TotalKB / 1024
mem.TotalGB = mem.TotalKB / 1024 / 1024
return mem, nil
}
func Get() (OpSys, error) {
o := OpSys{}
m, err := parse.ExecRegexpMap("/usr/bin/sw_vers", []string{}, ":", "\\S+:\\s\\S+")
if err != nil {
return OpSys{}, err
}
o.Kernel = runtime.GOOS
o.Product = m["ProductName"]
o.ProductVersion = m["ProductVersion"]
o.KernelVersion, err = parse.Exec("uname", []string{"-r"})
if err != nil {
return OpSys{}, err
}
return o, nil
}
func Get() (OpSys, error) {
op := OpSys{}
o, err := parse.ExecRegexpMap("lsb_release", []string{"-a"}, ":", "\\S+:\\s\\S+")
if err != nil {
return OpSys{}, err
}
op.Kernel = runtime.GOOS
op.Product = o["Distributor ID"]
op.ProductVersion = o["Release"]
op.KernelVersion, err = parse.Exec("uname", []string{"-r"})
if err != nil {
return OpSys{}, err
}
return op, nil
}
// Get network interfaces.
func Get() (Interfaces, error) {
hasEthtool := false
if err := parse.Exists("ethtool"); err == nil {
hasEthtool = true
}
hasLldpctl := false
if err := parse.Exists("lldpctl"); err == nil {
hasLldpctl = true
}
hasSfctool := false
if err := parse.Exists("sfctool"); err == nil {
hasSfctool = true
}
rIntfs, err := net.Interfaces()
if err != nil {
return Interfaces{}, err
}
i := Interfaces{}
for _, rIntf := range rIntfs {
// Skip loopback interfaces
if rIntf.Flags&net.FlagLoopback != 0 {
continue
}
addrs, err := rIntf.Addrs()
if err != nil {
return Interfaces{}, err
}
wIntf := Interface{
Name: rIntf.Name,
HWAddr: rIntf.HardwareAddr.String(),
MTU: rIntf.MTU,
}
for _, addr := range addrs {
wIntf.IPAddr = append(wIntf.IPAddr, addr.String())
}
if rIntf.Flags&net.FlagUp != 0 {
wIntf.Flags = append(wIntf.Flags, "UP")
}
if rIntf.Flags&net.FlagBroadcast != 0 {
wIntf.Flags = append(wIntf.Flags, "BROADCAST")
}
if rIntf.Flags&net.FlagPointToPoint != 0 {
wIntf.Flags = append(wIntf.Flags, "POINTTOPOINT")
}
if rIntf.Flags&net.FlagMulticast != 0 {
wIntf.Flags = append(wIntf.Flags, "MULTICAST")
}
if runtime.GOOS == "linux" && hasEthtool == true {
m, err := parse.ExecRegexpMap("ethtool", []string{"-i", rIntf.Name}, ":", "\\S+:\\s\\S+")
// Do nothing on error
if err == nil {
s1 := m["driver"]
wIntf.Driver = &s1
s2 := m["version"]
wIntf.DriverVersion = &s2
s3 := m["firmware-version"]
wIntf.FirmwareVersion = &s3
if strings.HasPrefix(m["bus-info"], "0000:") {
s4 := m["bus-info"]
wIntf.PCIBus = &s4
s5 := fmt.Sprintf("/pci/%v", m["bus-info"])
wIntf.PCIBusURL = &s5
}
}
}
if runtime.GOOS == "linux" && hasEthtool == true {
m, err := parse.ExecRegexpMap("ethtool", []string{rIntf.Name}, ":", "\\S+:\\s\\S+")
// Do nothing on error
if err == nil {
i, err := strconv.Atoi(strings.TrimRight(m["Speed"], "Mb/s"))
if err == nil {
wIntf.SpeedMbs = &i
}
if wIntf.SpeedMbs != nil {
s := m["Duplex"]
wIntf.Duplex = &s
}
switch m["Link detected"] {
case "yes":
b := true
wIntf.LinkDetected = &b
case "no":
b := false
wIntf.LinkDetected = &b
}
}
}
if runtime.GOOS == "linux" && hasEthtool == true {
m, err := parse.ExecRegexpMap("ethtool", []string{"-P", rIntf.Name}, ":[ ]", "\\S+:\\s([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})")
// Do nothing on error
if err == nil {
bia := m["Permanent address"]
wIntf.PermanentHWAddr = &bia
}
}
if runtime.GOOS == "linux" && hasEthtool && wIntf.Driver != nil && *wIntf.Driver != "sfc" {
o, err := parse.Exec("ethtool", []string{"-m", rIntf.Name, "raw", "on"})
// Do nothing on error, doesn't support getting Eeprom info
if err == nil {
s := hex.EncodeToString([]byte(o))
var b []byte
var eeprom string = ""
switch s[:2] {
case "03": // SFP+
eeprom = s[0:]
case "0d": // QSFP+
eeprom = s[256:768]
}
length := len(eeprom)
if length >= 512 {
ep := eeprom
wIntf.TransceiverEeprom = &ep
// Serial Number
b, err = hex.DecodeString(eeprom[136:168])
if err == nil {
sn := strings.Trim(string(b), " ")
wIntf.TransceiverSN = &sn
}
// Vendor Name
b, err = hex.DecodeString(eeprom[40:72])
if err == nil {
vn := strings.Trim(string(b), " ")
wIntf.TransceiverVN = &vn
}
// Product Name
b, err = hex.DecodeString(eeprom[80:112])
if err == nil {
pn := strings.Trim(string(b), " ")
wIntf.TransceiverPN = &pn
}
// Arista specific QSFP-4xSFP sub-assembly
if *wIntf.TransceiverVN == "Arista Networks" && strings.HasPrefix(*wIntf.TransceiverPN, "CAB-Q-S-") {
b, err = hex.DecodeString(eeprom[240:242])
if err == nil {
sa := int(b[0])
wIntf.TransceiverSA = &sa
}
}
}
}
}
if runtime.GOOS == "linux" && hasSfctool && wIntf.Driver != nil && *wIntf.Driver == "sfc" {
o, err := parse.Exec("sfctool", []string{"-m", rIntf.Name, "raw", "on"})
// Do nothing on error, doesn't support getting Eeprom info
if err == nil {
s := hex.EncodeToString([]byte(o))
var b []byte
var eeprom string = ""
switch s[:2] {
case "03": // SFP+
eeprom = s[0:512]
case "0d": // QSFP+
eeprom = s[256:768]
}
length := len(eeprom)
if length == 512 {
ep := eeprom
wIntf.TransceiverEeprom = &ep
// Serial Number
b, err = hex.DecodeString(eeprom[136:168])
if err == nil {
sn := strings.Trim(string(b), " ")
wIntf.TransceiverSN = &sn
}
// Vendor Name
b, err = hex.DecodeString(eeprom[40:72])
if err == nil {
vn := strings.Trim(string(b), " ")
wIntf.TransceiverVN = &vn
}
// Product Name
b, err = hex.DecodeString(eeprom[80:112])
if err == nil {
pn := strings.Trim(string(b), " ")
wIntf.TransceiverPN = &pn
}
// Arista specific QSFP-4xSFP sub-assembly
if *wIntf.TransceiverVN == "Arista Networks" && strings.HasPrefix(*wIntf.TransceiverPN, "CAB-Q-S-") {
b, err = hex.DecodeString(eeprom[240:242])
if err == nil {
sa := int(b[0])
wIntf.TransceiverSA = &sa
}
}
}
}
}
if runtime.GOOS == "linux" && hasLldpctl == true {
o, err := parse.Exec("lldpctl", []string{rIntf.Name})
// Do nothing on error
if err == nil {
for _, line := range strings.Split(o, "\n") {
arr := strings.SplitN(line, ":", 2)
if len(arr) < 2 {
continue
}
key := strings.TrimSpace(arr[0])
val := strings.TrimSpace(arr[1])
switch key {
case "ChassisID":
wIntf.SwChassisID = &val
case "SysName":
wIntf.SwName = &val
case "SysDescr":
wIntf.SwDescr = &val
case "PortID":
wIntf.SwPortID = &val
case "PortDescr":
wIntf.SwPortDescr = &val
case "VLAN":
wIntf.SwVLAN = &val
}
}
}
}
i = append(i, wIntf)
}
return i, nil
}