add memory stats

2026-08-06 11:58:34 -07:00
parent 0998633e5c
commit b99bb45877
14 changed files with 448 additions and 143 deletions
@@ -0,0 +1,161 @@
+package drivers
+
+import (
+	"bufio"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+type DmiDecodeDriver struct{}
+
+func NewDmiDecodeDriver() *DmiDecodeDriver {
+	return &DmiDecodeDriver{}
+}
+
+// Parses dmidecode to extract physical hardware limits, slot counts, and module details
+func (r *DmiDecodeDriver) ReadHardwareSensors() (MemoryHardware, error) {
+	hw := MemoryHardware{}
+
+	// Query Memory Array (Type 16) for Max Capacity and Slot Count
+	arrayCmd := exec.Command("dmidecode", "-t", "16")
+	arrayOutput, err := arrayCmd.Output()
+	if err != nil {
+		return hw, fmt.Errorf("dmidecode -t 16 failed: %w", err)
+	}
+
+	// Query Memory Device (Type 17) for active slots, speed, type, form factor, and model name
+	deviceCmd := exec.Command("dmidecode", "-t", "17")
+	deviceOutput, err := deviceCmd.Output()
+	if err != nil {
+		return hw, fmt.Errorf("dmidecode -t 17 failed: %w", err)
+	}
+
+	// Parse Type 16 Output
+	scanner := bufio.NewScanner(strings.NewReader(string(arrayOutput)))
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if strings.HasPrefix(line, "Maximum Capacity:") {
+			hw.MaxCapacityGB = parseCapacityToGB(line)
+		} else if strings.HasPrefix(line, "Number Of Devices:") {
+			parts := strings.Split(line, ":")
+			if len(parts) == 2 {
+				hw.TotalSlots, _ = strconv.Atoi(strings.TrimSpace(parts[1]))
+			} else {
+				return hw, fmt.Errorf("parsing dmidecode -t 16 failed")
+			}
+		}
+	}
+
+	// Parse Type 17 Output
+	var currentSize, currentType, currentSpeed, currentForm, currentVendor, currentPart string
+
+	deviceScanner := bufio.NewScanner(strings.NewReader(string(deviceOutput)))
+	for deviceScanner.Scan() {
+		line := strings.TrimSpace(deviceScanner.Text())
+
+		if strings.HasPrefix(line, "Memory Device") {
+			processDeviceBlock(currentSize, currentType, currentSpeed, currentForm, currentVendor, currentPart, &hw)
+			currentSize, currentType, currentSpeed, currentForm, currentVendor, currentPart = "", "", "", "", "", ""
+			continue
+		}
+
+		if strings.HasPrefix(line, "Size:") {
+			currentSize = strings.TrimSpace(strings.TrimPrefix(line, "Size:"))
+		} else if strings.HasPrefix(line, "Type:") {
+			currentType = strings.TrimSpace(strings.TrimPrefix(line, "Type:"))
+		} else if strings.HasPrefix(line, "Speed:") || strings.HasPrefix(line, "Configured Memory Speed:") {
+			val := strings.TrimSpace(strings.Split(line, ":")[1])
+			if val != "Unknown" && val != "" && currentSpeed == "" {
+				currentSpeed = val
+			}
+		} else if strings.HasPrefix(line, "Form Factor:") {
+			currentForm = strings.TrimSpace(strings.TrimPrefix(line, "Form Factor:"))
+		} else if strings.HasPrefix(line, "Manufacturer:") {
+			currentVendor = strings.TrimSpace(strings.TrimPrefix(line, "Manufacturer:"))
+		} else if strings.HasPrefix(line, "Part Number:") {
+			currentPart = strings.TrimSpace(strings.TrimPrefix(line, "Part Number:"))
+		}
+	}
+	// Process the final block
+	processDeviceBlock(currentSize, currentType, currentSpeed, currentForm, currentVendor, currentPart, &hw)
+
+	return hw, nil
+}
+
+func processDeviceBlock(size, memType, speed, form, vendor, part string, hw *MemoryHardware) {
+	if size != "" && size != "No Module Installed" && size != "Unknown" {
+		hw.SlotsUsed++
+
+		if memType != "" && memType != "Unknown" {
+			hw.Generations = append(hw.Generations, memType)
+		} else {
+			hw.Generations = append(hw.Generations, "Unknown")
+		}
+
+		if speed != "" && speed != "Unknown" {
+			hw.Speeds = append(hw.Speeds, speed)
+		} else {
+			hw.Speeds = append(hw.Speeds, "Unknown")
+		}
+
+		if form != "" && form != "Unknown" {
+			hw.FormFactors = append(hw.FormFactors, form)
+		} else {
+			hw.FormFactors = append(hw.FormFactors, "Unknown")
+		}
+
+		// Construct model/part identifier
+		partClean := cleanString(part)
+		vendorClean := cleanString(vendor)
+
+		if partClean != "" && vendorClean != "" {
+			hw.ModelNames = append(hw.ModelNames, fmt.Sprintf("%s (%s)", partClean, vendorClean))
+		} else if partClean != "" {
+			hw.ModelNames = append(hw.ModelNames, partClean)
+		} else if vendorClean != "" {
+			hw.ModelNames = append(hw.ModelNames, vendorClean)
+		} else {
+			hw.ModelNames = append(hw.ModelNames, "Unknown")
+		}
+	}
+}
+
+func cleanString(val string) string {
+	v := strings.TrimSpace(val)
+	if v == "" || v == "Unknown" || v == "NO DIMM" || strings.HasPrefix(v, "0x") {
+		return ""
+	}
+	return v
+}
+
+func parseCapacityToGB(line string) float64 {
+	parts := strings.Split(line, ":")
+	if len(parts) < 2 {
+		return 0
+	}
+	valStr := strings.TrimSpace(parts[1])
+	fields := strings.Fields(valStr)
+	if len(fields) < 2 {
+		return 0
+	}
+	val, err := strconv.ParseFloat(fields[0], 64)
+	if err != nil {
+		return 0
+	}
+	unit := strings.ToUpper(fields[1])
+	if strings.HasPrefix(unit, "TB") {
+		return val * 1024
+	} else if strings.HasPrefix(unit, "MB") {
+		return val / 1024
+	}
+	return val
+}
+
+func formatSlice(s []string) string {
+	if len(s) == 0 {
+		return "N/A"
+	}
+	return strings.Join(s, ", ")
+}
@@ -0,0 +1,28 @@
+package drivers
+
+// MemoryUsage holds live RAM stats from /proc/meminfo
+type MemoryUsage struct {
+	TotalGB     float64
+	AvailableGB float64
+	UsedGB      float64
+	UsedPercent float64
+}
+
+type UsageDriver interface {
+	ReadUsageSensors() (MemoryUsage, error)
+}
+
+// MemoryHardware holds physical RAM slot and module details
+type MemoryHardware struct {
+	MaxCapacityGB float64
+	TotalSlots    int
+	SlotsUsed     int
+	Generations   []string
+	Speeds        []string
+	FormFactors   []string
+	ModelNames    []string
+}
+
+type HardwareDriver interface {
+	ReadHardwareSensors() (MemoryHardware, error)
+}
@@ -0,0 +1,63 @@
+package drivers
+
+import (
+	"bufio"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type MemInfoDriver struct{}
+
+func NewMemInfoDriver() *MemInfoDriver {
+	return &MemInfoDriver{}
+}
+
+// Read /proc/meminfo for active system memory statistics
+func (r *MemInfoDriver) ReadUsageSensors() (MemoryUsage, error) {
+	usage := MemoryUsage{}
+	file, err := os.Open("/proc/meminfo")
+	if err != nil {
+		return usage, err
+	}
+	defer file.Close()
+
+	var memTotal, memAvailable float64
+	scanner := bufio.NewScanner(file)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		fields := strings.Fields(line)
+		if len(fields) < 2 {
+			continue
+		}
+
+		val, err := strconv.ParseFloat(fields[1], 64)
+		if err != nil {
+			continue
+		}
+
+		switch fields[0] {
+		case "MemTotal:":
+			memTotal = val // stored in kB
+		case "MemAvailable:":
+			memAvailable = val // stored in kB
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return usage, err
+	}
+
+	used := memTotal - memAvailable
+	usedPct := (used / memTotal) * 100
+
+	usage = MemoryUsage{
+		TotalGB:     memTotal / (1024 * 1024),
+		AvailableGB: memAvailable / (1024 * 1024),
+		UsedGB:      used / (1024 * 1024),
+		UsedPercent: usedPct,
+	}
+
+	return usage, nil
+}
@@ -0,0 +1,69 @@
+package mem
+
+import (
+	"finally-a-monolithic-linux-hw-monitor/app/mem/drivers"
+	"fmt"
+	"strings"
+)
+
+func RenderMem(console *strings.Builder, mem *Mem) {
+	fmt.Fprintf(console, "=== %s ===\n", "Memory")
+	RenderUsageSensors(console, mem)
+	RenderHardwareSensors(console, mem)
+}
+
+func RenderUsageSensors(console *strings.Builder, mem *Mem) {
+	usage, _ := mem.SensorReader.ReadUsageSensors()
+	fmt.Fprintf(console, "--- Usage ---\n")
+	fmt.Fprintf(console, "%-16s | %.2f GiB\033[K\n", "Total", usage.TotalGB)
+	fmt.Fprintf(console, "%-16s | %.2f GiB (%.2f%%) \033[K\n", "Used", usage.UsedGB, usage.UsedPercent)
+	fmt.Fprintf(console, "%-16s | %.2f GiB\033[K\n", "Avail", usage.AvailableGB)
+}
+
+func RenderHardwareSensors(console *strings.Builder, mem *Mem) {
+	hardware, _ := mem.SensorReader.ReadHardwareSensors()
+	for i := range len(hardware.ModelNames) {
+		fmt.Fprintf(console, "--- RAM Module %d ---\n", i)
+		modelName := hardware.ModelNames[i]
+		fmt.Fprintf(console, "%-16s | %-16s \033[K\n", "Model Name", modelName)
+		generation := hardware.Generations[i]
+		speed := hardware.Speeds[i]
+		fmt.Fprintf(console, "%-16s | %s@%s \033[K\n", "Speed", generation, speed)
+		formFactor := hardware.FormFactors[i]
+		fmt.Fprintf(console, "%-16s | %s \033[K\n", "Form Factor", formFactor)
+	}
+}
+
+type Mem struct {
+	SensorReader MemSensorReader
+}
+
+func GetMem() (Mem, error) {
+	memInfoDriver := drivers.NewMemInfoDriver()
+	dmiDecodeDriver := drivers.NewDmiDecodeDriver()
+	reader := &StandardMemSensorReader{
+		UsageReader:    memInfoDriver,
+		HardwareReader: dmiDecodeDriver,
+	}
+	return Mem{
+		SensorReader: reader,
+	}, nil
+}
+
+type MemSensorReader interface {
+	ReadUsageSensors() (drivers.MemoryUsage, error)
+	ReadHardwareSensors() (drivers.MemoryHardware, error)
+}
+
+type StandardMemSensorReader struct {
+	UsageReader    drivers.UsageDriver
+	HardwareReader drivers.HardwareDriver
+}
+
+func (r *StandardMemSensorReader) ReadUsageSensors() (drivers.MemoryUsage, error) {
+	return r.UsageReader.ReadUsageSensors()
+}
+
+func (r *StandardMemSensorReader) ReadHardwareSensors() (drivers.MemoryHardware, error) {
+	return r.HardwareReader.ReadHardwareSensors()
+}