From 3fdfaf8370af4713dc01ff34a9ed2d4557459141 Mon Sep 17 00:00:00 2001 From: "liqiankun.1111" Date: Tue, 29 Sep 2026 14:58:13 +0800 Subject: [PATCH] feat: add runnable macOS system information binaries make build now produces versioned Linux and macOS binaries for AMD64 and ARM64. macOS collects OS/kernel, CPU, memory, page size, resource limits and network facts through native APIs, without subprocesses or third-party dependencies. Platform-specific collectors preserve Linux behavior and identify Rosetta translation explicitly. Validation: full make lint and make test passed through devloop; make build produced all four binaries; macOS ARM64 ran natively and AMD64 ran under Rosetta with valid JSON and no collection errors. Native Intel macOS and Linux execution are covered by the CI matrix but were not run locally in this change. --- .github/workflows/go.yml | 19 ++++-- AGENTS.md | 7 ++- Makefile | 12 +++- README.md | 27 ++++++-- cmd/sysinfo/main.go | 6 +- kernel_darwin.go | 12 ++++ platform_darwin.go | 130 +++++++++++++++++++++++++++++++++++++++ platform_darwin_test.go | 65 ++++++++++++++++++++ platform_linux.go | 24 ++++++++ runtime.go | 41 +----------- runtime_linux.go | 44 +++++++++++++ sysinfo.go | 23 +------ 12 files changed, 329 insertions(+), 81 deletions(-) create mode 100644 platform_darwin.go create mode 100644 platform_darwin_test.go create mode 100644 platform_linux.go create mode 100644 runtime_linux.go diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index a77d6a3..07e15c9 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -9,7 +9,7 @@ jobs: check: strategy: matrix: - os: [ubuntu-latest, ubuntu-24.04-arm] + os: [ubuntu-latest, ubuntu-24.04-arm, macos-15, macos-15-intel] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v4 @@ -20,15 +20,22 @@ jobs: - run: make lint test build - name: Run without root and verify JSON run: | - case "$(uname -m)" in aarch64) arch=arm64 ;; x86_64) arch=amd64 ;; esac + case "$(uname -m)" in aarch64|arm64) arch=arm64 ;; x86_64) arch=amd64 ;; esac + case "$(uname -s)" in Linux) platform=linux ;; Darwin) platform=darwin ;; esac version=$(sed -n 's/^const Version = "\([^"]*\)"/\1/p' version.go) - ./dist/sysinfo-$version-linux-$arch > /tmp/sysinfo.json + ./dist/sysinfo-$version-$platform-$arch > /tmp/sysinfo.json python3 - <<'PYTHON' - import json, os + import json, os, sys with open('/tmp/sysinfo.json') as f: report = json.load(f) assert report['runtime']['page_size_bytes'] == os.sysconf('SC_PAGE_SIZE') assert report['runtime']['resource_limits'] - assert report['runtime']['libc'] - assert report['runtime']['vm']['overcommit_memory'] in ['0', '1', '2'] + if sys.platform == 'linux': + assert report['runtime']['libc'] + assert report['runtime']['vm']['overcommit_memory'] in ['0', '1', '2'] + else: + assert report['os']['name'] == 'macOS' + assert report['os']['version'] + assert report['kernel']['release'] + assert report['memory']['size'] > 0 PYTHON diff --git a/AGENTS.md b/AGENTS.md index 866b4a2..03be766 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -2,14 +2,15 @@ ## 项目定位与边界 -Linux 系统信息 CLI，基于 zcalusic/sysinfo 增强。直接执行输出 JSON，辅助判断二进制构建与运行环境的兼容性；不自动作兼容性结论。 +Linux / macOS 系统信息 CLI，基于 zcalusic/sysinfo 增强。直接执行输出 JSON，辅助判断二进制构建与运行环境的兼容性；不自动作兼容性结论。 ## 代码地图 ```text cmd/sysinfo/ # CLI 入口，输出一次 JSON *.go # 沿用上游系统信息采集结构 -runtime.go # 基础页大小、资源限制、内存与内核策略 +runtime*.go # 基础页大小与平台运行环境 +platform_*.go # Linux / macOS 采集入口 libc.go # 静态读取已安装 libc 的版本证据 cpuid/ # 上游 CPU 指令封装 ``` @@ -17,7 +18,7 @@ cpuid/ # 上游 CPU 指令封装 ## 关键约定 - 采集只读，不创建或修复系统文件，不执行外部程序。 -- 标准库实现；发布使用 CGO_ENABLED=0，不依赖客户机的 libc 或语言运行时。 +- 标准库实现；发布使用 CGO_ENABLED=0，Linux 静态链接，macOS 仅使用系统自带库，不依赖额外语言运行时。 - 缺失证据不转换为正常默认值；新增运行环境采集错误保存在 runtime.errors。 - 保留上游版权及许可证。版本由 version.go 管理。 - 验证入口：make fix、make lint、make test、make build；build 一次产出全部支持架构，跨编译不等于客户机运行验证。 diff --git a/Makefile b/Makefile index df4f35c..a50cd36 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ TEST_WORKERS ?= 4 LINT_WORKERS ?= 4 .DEFAULT_GOAL := build -.PHONY: fix lint test build build-all build-linux-amd64 build-linux-arm64 +.PHONY: fix lint test build build-all build-linux-amd64 build-linux-arm64 build-darwin-amd64 build-darwin-arm64 fix: $(GO) fmt ./... @@ -16,13 +16,15 @@ lint: $(GO) vet -p $(LINT_WORKERS) ./... CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GO) vet -p $(LINT_WORKERS) ./... CGO_ENABLED=0 GOOS=linux GOARCH=arm64 $(GO) vet -p $(LINT_WORKERS) ./... + CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 $(GO) vet -p $(LINT_WORKERS) ./... + CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 $(GO) vet -p $(LINT_WORKERS) ./... test: $(GO) test -p $(TEST_WORKERS) -parallel 1 $(TEST_PACKAGES) # One static binary per architecture serves supported Linux distributions and # kernels. Do not create kernel/glibc-labelled copies of the same executable. -build: build-linux-amd64 build-linux-arm64 +build: build-linux-amd64 build-linux-arm64 build-darwin-amd64 build-darwin-arm64 build-all: build @@ -31,3 +33,9 @@ build-linux-amd64: build-linux-arm64: CGO_ENABLED=0 GOOS=linux GOARCH=arm64 GOARM64=v8.0 $(GO) build -trimpath -ldflags='-s -w' -o "$(DIST_DIR)/$(ARTIFACT_PREFIX)-linux-arm64" ./cmd/sysinfo + +build-darwin-amd64: + CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 GOAMD64=v1 $(GO) build -trimpath -ldflags='-s -w' -o "$(DIST_DIR)/$(ARTIFACT_PREFIX)-darwin-amd64" ./cmd/sysinfo + +build-darwin-arm64: + CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 GOARM64=v8.0 $(GO) build -trimpath -ldflags='-s -w' -o "$(DIST_DIR)/$(ARTIFACT_PREFIX)-darwin-arm64" ./cmd/sysinfo diff --git a/README.md b/README.md index f2667b7..6739ba2 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # sysinfo -sysinfo is a standalone, read-only Linux CLI for collecting the system facts needed +sysinfo is a standalone, read-only Linux and macOS CLI for collecting the system facts needed to build, distribute and troubleshoot native applications. It gathers OS, kernel, CPU, memory, libc and process-limit information into a single JSON report, so users can compare environments, choose suitable build targets and investigate startup failures. @@ -14,16 +14,21 @@ Run it without arguments to print the report; redirect stdout to save it. ```sh ./sysinfo-1.1.4-linux-arm64 > sysinfo.json -# On x86-64: +# On Linux x86-64: ./sysinfo-1.1.4-linux-amd64 > sysinfo.json +# On Apple Silicon macOS: +./sysinfo-1.1.4-darwin-arm64 > sysinfo.json ``` -The binary needs no Bun, Node, Python, shell utilities, or installed libc. +The binary needs no Bun, Node, Python or shell utilities. Linux builds are static; +macOS builds use only system libraries shipped with macOS. It does not execute subprocesses or modify system files. Root is optional; firmware/serial information may be unavailable without permission. ## Information collected +On Linux: + - OS distribution, kernel and userland architecture, CPU and common feature flags. - Hardware inventory inherited from upstream: firmware, memory, storage and network. - Actual base page size in bytes (including 64 KiB ARM64 systems), independently of huge pages. @@ -31,6 +36,14 @@ firmware/serial information may be unavailable without permission. - This process's soft/hard resource limits, including virtual address space and core dumps. - `/proc/meminfo`, overcommit policy/ratio/size, mapping limits and cgroup membership. +On macOS, native system APIs collect the OS version/build, Darwin kernel, host and +process architectures, CPU model/core counts, physical memory, base page size, +resource limits and network interfaces. Linux-specific libc, overcommit and cgroup +fields remain empty, with platform notes in the report. Firmware/storage inventory +and ARM CPU feature flags are not collected on macOS. +Under Rosetta, the report identifies translation and separates the ARM64 host +from the AMD64 process. Page size and resource limits describe the running process. + Reports describe the environment visible to the collector. Run it from the same shell/container/service context as the failing program when investigating limits. Memory data comes from procfs; cgroup membership is included as context, but cgroup @@ -58,21 +71,23 @@ make test make build # dist/sysinfo-1.1.4-linux-amd64 # dist/sysinfo-1.1.4-linux-arm64 +# dist/sysinfo-1.1.4-darwin-amd64 +# dist/sysinfo-1.1.4-darwin-arm64 # Optional: build a single architecture, or choose an output directory. make build-linux-arm64 make build DIST_DIR=/tmp/sysinfo-dist ``` -`make` and `make build-all` also build both architectures. Artifact versions come +`make` and `make build-all` also build all four platform binaries. Artifact versions come from `version.go`, matching the version in the JSON report. AMD64 uses the v1 CPU baseline; ARM64 uses ARMv8.0. Both Linux builds use `CGO_ENABLED=0`, so there are no separate Debian/Kylin, glibc or kernel-labelled binaries. Go's documented Linux kernel requirements are listed in [Minimum Requirements](https://go.dev/wiki/MinimumRequirements); the collector also needs access to procfs/sysfs for the corresponding fields. -macOS can cross-compile and run parser tests; -the CLI itself supports Linux only. Kernel/distribution and page-size combinations +All four builds use `CGO_ENABLED=0`. macOS binaries use native sysctl and resource-limit +APIs without invoking external commands. Kernel/distribution and page-size combinations still require runtime validation on those systems. ## Origin and license diff --git a/cmd/sysinfo/main.go b/cmd/sysinfo/main.go index 7485ea0..26c1196 100644 --- a/cmd/sysinfo/main.go +++ b/cmd/sysinfo/main.go @@ -12,19 +12,15 @@ import ( "fmt" "log" "os" - "runtime" "github.com/compforge/sysinfo" ) func main() { if len(os.Args) != 1 { - fmt.Fprintln(os.Stderr, "usage: sysinfo (prints Linux system information as JSON)") + fmt.Fprintln(os.Stderr, "usage: sysinfo (prints system information as JSON)") os.Exit(2) } - if runtime.GOOS != "linux" { - log.Fatal("sysinfo supports Linux only") - } var si sysinfo.SysInfo diff --git a/kernel_darwin.go b/kernel_darwin.go index 73e0c98..bd297a5 100644 --- a/kernel_darwin.go +++ b/kernel_darwin.go @@ -3,6 +3,8 @@ package sysinfo +import "syscall" + // Kernel information. type Kernel struct { Release string `json:"release,omitempty"` @@ -11,4 +13,14 @@ type Kernel struct { } func (si *SysInfo) getKernelInfo() { + si.Kernel.Release = si.sysctlString("kern.osrelease") + si.Kernel.Version = si.sysctlString("kern.version") + si.Kernel.Architecture = si.sysctlString("hw.machine") + // Under Rosetta hw.machine may describe the translated process. ARM64 + // support or the translation flag identifies the native host; + // runtime.process_architecture still describes the running executable. + arm64, _ := syscall.SysctlUint32("hw.optional.arm64") + if arm64 == 1 || si.Runtime.Translation == "rosetta2" { + si.Kernel.Architecture = "arm64" + } } diff --git a/platform_darwin.go b/platform_darwin.go new file mode 100644 index 0000000..88748e6 --- /dev/null +++ b/platform_darwin.go @@ -0,0 +1,130 @@ +package sysinfo + +import ( + "encoding/binary" + "fmt" + "net" + "os" + "strconv" + "strings" + "syscall" + "time" +) + +func (si *SysInfo) sysctlString(name string) string { + value, err := syscall.Sysctl(name) + if err != nil { + si.Runtime.Errors[name] = err.Error() + } + return strings.TrimSpace(value) +} + +func (si *SysInfo) sysctlUint32(name string) uint32 { + value, err := syscall.SysctlUint32(name) + if err != nil { + si.Runtime.Errors[name] = err.Error() + } + return value +} + +func (si *SysInfo) getPlatformInfo() { + si.getKernelInfo() + si.OS = OS{Name: "macOS", Vendor: "Apple", Version: si.sysctlString("kern.osproductversion"), + Release: si.sysctlString("kern.osversion"), Architecture: si.Kernel.Architecture} + var err error + si.Node.Hostname, err = os.Hostname() + if err != nil { + si.Runtime.Errors["hostname"] = err.Error() + } + si.Node.Timezone, _ = time.Now().Zone() + si.Product.Vendor = "Apple" + si.Product.Name = si.sysctlString("hw.model") + si.CPU.Model = si.sysctlString("machdep.cpu.brand_string") + si.CPU.Cpus = uint(si.sysctlUint32("hw.packages")) + si.CPU.Cores = uint(si.sysctlUint32("hw.physicalcpu")) + si.CPU.Threads = uint(si.sysctlUint32("hw.logicalcpu")) + // x86 feature strings are optional on Apple Silicon. Do not translate + // unrelated ARM capability keys into x86 instruction-set claims. + if value, err := syscall.Sysctl("machdep.cpu.vendor"); err == nil { + si.CPU.Vendor = value + } + for _, name := range []string{"machdep.cpu.features", "machdep.cpu.leaf7_features", "machdep.cpu.extfeatures"} { + if value, err := syscall.Sysctl(name); err == nil { + si.CPU.Features = append(si.CPU.Features, strings.Fields(strings.ToLower(value))...) + } + } + if value, err := sysctlUint64("hw.memsize"); err == nil { + si.Memory.Size = uint(value / (1024 * 1024)) + si.Runtime.Memory["physical_bytes"] = strconv.FormatUint(value, 10) + } else { + si.Runtime.Errors["hw.memsize"] = err.Error() + } + interfaces, err := net.Interfaces() + if err != nil { + si.Runtime.Errors["network_interfaces"] = err.Error() + return + } + for _, iface := range interfaces { + if iface.Flags&net.FlagLoopback != 0 { + continue + } + si.Network = append(si.Network, NetworkDevice{Name: iface.Name, MACAddress: iface.HardwareAddr.String()}) + } +} + +func sysctlUint64(name string) (uint64, error) { + value, err := syscall.Sysctl(name) + if err != nil { + return 0, err + } + return decodeSysctlUint64(value) +} + +func decodeSysctlUint64(value string) (uint64, error) { + // syscall.Sysctl removes one trailing NUL even for binary data. Restore + // that byte for uint64 values. Both supported Darwin architectures are LE. + if len(value) != 7 && len(value) != 8 { + return 0, fmt.Errorf("expected 8-byte sysctl value, got %d bytes", len(value)) + } + var data [8]byte + copy(data[:], value) + return binary.LittleEndian.Uint64(data[:]), nil +} + +func (si *SysInfo) getPlatformRuntime() { + if translated, err := syscall.SysctlUint32("sysctl.proc_translated"); err == nil && translated == 1 { + si.Runtime.Translation = "rosetta2" + } + si.Runtime.Notes = []string{ + "macOS uses the system libSystem runtime; Linux libc, overcommit and cgroup fields do not apply.", + "macOS firmware, storage inventory and ARM CPU feature flags are not collected.", + } + for _, limit := range []struct { + name string + resource int + unit string + }{ + {"Max cpu time", syscall.RLIMIT_CPU, "seconds"}, + {"Max file size", syscall.RLIMIT_FSIZE, "bytes"}, + {"Max data size", syscall.RLIMIT_DATA, "bytes"}, + {"Max stack size", syscall.RLIMIT_STACK, "bytes"}, + {"Max core file size", syscall.RLIMIT_CORE, "bytes"}, + {"Max address space", syscall.RLIMIT_AS, "bytes"}, + {"Max open files", syscall.RLIMIT_NOFILE, "files"}, + } { + var value syscall.Rlimit + if err := syscall.Getrlimit(limit.resource, &value); err != nil { + si.Runtime.Errors[limit.name] = err.Error() + continue + } + si.Runtime.Limits = append(si.Runtime.Limits, ResourceLimit{Name: limit.name, + Soft: darwinLimit(value.Cur), Hard: darwinLimit(value.Max), Unit: limit.unit}) + } +} + +func darwinLimit(value uint64) string { + if value == uint64(syscall.RLIM_INFINITY) { + return "unlimited" + } + return strconv.FormatUint(value, 10) +} diff --git a/platform_darwin_test.go b/platform_darwin_test.go new file mode 100644 index 0000000..950d83e --- /dev/null +++ b/platform_darwin_test.go @@ -0,0 +1,65 @@ +package sysinfo + +import ( + "encoding/binary" + "os" + "strings" + "syscall" + "testing" +) + +func TestDarwinReport(t *testing.T) { + var si SysInfo + si.GetSysInfo() + if si.OS.Name != "macOS" || si.OS.Version == "" || si.Kernel.Release == "" || si.Kernel.Architecture == "" { + t.Fatalf("missing platform information: %+v %+v", si.OS, si.Kernel) + } + if si.CPU.Cores == 0 || si.CPU.Threads == 0 || si.Memory.Size == 0 || si.Runtime.PageSizeBytes != os.Getpagesize() { + t.Fatalf("missing hardware information: %+v %+v", si.CPU, si.Memory) + } + var limits syscall.Rlimit + if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limits); err != nil { + t.Fatal(err) + } + found := false + for _, limit := range si.Runtime.Limits { + if limit.Name == "Max open files" { + found = true + if limit.Soft != darwinLimit(limits.Cur) || limit.Hard != darwinLimit(limits.Max) { + t.Fatal(limit) + } + } + } + if !found { + t.Fatal("missing open file limit") + } + for key := range si.Runtime.Errors { + if key == "platform" || strings.HasPrefix(key, "/proc/") { + t.Fatalf("Linux collector ran: %s", key) + } + } + if len(si.Runtime.Libc) != 0 || len(si.Runtime.VM) != 0 || len(si.Runtime.Notes) == 0 { + t.Fatal("missing platform boundary") + } + if si.Runtime.Translation == "rosetta2" && (si.Kernel.Architecture != "arm64" || si.Runtime.ProcessArch != "amd64") { + t.Fatalf("incorrect translated architecture: %+v %+v", si.Kernel, si.Runtime) + } +} + +func TestDecodeSysctlUint64(t *testing.T) { + for _, value := range []uint64{0, 64 << 30, 0xffffffffffffffff} { + var data [8]byte + binary.LittleEndian.PutUint64(data[:], value) + raw := strings.TrimSuffix(string(data[:]), "\x00") + got, err := decodeSysctlUint64(raw) + if err != nil || got != value { + t.Fatalf("%d: got %d, %v", value, got, err) + } + } + if _, err := decodeSysctlUint64("bad"); err == nil { + t.Fatal("accepted invalid width") + } + if darwinLimit(uint64(syscall.RLIM_INFINITY)) != "unlimited" || darwinLimit(0) != "0" { + t.Fatal("invalid limit rendering") + } +} diff --git a/platform_linux.go b/platform_linux.go new file mode 100644 index 0000000..a91ffdd --- /dev/null +++ b/platform_linux.go @@ -0,0 +1,24 @@ +package sysinfo + +func (si *SysInfo) getPlatformInfo() { + // DMI info + si.getProductInfo() + si.getBoardInfo() + si.getChassisInfo() + si.getBIOSInfo() + + // SMBIOS info + si.getMemoryInfo() + + // Node info + si.getNodeInfo() // depends on BIOS info + + // Hardware info + si.getCPUInfo() // depends on Node info + si.getStorageInfo() + si.getNetworkInfo() + + // Software info + si.getOSInfo() + si.getKernelInfo() +} diff --git a/runtime.go b/runtime.go index 67a452b..7435292 100644 --- a/runtime.go +++ b/runtime.go @@ -14,12 +14,14 @@ import ( type RuntimeInfo struct { PageSizeBytes int `json:"page_size_bytes"` ProcessArch string `json:"process_architecture"` + Translation string `json:"translation,omitempty"` GoVersion string `json:"go_version"` Libc []Libc `json:"libc"` Limits []ResourceLimit `json:"resource_limits"` Memory map[string]string `json:"memory"` VM map[string]string `json:"vm"` Cgroup string `json:"cgroup_membership,omitempty"` + Notes []string `json:"notes,omitempty"` Errors map[string]string `json:"errors,omitempty"` } @@ -42,44 +44,7 @@ func (si *SysInfo) getRuntimeInfo() { Memory: map[string]string{}, VM: map[string]string{}, Errors: map[string]string{}, } - if runtime.GOOS != "linux" { - r.Errors["platform"] = "Linux is required" - return - } - read := func(path string) string { - data, err := os.ReadFile(path) - if err != nil { - r.Errors[path] = err.Error() - return "" - } - value := strings.TrimSpace(string(data)) - if value == "" { - r.Errors[path] = "file is empty" - } - return value - } - if data := read("/proc/self/limits"); data != "" { - var err error - r.Limits, err = parseLimits(data) - if err != nil { - r.Errors["/proc/self/limits"] = err.Error() - } - } - for _, line := range strings.Split(read("/proc/meminfo"), "\n") { - if key, value, ok := strings.Cut(line, ":"); ok { - r.Memory[key] = strings.TrimSpace(value) - } - } - for _, name := range []string{"overcommit_memory", "overcommit_ratio", "overcommit_kbytes", "max_map_count", "mmap_min_addr"} { - if value := read("/proc/sys/vm/" + name); value != "" { - r.VM[name] = value - } - } - r.Cgroup = read("/proc/self/cgroup") - r.Libc, r.Errors["libc"] = findLibc() - if r.Errors["libc"] == "" { - delete(r.Errors, "libc") - } + si.getPlatformRuntime() } func parseLimits(data string) ([]ResourceLimit, error) { diff --git a/runtime_linux.go b/runtime_linux.go new file mode 100644 index 0000000..fab9d2a --- /dev/null +++ b/runtime_linux.go @@ -0,0 +1,44 @@ +package sysinfo + +import ( + "os" + "strings" +) + +func (si *SysInfo) getPlatformRuntime() { + r := &si.Runtime + read := func(path string) string { + data, err := os.ReadFile(path) + if err != nil { + r.Errors[path] = err.Error() + return "" + } + value := strings.TrimSpace(string(data)) + if value == "" { + r.Errors[path] = "file is empty" + } + return value + } + if data := read("/proc/self/limits"); data != "" { + var err error + r.Limits, err = parseLimits(data) + if err != nil { + r.Errors["/proc/self/limits"] = err.Error() + } + } + for _, line := range strings.Split(read("/proc/meminfo"), "\n") { + if key, value, ok := strings.Cut(line, ":"); ok { + r.Memory[key] = strings.TrimSpace(value) + } + } + for _, name := range []string{"overcommit_memory", "overcommit_ratio", "overcommit_kbytes", "max_map_count", "mmap_min_addr"} { + if value := read("/proc/sys/vm/" + name); value != "" { + r.VM[name] = value + } + } + r.Cgroup = read("/proc/self/cgroup") + r.Libc, r.Errors["libc"] = findLibc() + if r.Errors["libc"] == "" { + delete(r.Errors, "libc") + } +} diff --git a/sysinfo.go b/sysinfo.go index 9938529..d72610e 100644 --- a/sysinfo.go +++ b/sysinfo.go @@ -2,7 +2,7 @@ // // Use of this source code is governed by an MIT-style license that can be found in the LICENSE file. -// Package sysinfo is a Go library providing Linux OS / kernel / hardware system information. +// Package sysinfo is a Go library providing Linux and macOS / kernel / hardware system information. package sysinfo // SysInfo struct encapsulates all other information structs. @@ -30,24 +30,5 @@ func (si *SysInfo) GetSysInfo() { // Meta info si.getMetaInfo() - // DMI info - si.getProductInfo() - si.getBoardInfo() - si.getChassisInfo() - si.getBIOSInfo() - - // SMBIOS info - si.getMemoryInfo() - - // Node info - si.getNodeInfo() // depends on BIOS info - - // Hardware info - si.getCPUInfo() // depends on Node info - si.getStorageInfo() - si.getNetworkInfo() - - // Software info - si.getOSInfo() - si.getKernelInfo() + si.getPlatformInfo() }