two/internal/host/host.go
GnomeZworc 080ce82d0d
f-39: host: faits et état de l'hôte lus depuis /proc et /etc #39
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-31 20:11:17 +01:00

225 lines
4.9 KiB
Go

package host
import (
"bufio"
"fmt"
"io/fs"
"strconv"
"strings"
)
type CPU struct {
Vendor string
Model string
Sockets int
Cores int
Threads int
}
type OS struct {
ID string
VersionID string
PrettyName string
}
type Facts struct {
Hostname string
CPU CPU
MemoryBytes uint64
OS OS
Kernel string
}
type State struct {
BootTime int64
UptimeSeconds float64
Load [3]float64
}
func ReadFacts(fsys fs.FS) (Facts, error) {
var f Facts
var err error
if f.Hostname, err = readLine(fsys, "proc/sys/kernel/hostname"); err != nil {
return Facts{}, err
}
if f.Kernel, err = readLine(fsys, "proc/sys/kernel/osrelease"); err != nil {
return Facts{}, err
}
data, err := fs.ReadFile(fsys, "proc/cpuinfo")
if err != nil {
return Facts{}, err
}
if f.CPU, err = parseCPUInfo(string(data)); err != nil {
return Facts{}, err
}
data, err = fs.ReadFile(fsys, "proc/meminfo")
if err != nil {
return Facts{}, err
}
if f.MemoryBytes, err = parseMemTotal(string(data)); err != nil {
return Facts{}, err
}
data, err = fs.ReadFile(fsys, "etc/os-release")
if err != nil {
return Facts{}, err
}
f.OS = parseOSRelease(string(data))
return f, nil
}
func ReadState(fsys fs.FS) (State, error) {
var s State
data, err := fs.ReadFile(fsys, "proc/stat")
if err != nil {
return State{}, err
}
if s.BootTime, err = parseBootTime(string(data)); err != nil {
return State{}, err
}
line, err := readLine(fsys, "proc/uptime")
if err != nil {
return State{}, err
}
if s.UptimeSeconds, err = parseUptime(line); err != nil {
return State{}, err
}
if line, err = readLine(fsys, "proc/loadavg"); err != nil {
return State{}, err
}
if s.Load, err = parseLoadAvg(line); err != nil {
return State{}, err
}
return s, nil
}
func readLine(fsys fs.FS, name string) (string, error) {
data, err := fs.ReadFile(fsys, name)
if err != nil {
return "", err
}
line := strings.TrimSpace(string(data))
if line == "" {
return "", fmt.Errorf("%s: empty", name)
}
return line, nil
}
func parseCPUInfo(data string) (CPU, error) {
var cpu CPU
sockets := map[string]bool{}
cores := map[string]bool{}
var physical string
scanner := bufio.NewScanner(strings.NewReader(data))
for scanner.Scan() {
key, value, ok := strings.Cut(scanner.Text(), ":")
if !ok {
continue
}
value = strings.TrimSpace(value)
switch strings.TrimSpace(key) {
case "processor":
cpu.Threads++
physical = ""
case "vendor_id":
cpu.Vendor = value
case "model name":
cpu.Model = value
case "physical id":
physical = value
sockets[value] = true
case "core id":
if physical == "" {
return CPU{}, fmt.Errorf("cpuinfo: core id %s without physical id", value)
}
cores[physical+"/"+value] = true
}
}
if err := scanner.Err(); err != nil {
return CPU{}, fmt.Errorf("cpuinfo: %w", err)
}
if cpu.Threads == 0 || len(sockets) == 0 || len(cores) == 0 {
return CPU{}, fmt.Errorf("cpuinfo: %d processors, %d physical ids, %d core ids", cpu.Threads, len(sockets), len(cores))
}
cpu.Sockets = len(sockets)
cpu.Cores = len(cores)
return cpu, nil
}
func parseMemTotal(data string) (uint64, error) {
for _, line := range strings.Split(data, "\n") {
fields := strings.Fields(line)
if len(fields) != 3 || fields[0] != "MemTotal:" || fields[2] != "kB" {
continue
}
kb, err := strconv.ParseUint(fields[1], 10, 64)
if err != nil {
return 0, fmt.Errorf("meminfo: MemTotal: %w", err)
}
return kb * 1024, nil
}
return 0, fmt.Errorf("meminfo: no MemTotal in kB")
}
func parseOSRelease(data string) OS {
var rel OS
for _, line := range strings.Split(data, "\n") {
key, value, ok := strings.Cut(strings.TrimSpace(line), "=")
if !ok {
continue
}
if unquoted, err := strconv.Unquote(value); err == nil {
value = unquoted
}
switch key {
case "ID":
rel.ID = value
case "VERSION_ID":
rel.VersionID = value
case "PRETTY_NAME":
rel.PrettyName = value
}
}
return rel
}
func parseBootTime(data string) (int64, error) {
for _, line := range strings.Split(data, "\n") {
fields := strings.Fields(line)
if len(fields) == 2 && fields[0] == "btime" {
t, err := strconv.ParseInt(fields[1], 10, 64)
if err != nil {
return 0, fmt.Errorf("stat: btime: %w", err)
}
return t, nil
}
}
return 0, fmt.Errorf("stat: no btime")
}
func parseUptime(line string) (float64, error) {
fields := strings.Fields(line)
if len(fields) != 2 {
return 0, fmt.Errorf("uptime: %q", line)
}
up, err := strconv.ParseFloat(fields[0], 64)
if err != nil {
return 0, fmt.Errorf("uptime: %w", err)
}
return up, nil
}
func parseLoadAvg(line string) ([3]float64, error) {
var load [3]float64
fields := strings.Fields(line)
if len(fields) != 5 {
return load, fmt.Errorf("loadavg: %q", line)
}
for i := range load {
v, err := strconv.ParseFloat(fields[i], 64)
if err != nil {
return load, fmt.Errorf("loadavg: %w", err)
}
load[i] = v
}
return load, nil
}