diff --git a/.claude/settings.local.json b/.claude/settings.local.json deleted file mode 100644 index a8b97a3..0000000 --- a/.claude/settings.local.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "permissions": { - "allow": [ - "Bash(git -C /home/spoulson/src/frostd log --oneline)", - "Bash(git *)", - "Bash(go version *)", - "Bash(go get *)", - "Bash(chmod +x *)", - "Bash(go build *)", - "Bash(go test *)", - "Bash(go mod *)" - ] - } -} diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml index 79e0cde..d88843b 100644 --- a/.github/workflows/verify.yml +++ b/.github/workflows/verify.yml @@ -6,30 +6,36 @@ on: pull_request: branches: [main] -env: - GOLANGCI_LINT_VERSION: v2.11.4 - jobs: lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: actions/setup-go@v5 - with: - go-version-file: go.mod + - name: Install C dev dependencies + run: | + sudo apt-get update -q + sudo apt-get install -y \ + libcyaml-dev libyaml-dev \ + libipmimonitoring-dev libfreeipmi-dev \ + libmicrohttpd-dev \ + libcmocka-dev \ + cppcheck - - uses: golangci/golangci-lint-action@v9 - with: - version: ${{ env.GOLANGCI_LINT_VERSION }} + - run: make lint test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: actions/setup-go@v5 - with: - go-version-file: go.mod + - name: Install C dev dependencies + run: | + sudo apt-get update -q + sudo apt-get install -y \ + libcyaml-dev libyaml-dev \ + libipmimonitoring-dev libfreeipmi-dev \ + libmicrohttpd-dev \ + libcmocka-dev - - run: go test -race ./... + - run: make test diff --git a/.gitignore b/.gitignore index 9123135..9c0f76a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,8 @@ /frostd /bin frostd*.deb +test_config +test_cpu +test_fan +test_gpu +test_metrics diff --git a/CLAUDE.md b/CLAUDE.md index 646718f..16d1b71 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -90,60 +90,95 @@ affecting hardware. ## Technology Stack -`frostd` is written in Golang and compiled to standalone executable file to be -run on Debian or Ubuntu Linux on x86-64 architecture. The executable runs as a -systemd service. +`frostd` is written in C (C23 standard) and compiled to a standalone executable +to be run on Debian or Ubuntu Linux on x86-64 architecture. The executable +runs as a systemd service. ## Developer Prerequisites - Debian or Ubuntu Linux OS on x86-64 architecture -- Golang 1.26+ installed +- GCC 9+ installed (GCC 13+ recommended for C23 support) - `make` installed +- C development libraries: + - `libcyaml-dev` (YAML parsing) + - `libyaml-dev` (libcyaml dependency) + - `libipmimonitoring-dev` (IPMI sensor reads) + - `libfreeipmi-dev` (IPMI raw commands) + - `libmicrohttpd-dev` (Prometheus HTTP server) + - `libcmocka-dev` (unit testing) + - `cppcheck` (static analysis) ## Software Design ### Technology Stack -- `frostd` is a systemd service written in latest Golang. +- `frostd` is a systemd service written in C (C23 standard). - It must be run on a Dell PowerEdge 12th generation server. +### Source Layout + +``` +src/ C source and header files +tests/ Unit test files and shared test helpers +packaging/ Debian package scripts and systemd configuration +``` + ### Tooling -- Use `slog` package for logging. -- Use module `github.com/bougou/go-ipmi` for IPMI support. Do not depend on -the commonly used `ipmitool` command. +- Use structured logging via `src/log.c/.h` (text key=value or JSON format). +- Use `libipmimonitoring` for IPMI sensor reads (temperature, fan). +- Use `libfreeipmi` API (`ipmi_ctx_t`) for IPMI raw commands (fan control). +- Do not depend on the commonly used `ipmitool` command. +- Use `libcyaml` for YAML config parsing. +- Use `libmicrohttpd` for the Prometheus metrics HTTP endpoint. + +### Interfaces (vtable pattern) + +C interfaces are implemented as function-pointer structs: +- `ipmi_ops_t` (`src/ipmi.h`) — IPMI operations (connect/sensors/raw command) +- `temp_reader_t` (`src/metrics.h`) — temperature reader for sensor monitors +- `cmd_runner_t` (`src/gpu.h`) — command execution (nvidia-smi) + +Tests inject mock implementations of these vtables instead of real hardware. ### Service Lifecycle Service starts up by parsing and validating the configuration file. -Then, the service runs in a loop. On each iteration: +Then, the service runs with one pthread per sensor type. Each sensor thread: - Polls temperature metrics -- Compute suggested fan speed -- Set chassis fan speed -- Sleep until next interval - - Sleep to incremental times, not static durations. This ensures loops occur - on steady cadence even if one iteration takes a bit longer to process. +- Computes suggested fan speed +- Posts the speed to a shared `speed_bus_t` (mutex + condvar) +- Sleeps until next tick using `clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME)` + for steady cadence + +The main thread waits on the `speed_bus_t` condvar (with a fan-log timeout), +takes the max speed across all sensors, and calls `fan_set_speed()`. + +The service gracefully stops on SIGTERM/SIGINT via a `volatile sig_atomic_t +g_shutdown` flag checked in each thread loop. -The service immediately and gracefully stops when requested with command: -`systemctl stop frostd`. +**Note:** IPMI calls are synchronous and blocking. SIGTERM response time may +be up to one IPMI timeout period (~5–10 seconds) while an IPMI call completes. ### Tests Tests are required to confirm requirements and prevent regressions during code maintenance. -Use module `github.com/stretchr/testify` for `assert` and `require` packages -for simplifying assertions and validation logic. +Use `libcmocka` for test assertions (`assert_int_equal`, `assert_string_equal`, +`assert_float_equal`, etc.). Each test file has its own `main()` function and +is compiled and run independently by `make test`. -End-to-end tests are required for functionality: -- Configuration parsing - - YAML file structure - - Validation for each field with happy path, numeric range errors, and likely special case checks -- Computing aggregate temperature metrics +Shared mock helpers live in `tests/test_helpers.h` and `tests/test_helpers.c`. + +Test coverage required for: +- Configuration parsing (YAML, defaults, validation) +- Computing aggregate temperature metrics (rolling buffer) - Computing suggested fan speeds from mock temperature samples -- Reading actual CPU temperature metrics -- Reading actual NVIDIA GPU temperature metrics using `nvidia-smi` +- Reading CPU temperature metrics via mock IPMI vtable +- Reading GPU temperature metrics via mock command runner +- Fan IPMI control (ReadFanSpeeds, SetSpeed) via mock IPMI vtable ### Error Handling @@ -165,18 +200,17 @@ next iteration when fan speed is suggested again. ## Launch From Source -The repository will provide a `make run` target that will: -- Call `go run` to launch the service using the configuration file `dev.yaml`. -- `dev.yaml` is a copy of the default configuration file used for installing -`/etc/frostd.yaml`. -- Log output goes to stdout instead of a log file. +The repository provides a `make run` target that: +- Builds the service binary +- Launches it using the configuration file `dev.yaml` +- Log output goes to stdout (since `dev.yaml` has no `log_file` set) ## Software Package Installation -The repository will provide a `make package` target that will: -- Build the executable -- Build a Debian .deb package that can be installed with `apt install` on -Debian and Ubuntu Linux OS +The repository provides a `make package` target that: +- Builds the executable +- Builds a Debian .deb package installable with `apt install` on + Debian and Ubuntu Linux OS The package includes the compiled executable, default configuration for `/etc/frostd.yaml`, and systemd service configuration. @@ -196,10 +230,18 @@ not a literal filename. Place the directive on the line before its definition, not as a single directive for all targets. This helps prevent forgetting to update the list. -### Golang +### C + +Write code targeting C23 (`-std=c2x` flag for GCC 13). Follow standard C best +practices: const-correctness, error-checked return codes, no implicit fallthrough. -Write code for latest Golang version. Follow Golang's current standards of code -style and best practices as outlined in Effective Go by Google. +- Compile flags: `-std=c2x -D_GNU_SOURCE -Wall -Wextra -Wpedantic` +- No global mutable state except `volatile sig_atomic_t g_shutdown` in main.c +- Memory ownership: functions that allocate with `malloc` expose a matching + `*_free()` function; the caller is responsible for calling it. +- Error reporting: functions return -1 (or NULL) on failure and write a + human-readable message into a caller-supplied `char *errbuf, int errbuflen` + parameter pair. ## License diff --git a/Makefile b/Makefile index e1f07b7..c3f024a 100644 --- a/Makefile +++ b/Makefile @@ -1,25 +1,53 @@ BINARY = frostd -GOLANGCI_LINT = ./bin/golangci-lint -GOLANGCI_LINT_VERSION = v2.11.4 + +CC = gcc +CFLAGS = -std=c2x -D_GNU_SOURCE -Wall -Wextra -Wpedantic \ + $(shell pkg-config --cflags libcyaml libipmimonitoring libfreeipmi libmicrohttpd) +LIBS = $(shell pkg-config --libs libcyaml libipmimonitoring libfreeipmi libmicrohttpd) \ + -lpthread -lm + +TEST_CFLAGS = $(CFLAGS) $(shell pkg-config --cflags cmocka) +TEST_LIBS = $(LIBS) $(shell pkg-config --libs cmocka) + +SRCS = src/config.c src/cpu.c src/fan.c src/gpu.c src/ipmi.c \ + src/log.c src/metrics.c src/prometheus.c src/service.c + +TEST_SRCS = tests/test_config.c tests/test_metrics.c tests/test_fan.c \ + tests/test_gpu.c tests/test_cpu.c + +$(BINARY): $(SRCS) + $(CC) $(CFLAGS) -o $(BINARY) src/main.c $(SRCS) $(LIBS) .PHONY: build -build: - go build -o $(BINARY) . +build: $(BINARY) .PHONY: run -run: - go run . -c dev.yaml +run: build + ./$(BINARY) -c dev.yaml .PHONY: test test: - go test -race ./... - -$(GOLANGCI_LINT): - curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b ./bin $(GOLANGCI_LINT_VERSION) + $(CC) $(TEST_CFLAGS) -o test_config src/config.c src/log.c \ + tests/test_config.c $(TEST_LIBS) && ./test_config + $(CC) $(TEST_CFLAGS) -o test_metrics src/metrics.c \ + tests/test_metrics.c tests/test_helpers.c $(TEST_LIBS) && ./test_metrics + $(CC) $(TEST_CFLAGS) -o test_fan src/fan.c src/metrics.c \ + tests/test_fan.c tests/test_helpers.c $(TEST_LIBS) -lm && ./test_fan + $(CC) $(TEST_CFLAGS) -o test_gpu src/gpu.c \ + tests/test_gpu.c tests/test_helpers.c $(TEST_LIBS) && ./test_gpu + $(CC) $(TEST_CFLAGS) -o test_cpu src/cpu.c \ + tests/test_cpu.c tests/test_helpers.c $(TEST_LIBS) && ./test_cpu .PHONY: lint -lint: $(GOLANGCI_LINT) - $(GOLANGCI_LINT) run +lint: + cppcheck --std=c2x --enable=warning,style,performance \ + --suppress=missingIncludeSystem \ + --suppress=syntaxError \ + src/ 2>&1 + +.PHONY: clean +clean: + rm -f $(BINARY) test_config test_metrics test_fan test_gpu test_cpu .PHONY: install install: build diff --git a/README.md b/README.md index aabba6d..5922d38 100644 --- a/README.md +++ b/README.md @@ -36,10 +36,20 @@ This allows for a measurable power reduction at idle. - Dell PowerEdge 12th generation server (e.g. R720) - Debian or Ubuntu Linux, x86-64 -- Go 1.26+ (build only) -- `make` (build only) - Compatible NVIDIA driver and CUDA toolkit (GPU monitoring only) +### Build requirements + +- GCC 9+ (GCC 13+ recommended for C23 support) +- `make` +- `libcyaml-dev` (YAML parsing) +- `libyaml-dev` (libcyaml dependency) +- `libipmimonitoring-dev` (IPMI sensor reads) +- `libfreeipmi-dev` (IPMI raw commands) +- `libmicrohttpd-dev` (Prometheus HTTP server) +- `libcmocka-dev` (unit testing) +- `cppcheck` (static analysis) + ## Dev Tooling ### Build diff --git a/config.go b/config.go deleted file mode 100644 index 84755e5..0000000 --- a/config.go +++ /dev/null @@ -1,118 +0,0 @@ -package main - -import ( - "fmt" - "os" - "time" - - "gopkg.in/yaml.v3" -) - -type Config struct { - LogFile string `yaml:"log_file"` - LogFormat string `yaml:"log_format"` - DryRun bool `yaml:"dry_run"` - FanLogInterval time.Duration `yaml:"fan_log_interval"` - Prometheus *PrometheusConfig `yaml:"prometheus"` - CPU *SensorConfig `yaml:"cpu"` - GPU *SensorConfig `yaml:"gpu"` -} - -type PrometheusConfig struct { - ListenAddr string `yaml:"listen_addr"` -} - -type SensorConfig struct { - IdealTemp float64 `yaml:"ideal_temp"` - MaxTemp float64 `yaml:"max_temp"` - SampleSize int `yaml:"sample_size"` - SampleInterval time.Duration `yaml:"sample_interval"` -} - -func loadConfig(path string) (*Config, error) { - data, err := os.ReadFile(path) - if err != nil { - return nil, fmt.Errorf("reading config file: %w", err) - } - var cfg Config - if err := yaml.Unmarshal(data, &cfg); err != nil { - return nil, fmt.Errorf("parsing config file: %w", err) - } - applyDefaults(&cfg) - if err := validateConfig(&cfg); err != nil { - return nil, err - } - return &cfg, nil -} - -func applyDefaults(cfg *Config) { - if cfg.LogFormat == "" { - cfg.LogFormat = "text" - } - if cfg.FanLogInterval == 0 { - cfg.FanLogInterval = 15 * time.Second - } - if cfg.CPU != nil { - applySensorDefaults(cfg.CPU) - } - if cfg.GPU != nil { - applySensorDefaults(cfg.GPU) - } -} - -func applySensorDefaults(d *SensorConfig) { - if d.IdealTemp == 0 { - d.IdealTemp = 40 - } - if d.MaxTemp == 0 { - d.MaxTemp = 75 - } - if d.SampleSize == 0 { - d.SampleSize = 3 - } - if d.SampleInterval == 0 { - d.SampleInterval = 15 * time.Second - } -} - -func validateConfig(cfg *Config) error { - if cfg.CPU == nil && cfg.GPU == nil { - return fmt.Errorf("config must enable at least one sensor type (cpu or gpu)") - } - if cfg.LogFormat != "text" && cfg.LogFormat != "json" { - return fmt.Errorf("log_format must be \"text\" or \"json\", got %q", cfg.LogFormat) - } - if cfg.FanLogInterval <= 0 { - return fmt.Errorf("fan_log_interval must be positive, got %s", cfg.FanLogInterval) - } - if cfg.CPU != nil { - if err := validateSensorConfig("cpu", cfg.CPU); err != nil { - return err - } - } - if cfg.GPU != nil { - if err := validateSensorConfig("gpu", cfg.GPU); err != nil { - return err - } - } - return nil -} - -func validateSensorConfig(name string, d *SensorConfig) error { - if d.IdealTemp <= 0 { - return fmt.Errorf("%s: ideal_temp must be positive, got %.1f", name, d.IdealTemp) - } - if d.MaxTemp <= 0 { - return fmt.Errorf("%s: max_temp must be positive, got %.1f", name, d.MaxTemp) - } - if d.IdealTemp >= d.MaxTemp { - return fmt.Errorf("%s: ideal_temp (%.1f) must be less than max_temp (%.1f)", name, d.IdealTemp, d.MaxTemp) - } - if d.SampleSize < 1 { - return fmt.Errorf("%s: sample_size must be at least 1, got %d", name, d.SampleSize) - } - if d.SampleInterval <= 0 { - return fmt.Errorf("%s: sample_interval must be positive, got %s", name, d.SampleInterval) - } - return nil -} diff --git a/config_test.go b/config_test.go deleted file mode 100644 index 3283d24..0000000 --- a/config_test.go +++ /dev/null @@ -1,186 +0,0 @@ -package main - -import ( - "os" - "testing" - "time" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func writeTempConfig(t *testing.T, content string) string { - t.Helper() - f, err := os.CreateTemp(t.TempDir(), "frostd-*.yaml") - require.NoError(t, err) - _, err = f.WriteString(content) - require.NoError(t, err) - err = f.Close() - require.NoError(t, err) - return f.Name() -} - -func TestLoadConfig_HappyPath(t *testing.T) { - path := writeTempConfig(t, ` -log_file: /var/log/frostd/frostd.log -cpu: - ideal_temp: 45 - max_temp: 80 - sample_size: 5 - sample_interval: 10s -gpu: - ideal_temp: 50 - max_temp: 85 - sample_size: 4 - sample_interval: 20s -`) - cfg, err := loadConfig(path) - require.NoError(t, err) - assert.Equal(t, "/var/log/frostd/frostd.log", cfg.LogFile) - assert.False(t, cfg.DryRun) - assert.Equal(t, 45.0, cfg.CPU.IdealTemp) - assert.Equal(t, 80.0, cfg.CPU.MaxTemp) - assert.Equal(t, 5, cfg.CPU.SampleSize) - assert.Equal(t, 10*time.Second, cfg.CPU.SampleInterval) - assert.Equal(t, 50.0, cfg.GPU.IdealTemp) -} - -func TestLoadConfig_DryRunEnabled(t *testing.T) { - path := writeTempConfig(t, ` -dry_run: true -cpu: - ideal_temp: 40 - max_temp: 75 -`) - cfg, err := loadConfig(path) - require.NoError(t, err) - assert.True(t, cfg.DryRun) -} - -func TestLoadConfig_DryRunDefault(t *testing.T) { - path := writeTempConfig(t, `cpu: {}`) - cfg, err := loadConfig(path) - require.NoError(t, err) - assert.False(t, cfg.DryRun) -} - -func TestLoadConfig_Defaults(t *testing.T) { - path := writeTempConfig(t, `cpu: {}`) - cfg, err := loadConfig(path) - require.NoError(t, err) - assert.Equal(t, "text", cfg.LogFormat) - assert.Equal(t, 40.0, cfg.CPU.IdealTemp) - assert.Equal(t, 75.0, cfg.CPU.MaxTemp) - assert.Equal(t, 3, cfg.CPU.SampleSize) - assert.Equal(t, 15*time.Second, cfg.CPU.SampleInterval) -} - -func TestLoadConfig_LogFormatJSON(t *testing.T) { - path := writeTempConfig(t, ` -log_format: json -cpu: {} -`) - cfg, err := loadConfig(path) - require.NoError(t, err) - assert.Equal(t, "json", cfg.LogFormat) -} - -func TestLoadConfig_LogFormatInvalid(t *testing.T) { - path := writeTempConfig(t, ` -log_format: xml -cpu: {} -`) - _, err := loadConfig(path) - assert.ErrorContains(t, err, "log_format") -} - -func TestLoadConfig_NoDevices(t *testing.T) { - path := writeTempConfig(t, `log_file: /tmp/test.log`) - _, err := loadConfig(path) - assert.ErrorContains(t, err, "at least one sensor type") -} - -func TestLoadConfig_IdealTempEqualMaxTemp(t *testing.T) { - path := writeTempConfig(t, ` -cpu: - ideal_temp: 75 - max_temp: 75 -`) - _, err := loadConfig(path) - assert.Error(t, err) -} - -func TestLoadConfig_IdealTempGreaterThanMaxTemp(t *testing.T) { - path := writeTempConfig(t, ` -cpu: - ideal_temp: 80 - max_temp: 75 -`) - _, err := loadConfig(path) - assert.Error(t, err) -} - -func TestLoadConfig_SampleSizeNegative(t *testing.T) { - path := writeTempConfig(t, ` -cpu: - ideal_temp: 40 - max_temp: 75 - sample_size: -1 - sample_interval: 15s -`) - _, err := loadConfig(path) - assert.ErrorContains(t, err, "sample_size") -} - -func TestLoadConfig_NegativeSampleInterval(t *testing.T) { - path := writeTempConfig(t, ` -cpu: - ideal_temp: 40 - max_temp: 75 - sample_size: 3 - sample_interval: -5s -`) - _, err := loadConfig(path) - assert.ErrorContains(t, err, "sample_interval") -} - -func TestLoadConfig_InvalidYAML(t *testing.T) { - path := writeTempConfig(t, `:::invalid yaml:::`) - _, err := loadConfig(path) - assert.Error(t, err) -} - -func TestLoadConfig_MissingFile(t *testing.T) { - _, err := loadConfig("/nonexistent/path/frostd.yaml") - assert.Error(t, err) -} - -func TestLoadConfig_PrometheusWithListenAddr(t *testing.T) { - path := writeTempConfig(t, ` -cpu: {} -prometheus: - listen_addr: ":9100" -`) - cfg, err := loadConfig(path) - require.NoError(t, err) - require.NotNil(t, cfg.Prometheus) - assert.Equal(t, ":9100", cfg.Prometheus.ListenAddr) -} - -func TestLoadConfig_PrometheusAbsent(t *testing.T) { - path := writeTempConfig(t, `cpu: {}`) - cfg, err := loadConfig(path) - require.NoError(t, err) - assert.Nil(t, cfg.Prometheus) -} - -func TestLoadConfig_PrometheusEmptyListenAddr(t *testing.T) { - path := writeTempConfig(t, ` -cpu: {} -prometheus: {} -`) - cfg, err := loadConfig(path) - require.NoError(t, err) - require.NotNil(t, cfg.Prometheus) - assert.Equal(t, "", cfg.Prometheus.ListenAddr) -} diff --git a/cpu.go b/cpu.go deleted file mode 100644 index 939346f..0000000 --- a/cpu.go +++ /dev/null @@ -1,53 +0,0 @@ -package main - -import ( - "context" - "fmt" - - ipmi "github.com/bougou/go-ipmi" -) - -type CPUReader struct { - newClient func() (ipmiClient, error) -} - -// ReadTemperatures returns CPU package temperatures via IPMI, keyed by sensor name. -// It reads temperature sensors with entity ID 0x03 (processor). -func (r *CPUReader) ReadTemperatures() (map[string]float64, error) { - ctx := context.Background() - client, err := r.newClient() - if err != nil { - return nil, fmt.Errorf("creating IPMI client: %w", err) - } - if err := client.Connect(ctx); err != nil { - return nil, fmt.Errorf("connecting to IPMI: %w", err) - } - defer func() { - _ = client.Close(ctx) - }() - - sensors, err := client.GetSensors(ctx, - ipmi.SensorFilterOptionIsSensorType(ipmi.SensorTypeTemperature)) - if err != nil { - return nil, fmt.Errorf("getting IPMI temperature sensors: %w", err) - } - - temps := map[string]float64{} - for _, s := range sensors { - if uint8(s.EntityID) != 0x03 { - continue - } - key := s.Name - for i := 2; ; i++ { - if _, exists := temps[key]; !exists { - break - } - key = fmt.Sprintf("%s_%d", s.Name, i) - } - temps[key] = s.Value - } - if len(temps) == 0 { - return nil, fmt.Errorf("no CPU temperature sensors found") - } - return temps, nil -} diff --git a/cpu_test.go b/cpu_test.go deleted file mode 100644 index 3580bc7..0000000 --- a/cpu_test.go +++ /dev/null @@ -1,91 +0,0 @@ -package main - -import ( - "testing" - - ipmi "github.com/bougou/go-ipmi" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func makeProcessorTempSensor(name string, value float64, entityInstance uint8) *ipmi.Sensor { - return &ipmi.Sensor{ - Name: name, - SensorType: ipmi.SensorTypeTemperature, - EntityID: ipmi.EntityID(0x03), - EntityInstance: ipmi.EntityInstance(entityInstance), - Value: value, - } -} - -func makeInletTempSensor(value float64) *ipmi.Sensor { - return &ipmi.Sensor{ - SensorType: ipmi.SensorTypeTemperature, - EntityID: ipmi.EntityID(0x07), // system board - Value: value, - } -} - -func TestCPUReader_ReturnsProcessorTemps(t *testing.T) { - mock := &mockIPMIClient{ - sensors: []*ipmi.Sensor{ - makeProcessorTempSensor("CPU1 Temp", 45, 1), - makeProcessorTempSensor("CPU2 Temp", 50, 2), - makeInletTempSensor(23), - }, - } - reader := &CPUReader{newClient: mockIPMIFactory(mock)} - temps, err := reader.ReadTemperatures() - require.NoError(t, err) - assert.Equal(t, map[string]float64{"CPU1 Temp": 45, "CPU2 Temp": 50}, temps) -} - -func TestCPUReader_DeduplicatesSensorNames(t *testing.T) { - mock := &mockIPMIClient{ - sensors: []*ipmi.Sensor{ - makeProcessorTempSensor("Temp", 45, 1), - makeProcessorTempSensor("Temp", 50, 2), - makeProcessorTempSensor("Temp", 55, 3), - }, - } - reader := &CPUReader{newClient: mockIPMIFactory(mock)} - temps, err := reader.ReadTemperatures() - require.NoError(t, err) - assert.Equal(t, map[string]float64{"Temp": 45, "Temp_2": 50, "Temp_3": 55}, temps) -} - -func TestCPUReader_IgnoresNonProcessorSensors(t *testing.T) { - mock := &mockIPMIClient{ - sensors: []*ipmi.Sensor{ - makeInletTempSensor(23), - }, - } - reader := &CPUReader{newClient: mockIPMIFactory(mock)} - _, err := reader.ReadTemperatures() - assert.ErrorContains(t, err, "no CPU temperature sensors found") -} - -func TestCPUReader_EmptySensorList(t *testing.T) { - mock := &mockIPMIClient{sensors: []*ipmi.Sensor{}} - reader := &CPUReader{newClient: mockIPMIFactory(mock)} - _, err := reader.ReadTemperatures() - assert.Error(t, err) -} - -func TestCPUReader_ClientConnectError(t *testing.T) { - reader := &CPUReader{newClient: mockIPMIFactoryErr("no IPMI device")} - _, err := reader.ReadTemperatures() - assert.Error(t, err) -} - -func TestCPUReader_GetSensorsError(t *testing.T) { - mock := &mockIPMIClient{rawErr: errIPMI("ipmitool failed")} - reader := &CPUReader{newClient: mockIPMIFactory(mock)} - _, err := reader.ReadTemperatures() - assert.Error(t, err) -} - -// errIPMI is a simple error helper for tests. -type errIPMI string - -func (e errIPMI) Error() string { return string(e) } diff --git a/executor.go b/executor.go deleted file mode 100644 index db773c4..0000000 --- a/executor.go +++ /dev/null @@ -1,13 +0,0 @@ -package main - -import "os/exec" - -type CommandRunner interface { - Run(name string, args ...string) ([]byte, error) -} - -type RealRunner struct{} - -func (r RealRunner) Run(name string, args ...string) ([]byte, error) { - return exec.Command(name, args...).Output() -} diff --git a/fan.go b/fan.go deleted file mode 100644 index 965215e..0000000 --- a/fan.go +++ /dev/null @@ -1,106 +0,0 @@ -package main - -import ( - "context" - "fmt" - "math" - - ipmi "github.com/bougou/go-ipmi" -) - -// SuggestSpeed computes fan speed [0,100] using a parabolic easing curve. -func SuggestSpeed(actualTemp, idealTemp, maxTemp float64) int { - if actualTemp <= idealTemp { - return 0 - } - deltaTemp1 := actualTemp - idealTemp - deltaTemp2 := maxTemp - idealTemp - speed := (deltaTemp1 * deltaTemp1) * (100 / (deltaTemp2 * deltaTemp2)) - if speed > 100 { - return 100 - } - return int(math.Round(speed)) -} - -type FanReading struct { - Name string - RPM *float64 - Percent *float64 -} - -type FanController interface { - ReadFanSpeeds(ctx context.Context) ([]FanReading, error) - SetSpeed(ctx context.Context, percent int) error -} - -type IPMIFanController struct { - newClient func() (ipmiClient, error) -} - -// ReadFanSpeeds returns current readings from all IPMI fan sensors. -// Each reading includes RPM if the sensor reports in RPM, or percent if the sensor reports as a percentage. -func (c *IPMIFanController) ReadFanSpeeds(ctx context.Context) ([]FanReading, error) { - client, err := c.newClient() - if err != nil { - return nil, fmt.Errorf("creating IPMI client: %w", err) - } - if err := client.Connect(ctx); err != nil { - return nil, fmt.Errorf("connecting to IPMI: %w", err) - } - defer func() { - _ = client.Close(ctx) - }() - - sensors, err := client.GetSensors(ctx, - ipmi.SensorFilterOptionIsSensorType(ipmi.SensorTypeFan)) - if err != nil { - return nil, fmt.Errorf("getting IPMI fan sensors: %w", err) - } - - var readings []FanReading - for _, s := range sensors { - if !s.HasAnalogReading { - continue - } - r := FanReading{Name: s.Name} - if s.SensorUnit.Percentage { - v := s.Value - r.Percent = &v - } else if s.SensorUnit.BaseUnit == ipmi.SensorUnitType_RPM { - v := s.Value - r.RPM = &v - } - readings = append(readings, r) - } - return readings, nil -} - -// SetSpeed sets the chassis fan speed to the given percentage [0,100]. -// It uses Dell OEM IPMI raw commands to enable manual fan control and set the speed. -func (c *IPMIFanController) SetSpeed(ctx context.Context, percent int) error { - if percent < 0 || percent > 100 { - return fmt.Errorf("fan speed %d out of range [0,100]", percent) - } - - client, err := c.newClient() - if err != nil { - return fmt.Errorf("creating IPMI client: %w", err) - } - if err := client.Connect(ctx); err != nil { - return fmt.Errorf("connecting to IPMI: %w", err) - } - defer func() { - _ = client.Close(ctx) - }() - - // Dell OEM: enable manual fan control - if _, err := client.RawCommand(ctx, ipmi.NetFn(0x30), 0x30, []byte{0x01, 0x00}, ""); err != nil { - return fmt.Errorf("enabling manual fan control: %w", err) - } - - // Dell OEM: set fan speed - if _, err := client.RawCommand(ctx, ipmi.NetFn(0x30), 0x30, []byte{0x02, 0xff, byte(percent)}, ""); err != nil { - return fmt.Errorf("setting fan speed to %d%%: %w", percent, err) - } - return nil -} diff --git a/fan_test.go b/fan_test.go deleted file mode 100644 index e6b255d..0000000 --- a/fan_test.go +++ /dev/null @@ -1,127 +0,0 @@ -package main - -import ( - "testing" - - ipmi "github.com/bougou/go-ipmi" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestSuggestSpeed_AtIdealTemp(t *testing.T) { - assert.Equal(t, 0, SuggestSpeed(40, 40, 75)) -} - -func TestSuggestSpeed_BelowIdealTemp(t *testing.T) { - assert.Equal(t, 0, SuggestSpeed(35, 40, 75)) -} - -func TestSuggestSpeed_AtMaxTemp(t *testing.T) { - assert.Equal(t, 100, SuggestSpeed(75, 40, 75)) -} - -func TestSuggestSpeed_AboveMaxTemp(t *testing.T) { - assert.Equal(t, 100, SuggestSpeed(90, 40, 75)) -} - -func TestSuggestSpeed_Midpoint(t *testing.T) { - // ideal=40, max=75, actual=57.5 → (17.5)^2 * (100/1225) = 25 - assert.Equal(t, 25, SuggestSpeed(57.5, 40, 75)) -} - -func TestSuggestSpeed_ThreeQuarterTemp(t *testing.T) { - // actual = 40 + 0.75*35 = 66.25 → (26.25)^2 * (100/1225) ≈ 56.25 → rounds to 56 - assert.Equal(t, 56, SuggestSpeed(66.25, 40, 75)) -} - -func TestIPMIFanController_SetSpeed(t *testing.T) { - mock := &mockIPMIClient{} - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - require.NoError(t, ctrl.SetSpeed(t.Context(), 50)) -} - -func TestIPMIFanController_SetSpeedOutOfRange(t *testing.T) { - mock := &mockIPMIClient{} - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - assert.Error(t, ctrl.SetSpeed(t.Context(), 101)) - assert.Error(t, ctrl.SetSpeed(t.Context(), -1)) -} - -func TestIPMIFanController_SetSpeedIPMIError(t *testing.T) { - mock := &mockIPMIClient{rawErr: errIPMI("raw command failed")} - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - assert.Error(t, ctrl.SetSpeed(t.Context(), 50)) -} - -func TestIPMIFanController_SetSpeedConnectError(t *testing.T) { - ctrl := &IPMIFanController{newClient: mockIPMIFactoryErr("no IPMI device")} - assert.Error(t, ctrl.SetSpeed(t.Context(), 50)) -} - -func ptr[T any](v T) *T { return &v } - -func TestIPMIFanController_ReadFanSpeeds_RPM(t *testing.T) { - mock := &mockIPMIClient{ - sensors: []*ipmi.Sensor{ - { - Name: "Fan1", - SensorType: ipmi.SensorTypeFan, - HasAnalogReading: true, - Value: 3600, - SensorUnit: ipmi.SensorUnit{BaseUnit: ipmi.SensorUnitType_RPM}, - }, - }, - } - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - readings, err := ctrl.ReadFanSpeeds(t.Context()) - require.NoError(t, err) - require.Len(t, readings, 1) - assert.Equal(t, "Fan1", readings[0].Name) - assert.Equal(t, ptr(3600.0), readings[0].RPM) - assert.Nil(t, readings[0].Percent) -} - -func TestIPMIFanController_ReadFanSpeeds_Percent(t *testing.T) { - mock := &mockIPMIClient{ - sensors: []*ipmi.Sensor{ - { - Name: "Fan1", - SensorType: ipmi.SensorTypeFan, - HasAnalogReading: true, - Value: 50, - SensorUnit: ipmi.SensorUnit{Percentage: true}, - }, - }, - } - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - readings, err := ctrl.ReadFanSpeeds(t.Context()) - require.NoError(t, err) - require.Len(t, readings, 1) - assert.Equal(t, ptr(50.0), readings[0].Percent) - assert.Nil(t, readings[0].RPM) -} - -func TestIPMIFanController_ReadFanSpeeds_SkipsDiscrete(t *testing.T) { - mock := &mockIPMIClient{ - sensors: []*ipmi.Sensor{ - {Name: "Fan1", SensorType: ipmi.SensorTypeFan, HasAnalogReading: false}, - }, - } - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - readings, err := ctrl.ReadFanSpeeds(t.Context()) - require.NoError(t, err) - assert.Empty(t, readings) -} - -func TestIPMIFanController_ReadFanSpeeds_IPMIError(t *testing.T) { - mock := &mockIPMIClient{rawErr: errIPMI("sensor read failed")} - ctrl := &IPMIFanController{newClient: mockIPMIFactory(mock)} - _, err := ctrl.ReadFanSpeeds(t.Context()) - assert.Error(t, err) -} - -func TestIPMIFanController_ReadFanSpeeds_ConnectError(t *testing.T) { - ctrl := &IPMIFanController{newClient: mockIPMIFactoryErr("no IPMI device")} - _, err := ctrl.ReadFanSpeeds(t.Context()) - assert.Error(t, err) -} diff --git a/go.mod b/go.mod deleted file mode 100644 index 5b471b5..0000000 --- a/go.mod +++ /dev/null @@ -1,38 +0,0 @@ -module frostd - -go 1.26 - -require ( - github.com/bougou/go-ipmi v0.8.3 - github.com/prometheus/client_golang v1.23.2 - github.com/stretchr/testify v1.11.1 - gopkg.in/yaml.v3 v3.0.1 -) - -require ( - github.com/beorn7/perks v1.0.1 // indirect - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/fatih/color v1.15.0 // indirect - github.com/google/uuid v1.1.2 // indirect - github.com/kr/pretty v0.3.1 // indirect - github.com/kr/text v0.2.0 // indirect - github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.19 // indirect - github.com/mattn/go-runewidth v0.0.16 // indirect - github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect - github.com/olekukonko/errors v1.1.0 // indirect - github.com/olekukonko/ll v0.0.9 // indirect - github.com/olekukonko/tablewriter v1.0.9 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.66.1 // indirect - github.com/prometheus/procfs v0.16.1 // indirect - github.com/rivo/uniseg v0.2.0 // indirect - github.com/rogpeppe/go-internal v1.10.0 // indirect - go.yaml.in/yaml/v2 v2.4.2 // indirect - golang.org/x/net v0.43.0 // indirect - golang.org/x/sys v0.35.0 // indirect - golang.org/x/term v0.34.0 // indirect - google.golang.org/protobuf v1.36.8 // indirect -) diff --git a/go.sum b/go.sum deleted file mode 100644 index 674367f..0000000 --- a/go.sum +++ /dev/null @@ -1,75 +0,0 @@ -github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bougou/go-ipmi v0.8.3 h1:jegrU+5lx5Moe/MiggLFIHCwDoVPd/BZuIOKYZS3BUY= -github.com/bougou/go-ipmi v0.8.3/go.mod h1:HWli0nfKgnBtD/3ViiDaqp6wHZogZrg5A5ctMMDUYS0= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= -github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= -github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= -github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= -github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= -github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= -github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= -github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM= -github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y= -github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI= -github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g= -github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8= -github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= -github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= -github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= -github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs= -github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA= -github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= -github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= -github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= -go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= -go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= -go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= -golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= -golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= -golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= -golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4= -golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw= -google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc= -google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/gpu.go b/gpu.go deleted file mode 100644 index 76c34dd..0000000 --- a/gpu.go +++ /dev/null @@ -1,47 +0,0 @@ -package main - -import ( - "fmt" - "strconv" - "strings" -) - -type GPUReader struct { - runner CommandRunner -} - -// ReadTemperatures returns GPU temperatures via nvidia-smi, keyed by "gpu0", "gpu1", etc. -func (r *GPUReader) ReadTemperatures() (map[string]float64, error) { - out, err := r.runner.Run("nvidia-smi", "--query-gpu=temperature.gpu", "--format=csv,noheader") - if err != nil { - return nil, fmt.Errorf("nvidia-smi: %w", err) - } - return parseGPUTemps(string(out)) -} - -// parseGPUTemps parses nvidia-smi CSV output (one temperature per line). -func parseGPUTemps(output string) (map[string]float64, error) { - temps := map[string]float64{} - for _, line := range strings.Split(strings.TrimSpace(output), "\n") { - line = strings.TrimSpace(line) - if line == "" { - continue - } - temp, err := strconv.ParseFloat(line, 64) - if err != nil { - return nil, fmt.Errorf("parsing GPU temperature %q: %w", line, err) - } - key := "Temp" - for i := 2; ; i++ { - if _, exists := temps[key]; !exists { - break - } - key = fmt.Sprintf("Temp_%d", i) - } - temps[key] = temp - } - if len(temps) == 0 { - return nil, fmt.Errorf("no GPU temperatures found in nvidia-smi output") - } - return temps, nil -} diff --git a/gpu_test.go b/gpu_test.go deleted file mode 100644 index d0113e1..0000000 --- a/gpu_test.go +++ /dev/null @@ -1,46 +0,0 @@ -package main - -import ( - "errors" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestGPUReader_ParsesSingleGPU(t *testing.T) { - temps, err := parseGPUTemps("72\n") - require.NoError(t, err) - assert.Equal(t, map[string]float64{"Temp": 72}, temps) -} - -func TestGPUReader_ParsesMultipleGPUs(t *testing.T) { - temps, err := parseGPUTemps("68\n74\n") - require.NoError(t, err) - assert.Equal(t, map[string]float64{"Temp": 68, "Temp_2": 74}, temps) -} - -func TestGPUReader_EmptyOutput(t *testing.T) { - _, err := parseGPUTemps("") - assert.Error(t, err) -} - -func TestGPUReader_InvalidLine(t *testing.T) { - _, err := parseGPUTemps("not a number\n") - assert.Error(t, err) -} - -func TestGPUReader_ReadTemperatures_CallsNvidiaSmi(t *testing.T) { - r := &mockRunner{output: []byte("72\n")} - reader := &GPUReader{runner: r} - temps, err := reader.ReadTemperatures() - require.NoError(t, err) - assert.Equal(t, map[string]float64{"Temp": 72}, temps) -} - -func TestGPUReader_ReadTemperatures_CommandError(t *testing.T) { - r := &mockRunner{err: errors.New("nvidia-smi not found")} - reader := &GPUReader{runner: r} - _, err := reader.ReadTemperatures() - assert.Error(t, err) -} diff --git a/ipmi_client.go b/ipmi_client.go deleted file mode 100644 index 422809c..0000000 --- a/ipmi_client.go +++ /dev/null @@ -1,18 +0,0 @@ -package main - -import ( - "context" - - ipmi "github.com/bougou/go-ipmi" -) - -type ipmiClient interface { - Connect(ctx context.Context) error - Close(ctx context.Context) error - GetSensors(ctx context.Context, opts ...ipmi.SensorFilterOption) ([]*ipmi.Sensor, error) - RawCommand(ctx context.Context, netFn ipmi.NetFn, cmd uint8, data []byte, name string) (*ipmi.CommandRawResponse, error) -} - -func newRealIPMIClient() (ipmiClient, error) { - return ipmi.NewOpenClient() -} diff --git a/main.go b/main.go deleted file mode 100644 index c4114a4..0000000 --- a/main.go +++ /dev/null @@ -1,102 +0,0 @@ -package main - -import ( - "context" - "flag" - "fmt" - "io" - "log/slog" - "os" - "os/signal" - "path/filepath" - "syscall" -) - -const version = "0.1.0" - -type args struct { - configPath string - showVersion bool -} - -func parseArgs() args { - configPath := flag.String("c", "/etc/frostd.yaml", "path to config file") - showVersion := flag.Bool("version", false, "print version and exit") - flag.Parse() - return args{configPath: *configPath, showVersion: *showVersion} -} - -func main() { - a := parseArgs() - - if a.showVersion { - fmt.Println(version) - return - } - - cfg, err := loadConfig(a.configPath) - if err != nil { - fmt.Fprintf(os.Stderr, "frostd: configuration error: %v\n", err) - os.Exit(1) - } - - logger, closer, err := setupLogger(cfg.LogFile, cfg.LogFormat) - if err != nil { - fmt.Fprintf(os.Stderr, "frostd: failed to open log file: %v\n", err) - os.Exit(1) - } - defer closer() - - fanCtrl := &IPMIFanController{newClient: newRealIPMIClient} - - var monitors []*SensorMonitor - if cfg.CPU != nil { - monitors = append(monitors, newSensorMonitor("cpu", cfg.CPU, &CPUReader{newClient: newRealIPMIClient})) - } - if cfg.GPU != nil { - monitors = append(monitors, newSensorMonitor("gpu", cfg.GPU, &GPUReader{runner: RealRunner{}})) - } - - ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) - defer stop() - - svc := &Service{ - cfg: cfg, - fanCtrl: fanCtrl, - monitors: monitors, - logger: logger, - prom: newPrometheusMetrics(), - } - if cfg.Prometheus != nil && cfg.Prometheus.ListenAddr != "" { - startPrometheusServer(ctx, cfg.Prometheus.ListenAddr, svc.prom, logger) - } - - logger.Info("frostd started", "config", a.configPath, "dry_run", cfg.DryRun) - svc.run(ctx) - logger.Info("frostd stopping") -} - -func setupLogger(logFile, logFormat string) (*slog.Logger, func(), error) { - var w io.Writer = os.Stdout - closer := func() {} - - if logFile != "" { - if err := os.MkdirAll(filepath.Dir(logFile), 0o755); err != nil { - return nil, nil, err - } - f, err := os.OpenFile(logFile, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644) - if err != nil { - return nil, nil, err - } - w = f - closer = func() { _ = f.Close() } - } - - var handler slog.Handler - if logFormat == "json" { - handler = slog.NewJSONHandler(w, nil) - } else { - handler = slog.NewTextHandler(w, nil) - } - return slog.New(handler), closer, nil -} diff --git a/metrics.go b/metrics.go deleted file mode 100644 index 7c1e8ed..0000000 --- a/metrics.go +++ /dev/null @@ -1,58 +0,0 @@ -package main - -import "fmt" - -type TempReader interface { - ReadTemperatures() (map[string]float64, error) -} - -type SensorMonitor struct { - name string - cfg *SensorConfig - reader TempReader - samples map[string][]float64 -} - -func newSensorMonitor(name string, cfg *SensorConfig, reader TempReader) *SensorMonitor { - return &SensorMonitor{ - name: name, - cfg: cfg, - reader: reader, - samples: map[string][]float64{}, - } -} - -// Poll reads current temperatures and updates per-sensor-ID rolling sample buffers. -// Returns the latest readings keyed by sensor ID, the rolling aggregate per sensor -// ID, and any error. -func (m *SensorMonitor) Poll() (map[string]float64, map[string]float64, error) { - temps, err := m.reader.ReadTemperatures() - if err != nil { - return nil, nil, fmt.Errorf("%s: reading temperatures: %w", m.name, err) - } - if len(temps) == 0 { - return nil, nil, fmt.Errorf("%s: no temperature readings returned", m.name) - } - - for id, t := range temps { - m.samples[id] = append(m.samples[id], t) - if len(m.samples[id]) > m.cfg.SampleSize { - m.samples[id] = m.samples[id][len(m.samples[id])-m.cfg.SampleSize:] - } - } - - return temps, m.Aggregates(), nil -} - -// Aggregates returns the rolling average for each sensor ID. -func (m *SensorMonitor) Aggregates() map[string]float64 { - result := make(map[string]float64, len(m.samples)) - for id, samples := range m.samples { - var sum float64 - for _, s := range samples { - sum += s - } - result[id] = sum / float64(len(samples)) - } - return result -} diff --git a/metrics_test.go b/metrics_test.go deleted file mode 100644 index a2c0c3c..0000000 --- a/metrics_test.go +++ /dev/null @@ -1,89 +0,0 @@ -package main - -import ( - "errors" - "testing" - "time" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -type staticReader struct { - temps map[string]float64 - err error -} - -func (r *staticReader) ReadTemperatures() (map[string]float64, error) { - return r.temps, r.err -} - -func testSensorConfig() *SensorConfig { - return &SensorConfig{ - IdealTemp: 40, - MaxTemp: 75, - SampleSize: 3, - SampleInterval: 15 * time.Second, - } -} - -func TestSensorMonitor_AccumulatesSamples(t *testing.T) { - reader := &staticReader{temps: map[string]float64{"s0": 50, "s1": 60}} - m := newSensorMonitor("cpu", testSensorConfig(), reader) - temps, aggs, err := m.Poll() - require.NoError(t, err) - assert.Equal(t, map[string]float64{"s0": 50, "s1": 60}, temps) - assert.Len(t, m.samples, 2) - assert.Equal(t, map[string]float64{"s0": 50.0, "s1": 60.0}, aggs) -} - -func TestSensorMonitor_CapsSamplesAtSampleSize(t *testing.T) { - cfg := testSensorConfig() - cfg.SampleSize = 3 - reader := &staticReader{temps: map[string]float64{"s0": 0}} - m := newSensorMonitor("cpu", cfg, reader) - - for i := 0; i < 5; i++ { - reader.temps = map[string]float64{"s0": float64(i * 10)} - _, _, err := m.Poll() - require.NoError(t, err) - } - assert.Len(t, m.samples["s0"], 3) - // last 3 polls: 20, 30, 40 - assert.Equal(t, (20.0+30.0+40.0)/3, m.Aggregates()["s0"]) -} - -func TestSensorMonitor_AggregatesBeforeAnyPolls(t *testing.T) { - m := newSensorMonitor("cpu", testSensorConfig(), &staticReader{temps: map[string]float64{"s0": 50}}) - assert.Empty(t, m.Aggregates()) -} - -func TestSensorMonitor_ReaderError(t *testing.T) { - reader := &staticReader{err: errors.New("ipmitool failed")} - m := newSensorMonitor("cpu", testSensorConfig(), reader) - _, _, err := m.Poll() - assert.Error(t, err) -} - -func TestSensorMonitor_EmptyReadings(t *testing.T) { - reader := &staticReader{temps: map[string]float64{}} - m := newSensorMonitor("cpu", testSensorConfig(), reader) - _, _, err := m.Poll() - assert.Error(t, err) -} - -func TestSensorMonitor_MultipleSensorIDsHaveIndependentAggregates(t *testing.T) { - cfg := testSensorConfig() - cfg.SampleSize = 2 - reader := &staticReader{temps: map[string]float64{"s0": 50, "s1": 70}} - m := newSensorMonitor("cpu", cfg, reader) - - _, _, err := m.Poll() - require.NoError(t, err) - reader.temps = map[string]float64{"s0": 60, "s1": 80} - _, aggs, err := m.Poll() - require.NoError(t, err) - - assert.Equal(t, (50.0+60.0)/2, aggs["s0"]) - assert.Equal(t, (70.0+80.0)/2, aggs["s1"]) -} diff --git a/packaging/debian/control b/packaging/debian/control index 133067e..d796849 100644 --- a/packaging/debian/control +++ b/packaging/debian/control @@ -4,6 +4,7 @@ Section: utils Priority: optional Architecture: amd64 Maintainer: Shawn Poulson +Depends: libfreeipmi17 | libfreeipmi-dev, libipmimonitoring6 | libipmimonitoring-dev, libcyaml1, libmicrohttpd12 | libmicrohttpd12t64 Description: Dell PowerEdge fan speed regulator frostd dynamically regulates fan speeds on Dell PowerEdge 12th generation servers based on CPU and GPU temperature metrics read via IPMI and nvidia-smi. diff --git a/prometheus.go b/prometheus.go deleted file mode 100644 index f28570f..0000000 --- a/prometheus.go +++ /dev/null @@ -1,80 +0,0 @@ -package main - -import ( - "context" - "log/slog" - "net/http" - - "github.com/prometheus/client_golang/prometheus" - "github.com/prometheus/client_golang/prometheus/promhttp" -) - -type PrometheusMetrics struct { - sensorTemp *prometheus.GaugeVec - aggregateTemp *prometheus.GaugeVec - suggestedSpeed *prometheus.GaugeVec - fanSpeedRPM *prometheus.GaugeVec - fanSpeedPercent *prometheus.GaugeVec - systemSpeed prometheus.Gauge - registry *prometheus.Registry -} - -func newPrometheusMetrics() *PrometheusMetrics { - reg := prometheus.NewRegistry() - m := &PrometheusMetrics{ - sensorTemp: prometheus.NewGaugeVec(prometheus.GaugeOpts{ - Name: "frostd_sensor_temperature", - Help: "Current temperature reading per sensor, in Celsius.", - }, []string{"sensor", "id"}), - aggregateTemp: prometheus.NewGaugeVec(prometheus.GaugeOpts{ - Name: "frostd_sensor_aggregate_temperature", - Help: "Rolling aggregate temperature per sensor type, in Celsius.", - }, []string{"sensor", "id"}), - suggestedSpeed: prometheus.NewGaugeVec(prometheus.GaugeOpts{ - Name: "frostd_suggested_fan_speed_percent", - Help: "Suggested fan speed percentage per sensor type.", - }, []string{"sensor"}), - fanSpeedRPM: prometheus.NewGaugeVec(prometheus.GaugeOpts{ - Name: "frostd_actual_fan_rpm", - Help: "Actual fan speed in RPM.", - }, []string{"fan"}), - fanSpeedPercent: prometheus.NewGaugeVec(prometheus.GaugeOpts{ - Name: "frostd_actual_fan_speed_percent", - Help: "Actual fan speed as percentage.", - }, []string{"fan"}), - systemSpeed: prometheus.NewGauge(prometheus.GaugeOpts{ - Name: "frostd_system_fan_speed_percent", - Help: "Commanded system fan speed percentage.", - }), - registry: reg, - } - reg.MustRegister( - m.sensorTemp, - m.aggregateTemp, - m.suggestedSpeed, - m.fanSpeedRPM, - m.fanSpeedPercent, - m.systemSpeed, - ) - return m -} - -func startPrometheusServer(ctx context.Context, addr string, m *PrometheusMetrics, logger *slog.Logger) { - mux := http.NewServeMux() - mux.Handle("/metrics", promhttp.HandlerFor(m.registry, promhttp.HandlerOpts{})) - srv := &http.Server{Addr: addr, Handler: mux} - - go func() { - <-ctx.Done() - if err := srv.Shutdown(context.Background()); err != nil { - logger.Error("prometheus server shutdown error", "error", err) - } - }() - - go func() { - logger.Info("prometheus metrics server listening", "addr", addr) - if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { - logger.Error("prometheus metrics server error", "error", err) - } - }() -} diff --git a/service.go b/service.go deleted file mode 100644 index 21a620f..0000000 --- a/service.go +++ /dev/null @@ -1,144 +0,0 @@ -package main - -import ( - "context" - "log/slog" - "time" -) - -type speedUpdate struct { - sensor string - speed int -} - -type Service struct { - cfg *Config - fanCtrl FanController - monitors []*SensorMonitor - logger *slog.Logger - prom *PrometheusMetrics -} - -func (s *Service) run(ctx context.Context) { - prevFanReadings := map[string]FanReading{} - s.logFanSpeeds(ctx, prevFanReadings) - - speedCh := make(chan speedUpdate, len(s.monitors)) - latestSpeeds := make(map[string]int, len(s.monitors)) - for _, m := range s.monitors { - latestSpeeds[m.name] = 0 - go s.runSensor(ctx, m, speedCh) - } - - fanLogTicker := time.NewTicker(s.cfg.FanLogInterval) - defer fanLogTicker.Stop() - pendingUpdate := false - lastSpeed := -1 - - for { - select { - case <-ctx.Done(): - return - case <-fanLogTicker.C: - s.logFanSpeeds(ctx, prevFanReadings) - case update := <-speedCh: - latestSpeeds[update.sensor] = update.speed - pendingUpdate = true - } - - if !pendingUpdate { - continue - } - - pendingUpdate = false - maxSpeed := 0 - for _, s := range latestSpeeds { - if s > maxSpeed { - maxSpeed = s - } - } - if maxSpeed == lastSpeed { - continue - } - lastSpeed = maxSpeed - - s.prom.systemSpeed.Set(float64(maxSpeed)) - - if s.cfg.DryRun { - s.logger.Info("dry run: skipping fan speed change", "system_percent", maxSpeed) - continue - } - - s.logger.Info("setting fan speed", "system_percent", maxSpeed) - if err := s.fanCtrl.SetSpeed(ctx, maxSpeed); err != nil { - s.logger.Error("failed to set fan speed", "error", err) - } - } -} - -func (s *Service) runSensor(ctx context.Context, m *SensorMonitor, ch chan<- speedUpdate) { - nextTick := time.Now() - for { - nextTick = nextTick.Add(m.cfg.SampleInterval) - - temps, aggs, err := m.Poll() - if err != nil { - s.logger.Error("sensor temperature poll failed", "sensor", m.name, "error", err) - } else { - s.logger.Info("sensor temperature", "sensor", m.name, "latest_temps", temps, "aggregate_temps", aggs) - var maxAgg float64 - for _, a := range aggs { - if a > maxAgg { - maxAgg = a - } - } - speed := SuggestSpeed(maxAgg, m.cfg.IdealTemp, m.cfg.MaxTemp) - s.logger.Info("sensor suggested fan speed", "sensor", m.name, "suggest_percent", speed) - for id, t := range temps { - s.prom.sensorTemp.WithLabelValues(m.name, id).Set(t) - } - for id, a := range aggs { - s.prom.aggregateTemp.WithLabelValues(m.name, id).Set(a) - } - s.prom.suggestedSpeed.WithLabelValues(m.name).Set(float64(speed)) - select { - case ch <- speedUpdate{sensor: m.name, speed: speed}: - case <-ctx.Done(): - return - } - } - - delay := time.Until(nextTick) - if delay < 0 { - delay = 0 - } - select { - case <-ctx.Done(): - return - case <-time.After(delay): - } - } -} - -func (s *Service) logFanSpeeds(ctx context.Context, prev map[string]FanReading) { - readings, err := s.fanCtrl.ReadFanSpeeds(ctx) - if err != nil { - s.logger.Error("failed to read current fan speeds", "error", err) - return - } - for _, r := range readings { - args := []any{"fan", r.Name} - if r.RPM != nil { - args = append(args, "rpm", int(*r.RPM)) - if p, ok := prev[r.Name]; ok && p.RPM != nil { - args = append(args, "delta", int(*r.RPM-*p.RPM)) - } - s.prom.fanSpeedRPM.WithLabelValues(r.Name).Set(*r.RPM) - } - if r.Percent != nil { - s.prom.fanSpeedPercent.WithLabelValues(r.Name).Set(*r.Percent) - } - s.logger.Info("current fan speed", args...) - prev[r.Name] = r - } -} diff --git a/src/config.c b/src/config.c new file mode 100644 index 0000000..3cb2a77 --- /dev/null +++ b/src/config.c @@ -0,0 +1,223 @@ +#include "config.h" + +#include +#include +#include +#include +#include + +/* ---------- libcyaml schemas ---------- */ + +static const cyaml_schema_field_t prometheus_fields[] = { + CYAML_FIELD_STRING_PTR("listen_addr", CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + prometheus_config_t, listen_addr, 0, CYAML_UNLIMITED), + CYAML_FIELD_END +}; + +static const cyaml_schema_field_t sensor_fields[] = { + CYAML_FIELD_FLOAT("ideal_temp", CYAML_FLAG_OPTIONAL, sensor_config_t, ideal_temp), + CYAML_FIELD_FLOAT("max_temp", CYAML_FLAG_OPTIONAL, sensor_config_t, max_temp), + CYAML_FIELD_INT("sample_size", CYAML_FLAG_OPTIONAL, sensor_config_t, sample_size), + CYAML_FIELD_STRING_PTR("sample_interval", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + sensor_config_t, sample_interval, 0, CYAML_UNLIMITED), + CYAML_FIELD_END +}; + +static const cyaml_schema_field_t config_fields[] = { + CYAML_FIELD_STRING_PTR("log_file", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + frostd_config_t, log_file, 0, CYAML_UNLIMITED), + CYAML_FIELD_STRING_PTR("log_format", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + frostd_config_t, log_format, 0, CYAML_UNLIMITED), + CYAML_FIELD_BOOL("dry_run", CYAML_FLAG_OPTIONAL, frostd_config_t, dry_run), + CYAML_FIELD_STRING_PTR("fan_log_interval", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + frostd_config_t, fan_log_interval, 0, CYAML_UNLIMITED), + CYAML_FIELD_MAPPING_PTR("prometheus", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + frostd_config_t, prometheus, prometheus_fields), + CYAML_FIELD_MAPPING_PTR("cpu", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + frostd_config_t, cpu, sensor_fields), + CYAML_FIELD_MAPPING_PTR("gpu", + CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL, + frostd_config_t, gpu, sensor_fields), + CYAML_FIELD_END +}; + +static const cyaml_schema_value_t config_schema = { + CYAML_VALUE_MAPPING(CYAML_FLAG_POINTER, frostd_config_t, config_fields) +}; + +static const cyaml_config_t cyaml_cfg = { + .log_fn = cyaml_log, + .mem_fn = cyaml_mem, + .log_level = CYAML_LOG_WARNING, +}; + +/* ---------- duration parser ---------- */ + +int parse_duration(const char *s, double *seconds_out) { + if (!s || !*s) return -1; + + char *end; + double val = strtod(s, &end); + if (end == s || val < 0) return -1; + + /* skip optional whitespace */ + while (isspace((unsigned char)*end)) end++; + + if (*end == '\0' || strcmp(end, "s") == 0) { + *seconds_out = val; + } else if (strcmp(end, "m") == 0) { + *seconds_out = val * 60.0; + } else if (strcmp(end, "h") == 0) { + *seconds_out = val * 3600.0; + } else if (strcmp(end, "ms") == 0) { + *seconds_out = val / 1000.0; + } else { + return -1; + } + return 0; +} + +/* ---------- defaults ---------- */ + +static void apply_sensor_defaults(sensor_config_t *s) { + if (s->ideal_temp == 0.0) s->ideal_temp = 40.0; + if (s->max_temp == 0.0) s->max_temp = 75.0; + if (s->sample_size == 0) s->sample_size = 3; + if (!s->sample_interval) { + s->sample_interval = strdup("15s"); + s->sample_interval_sec = 15.0; + } +} + +static int apply_defaults(frostd_config_t *cfg, char *errbuf, int errbuflen) { + if (!cfg->log_format) cfg->log_format = strdup("text"); + + if (!cfg->fan_log_interval) { + cfg->fan_log_interval = strdup("15s"); + cfg->fan_log_interval_sec = 15.0; + } else { + if (parse_duration(cfg->fan_log_interval, &cfg->fan_log_interval_sec) != 0) { + snprintf(errbuf, errbuflen, + "fan_log_interval: invalid duration %s", cfg->fan_log_interval); + return -1; + } + } + + if (cfg->cpu) { + apply_sensor_defaults(cfg->cpu); + if (cfg->cpu->sample_interval_sec == 0.0) { + if (parse_duration(cfg->cpu->sample_interval, + &cfg->cpu->sample_interval_sec) != 0) { + snprintf(errbuf, errbuflen, "cpu.sample_interval: invalid duration %s", + cfg->cpu->sample_interval); + return -1; + } + } + } + if (cfg->gpu) { + apply_sensor_defaults(cfg->gpu); + if (cfg->gpu->sample_interval_sec == 0.0) { + if (parse_duration(cfg->gpu->sample_interval, + &cfg->gpu->sample_interval_sec) != 0) { + snprintf(errbuf, errbuflen, "gpu.sample_interval: invalid duration %s", + cfg->gpu->sample_interval); + return -1; + } + } + } + return 0; +} + +/* ---------- validation ---------- */ + +static int validate_sensor(const char *name, const sensor_config_t *s, + char *errbuf, int errbuflen) { + if (s->ideal_temp <= 0.0) { + snprintf(errbuf, errbuflen, "%s: ideal_temp must be positive, got %.1f", + name, s->ideal_temp); + return -1; + } + if (s->max_temp <= 0.0) { + snprintf(errbuf, errbuflen, "%s: max_temp must be positive, got %.1f", + name, s->max_temp); + return -1; + } + if (s->ideal_temp >= s->max_temp) { + snprintf(errbuf, errbuflen, + "%s: ideal_temp (%.1f) must be less than max_temp (%.1f)", + name, s->ideal_temp, s->max_temp); + return -1; + } + if (s->sample_size < 1) { + snprintf(errbuf, errbuflen, "%s: sample_size must be at least 1, got %d", + name, s->sample_size); + return -1; + } + if (s->sample_interval_sec <= 0.0) { + snprintf(errbuf, errbuflen, "%s: sample_interval must be positive", + name); + return -1; + } + return 0; +} + +int config_validate(const frostd_config_t *cfg, char *errbuf, int errbuflen) { + if (!cfg->cpu && !cfg->gpu) { + snprintf(errbuf, errbuflen, + "config must enable at least one sensor type (cpu or gpu)"); + return -1; + } + if (strcmp(cfg->log_format, "text") != 0 && + strcmp(cfg->log_format, "json") != 0) { + snprintf(errbuf, errbuflen, + "log_format must be \"text\" or \"json\", got \"%s\"", + cfg->log_format); + return -1; + } + if (cfg->fan_log_interval_sec <= 0.0) { + snprintf(errbuf, errbuflen, "fan_log_interval must be positive"); + return -1; + } + if (cfg->cpu && validate_sensor("cpu", cfg->cpu, errbuf, errbuflen) != 0) + return -1; + if (cfg->gpu && validate_sensor("gpu", cfg->gpu, errbuf, errbuflen) != 0) + return -1; + return 0; +} + +/* ---------- public API ---------- */ + +int config_load(const char *path, frostd_config_t **cfg_out, + char *errbuf, int errbuflen) { + frostd_config_t *cfg = NULL; + cyaml_err_t err = cyaml_load_file(path, &cyaml_cfg, &config_schema, + (cyaml_data_t **)&cfg, NULL); + if (err != CYAML_OK) { + snprintf(errbuf, errbuflen, "parsing config file: %s", + cyaml_strerror(err)); + return -1; + } + + if (apply_defaults(cfg, errbuf, errbuflen) != 0) { + cyaml_free(&cyaml_cfg, &config_schema, cfg, 0); + return -1; + } + if (config_validate(cfg, errbuf, errbuflen) != 0) { + cyaml_free(&cyaml_cfg, &config_schema, cfg, 0); + return -1; + } + + *cfg_out = cfg; + return 0; +} + +void config_free(frostd_config_t *cfg) { + if (!cfg) return; + cyaml_free(&cyaml_cfg, &config_schema, cfg, 0); +} diff --git a/src/config.h b/src/config.h new file mode 100644 index 0000000..5e133fc --- /dev/null +++ b/src/config.h @@ -0,0 +1,43 @@ +#ifndef FROSTD_CONFIG_H +#define FROSTD_CONFIG_H + +#include + +typedef struct { + char *listen_addr; +} prometheus_config_t; + +typedef struct { + double ideal_temp; + double max_temp; + int sample_size; + char *sample_interval; /* duration string e.g. "15s", parsed to seconds */ + double sample_interval_sec; /* set by config_load, not from YAML */ +} sensor_config_t; + +typedef struct { + char *log_file; + char *log_format; + bool dry_run; + char *fan_log_interval; /* duration string */ + double fan_log_interval_sec; /* set by config_load */ + prometheus_config_t *prometheus; + sensor_config_t *cpu; + sensor_config_t *gpu; +} frostd_config_t; + +/* + * Load, parse, apply defaults, and validate the config at path. + * On success returns 0 and sets *cfg_out (caller must call config_free). + * On error returns -1 and sets errbuf to a descriptive message. + */ +int config_load(const char *path, frostd_config_t **cfg_out, + char *errbuf, int errbuflen); + +void config_free(frostd_config_t *cfg); + +/* Exposed for testing */ +int parse_duration(const char *s, double *seconds_out); +int config_validate(const frostd_config_t *cfg, char *errbuf, int errbuflen); + +#endif /* FROSTD_CONFIG_H */ diff --git a/src/cpu.c b/src/cpu.c new file mode 100644 index 0000000..54d685f --- /dev/null +++ b/src/cpu.c @@ -0,0 +1,99 @@ +#include "cpu.h" + +#include +#include +#include + +/* Entity ID 0x03 = Processor, per IPMI platform management spec. + * libipmimonitoring doesn't expose entity IDs directly; we rely on the + * sensor name to identify CPU packages. Dell PowerEdge CPU temperature + * sensors are named "Temp" (single CPU) or "Temp" / "Temp_2" etc. + * (multi-CPU), with entity ID 0x03. Non-CPU temp sensors (inlet, exhaust) + * use entity IDs like 0x07 (system board), 0x40 (OEM). + * + * Since libipmimonitoring does not surface entity IDs in the iterator + * API, we read all temperature sensors here and apply an allow-list filter + * based on the sensor name patterns used by Dell PowerEdge 12th-gen BIOS. + * + * If in the future entity-ID filtering is needed, the record IDs approach + * via ipmi_monitoring_sensor_readings_by_record_id can be substituted. + */ + +/* Dell PowerEdge 12G CPU temp sensor name prefixes */ +static const char *cpu_sensor_prefixes[] = { + "Temp", + "CPU", + NULL, +}; + +static int is_cpu_sensor(const char *name) { + for (int i = 0; cpu_sensor_prefixes[i]; i++) { + if (strncmp(name, cpu_sensor_prefixes[i], + strlen(cpu_sensor_prefixes[i])) == 0) + return 1; + } + return 0; +} + +cpu_reader_t *cpu_reader_new(ipmi_ops_t *ops) { + cpu_reader_t *r = malloc(sizeof(*r)); + if (!r) return NULL; + r->ops = ops; + return r; +} + +void cpu_reader_free(cpu_reader_t *r) { + free(r); +} + +int cpu_read_temperatures(void *ctx, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen) { + cpu_reader_t *r = ctx; + + if (r->ops->connect(r->ops->impl) != 0) { + snprintf(errbuf, errbuflen, "connecting to IPMI: %s", + r->ops->last_error(r->ops->impl)); + return -1; + } + + temp_sensor_raw_t raw[IPMI_MAX_SENSORS]; + int n = r->ops->get_temp_sensors(r->ops->impl, raw, IPMI_MAX_SENSORS); + r->ops->close(r->ops->impl); + + if (n < 0) { + snprintf(errbuf, errbuflen, "getting IPMI temperature sensors: %s", + r->ops->last_error(r->ops->impl)); + return -1; + } + + int count = 0; + for (int i = 0; i < n && count < max; i++) { + if (!is_cpu_sensor(raw[i].name)) continue; + + /* Deduplicate: if name already used, append _2, _3, … */ + char key[64]; + strncpy(key, raw[i].name, sizeof(key) - 1); + key[sizeof(key) - 1] = '\0'; + + for (int suffix = 2; ; suffix++) { + int dup = 0; + for (int j = 0; j < count; j++) { + if (strcmp(out_ids[j], key) == 0) { dup = 1; break; } + } + if (!dup) break; + snprintf(key, sizeof(key), "%.50s_%d", raw[i].name, suffix); + } + + strncpy(out_ids[count], key, 64); + out_ids[count][63] = '\0'; + out_temps[count] = raw[i].value; + count++; + } + + if (count == 0) { + snprintf(errbuf, errbuflen, "no CPU temperature sensors found"); + return -1; + } + return count; +} diff --git a/src/cpu.h b/src/cpu.h new file mode 100644 index 0000000..4a22073 --- /dev/null +++ b/src/cpu.h @@ -0,0 +1,27 @@ +#ifndef FROSTD_CPU_H +#define FROSTD_CPU_H + +#include "ipmi.h" +#include "metrics.h" + +/* + * CPU temperature reader backed by IPMI. + * Reads temperature sensors with entity ID 0x03 (processor). + */ +typedef struct { + ipmi_ops_t *ops; +} cpu_reader_t; + +cpu_reader_t *cpu_reader_new(ipmi_ops_t *ops); +void cpu_reader_free(cpu_reader_t *r); + +/* temp_reader_t callback — use cpu_reader_make_reader() to wrap */ +int cpu_read_temperatures(void *ctx, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen); + +static inline temp_reader_t cpu_reader_make_reader(cpu_reader_t *r) { + return (temp_reader_t){cpu_read_temperatures, r}; +} + +#endif /* FROSTD_CPU_H */ diff --git a/src/fan.c b/src/fan.c new file mode 100644 index 0000000..c38139d --- /dev/null +++ b/src/fan.c @@ -0,0 +1,97 @@ +#include "fan.h" +#include "ipmi.h" + +#include +#include +#include + +int suggest_speed(double actual_temp, double ideal_temp, double max_temp) { + if (actual_temp <= ideal_temp) return 0; + double delta1 = actual_temp - ideal_temp; + double delta2 = max_temp - ideal_temp; + double speed = (delta1 * delta1) * (100.0 / (delta2 * delta2)); + if (speed > 100.0) return 100; + return (int)round(speed); +} + +int fan_read_speeds(fan_controller_t *c, + fan_reading_t *out, int max, + char *errbuf, int errbuflen) { + if (!c || !c->ops) { + snprintf(errbuf, errbuflen, "fan controller not initialised"); + return -1; + } + + if (c->ops->connect(c->ops->impl) != 0) { + snprintf(errbuf, errbuflen, "connecting to IPMI: %s", + c->ops->last_error(c->ops->impl)); + return -1; + } + + fan_reading_raw_t raw[IPMI_MAX_SENSORS]; + int n = c->ops->get_fan_sensors(c->ops->impl, raw, IPMI_MAX_SENSORS); + c->ops->close(c->ops->impl); + + if (n < 0) { + snprintf(errbuf, errbuflen, "getting IPMI fan sensors: %s", + c->ops->last_error(c->ops->impl)); + return -1; + } + + int count = (n < max) ? n : max; + for (int i = 0; i < count; i++) { + strncpy(out[i].name, raw[i].name, sizeof(out[i].name) - 1); + out[i].name[sizeof(out[i].name) - 1] = '\0'; + out[i].rpm.valid = raw[i].has_rpm; + out[i].rpm.value = raw[i].rpm; + out[i].percent.valid = raw[i].has_percent; + out[i].percent.value = raw[i].percent; + } + return count; +} + +int fan_set_speed(fan_controller_t *c, int percent, + char *errbuf, int errbuflen) { + if (percent < 0 || percent > 100) { + snprintf(errbuf, errbuflen, "fan speed %d out of range [0,100]", percent); + return -1; + } + if (!c || !c->ops) { + snprintf(errbuf, errbuflen, "fan controller not initialised"); + return -1; + } + + if (c->ops->connect(c->ops->impl) != 0) { + snprintf(errbuf, errbuflen, "connecting to IPMI: %s", + c->ops->last_error(c->ops->impl)); + return -1; + } + + /* Dell OEM: enable manual fan control */ + uint8_t enable_data[] = {0x01, 0x00}; + uint8_t resp[16]; + int resp_len = (int)sizeof(resp); + if (c->ops->raw_command(c->ops->impl, 0x30, 0x30, + enable_data, (int)sizeof(enable_data), + resp, &resp_len) != 0) { + c->ops->close(c->ops->impl); + snprintf(errbuf, errbuflen, "enabling manual fan control: %s", + c->ops->last_error(c->ops->impl)); + return -1; + } + + /* Dell OEM: set fan speed */ + uint8_t speed_data[] = {0x02, 0xff, (uint8_t)percent}; + resp_len = (int)sizeof(resp); + if (c->ops->raw_command(c->ops->impl, 0x30, 0x30, + speed_data, (int)sizeof(speed_data), + resp, &resp_len) != 0) { + c->ops->close(c->ops->impl); + snprintf(errbuf, errbuflen, "setting fan speed to %d%%: %s", + percent, c->ops->last_error(c->ops->impl)); + return -1; + } + + c->ops->close(c->ops->impl); + return 0; +} diff --git a/src/fan.h b/src/fan.h new file mode 100644 index 0000000..b3d4275 --- /dev/null +++ b/src/fan.h @@ -0,0 +1,46 @@ +#ifndef FROSTD_FAN_H +#define FROSTD_FAN_H + +#include + +/* Optional float value — present if valid != 0 */ +typedef struct { + double value; + int valid; +} opt_double_t; + +typedef struct { + char name[64]; + opt_double_t rpm; + opt_double_t percent; +} fan_reading_t; + +typedef struct ipmi_ops ipmi_ops_t; /* forward declared in ipmi.h */ + +typedef struct { + ipmi_ops_t *ops; +} fan_controller_t; + +/* + * Compute fan speed [0,100] using the parabolic easing curve. + * Returns 0 if actual_temp <= ideal_temp, 100 if at or above max_temp. + */ +int suggest_speed(double actual_temp, double ideal_temp, double max_temp); + +/* + * Read current fan speeds from IPMI sensors. + * out must point to an array of max fan_reading_t. + * Returns number of readings on success, -1 on error. + */ +int fan_read_speeds(fan_controller_t *c, + fan_reading_t *out, int max, + char *errbuf, int errbuflen); + +/* + * Set chassis fan speed [0,100] via Dell OEM IPMI raw commands. + * Returns 0 on success, -1 on error. + */ +int fan_set_speed(fan_controller_t *c, int percent, + char *errbuf, int errbuflen); + +#endif /* FROSTD_FAN_H */ diff --git a/src/gpu.c b/src/gpu.c new file mode 100644 index 0000000..b7ca5d8 --- /dev/null +++ b/src/gpu.c @@ -0,0 +1,121 @@ +#include "gpu.h" + +#include +#include +#include +#include + +/* ---- popen-based real runner ---- */ + +static int real_run(void *ctx, + const char *prog, const char *const *args, + char *buf, int buflen, char *errbuf, int errbuflen) { + (void)ctx; + + /* Build the command string */ + char cmd[1024] = {0}; + int pos = 0; + pos += snprintf(cmd + pos, sizeof(cmd) - pos, "%s", prog); + for (int i = 0; args && args[i]; i++) + pos += snprintf(cmd + pos, sizeof(cmd) - pos, " %s", args[i]); + + FILE *fp = popen(cmd, "r"); + if (!fp) { + snprintf(errbuf, errbuflen, "popen(%s) failed", prog); + return -1; + } + + int n = (int)fread(buf, 1, buflen - 1, fp); + buf[n < 0 ? 0 : n] = '\0'; + int rc = pclose(fp); + if (rc != 0) { + snprintf(errbuf, errbuflen, "%s exited with status %d", prog, rc); + return -1; + } + return n; +} + +cmd_runner_t cmd_runner_real(void) { + return (cmd_runner_t){real_run, NULL}; +} + +/* ---- parse_gpu_temps ---- */ + +int parse_gpu_temps(const char *output, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen) { + if (!output || !*output) { + snprintf(errbuf, errbuflen, "no GPU temperatures found in nvidia-smi output"); + return -1; + } + + int count = 0; + const char *p = output; + + while (*p && count < max) { + /* skip leading whitespace / blank lines */ + while (*p && (isspace((unsigned char)*p)) && *p != '\n') p++; + if (*p == '\n') { p++; continue; } + if (!*p) break; + + /* read one number */ + char *end; + double temp = strtod(p, &end); + if (end == p) { + snprintf(errbuf, errbuflen, "parsing GPU temperature: unexpected token"); + return -1; + } + + /* advance to end of line */ + while (*end && *end != '\n') end++; + if (*end == '\n') end++; + + /* check trailing junk on the same line was just whitespace */ + const char *check = p + (end - p); + (void)check; + + if (count == 0) { + strncpy(out_ids[0], "Temp", 64); + } else { + snprintf(out_ids[count], 64, "Temp_%d", count + 1); + } + out_temps[count] = temp; + count++; + p = end; + } + + if (count == 0) { + snprintf(errbuf, errbuflen, "no GPU temperatures found in nvidia-smi output"); + return -1; + } + return count; +} + +/* ---- gpu_reader_t ---- */ + +gpu_reader_t *gpu_reader_new(cmd_runner_t runner) { + gpu_reader_t *r = malloc(sizeof(*r)); + if (!r) return NULL; + r->runner = runner; + return r; +} + +void gpu_reader_free(gpu_reader_t *r) { + free(r); +} + +int gpu_read_temperatures(void *ctx, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen) { + gpu_reader_t *r = ctx; + char buf[4096]; + const char *args[] = { + "--query-gpu=temperature.gpu", + "--format=csv,noheader", + NULL, + }; + int n = r->runner.run(r->runner.ctx, "nvidia-smi", args, + buf, sizeof(buf), errbuf, errbuflen); + if (n < 0) return -1; + return parse_gpu_temps(buf, out_ids, out_temps, max, errbuf, errbuflen); +} diff --git a/src/gpu.h b/src/gpu.h new file mode 100644 index 0000000..133ba2b --- /dev/null +++ b/src/gpu.h @@ -0,0 +1,51 @@ +#ifndef FROSTD_GPU_H +#define FROSTD_GPU_H + +#include "metrics.h" + +/* + * Command runner vtable — analogous to Go's CommandRunner interface. + * run() executes a command and writes stdout into buf (null-terminated). + * Returns number of bytes written, or -1 on error. + */ +typedef struct { + int (*run)(void *ctx, const char *prog, const char *const *args, + char *buf, int buflen, char *errbuf, int errbuflen); + void *ctx; +} cmd_runner_t; + +typedef struct { + cmd_runner_t runner; +} gpu_reader_t; + +/* + * Parse nvidia-smi CSV output (one temperature per line). + * out_ids must be char[max][64], out_temps double[max]. + * Returns number of GPUs parsed, or -1 on error. + */ +int parse_gpu_temps(const char *output, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen); + +/* + * Build a temp_reader_t backed by nvidia-smi via a cmd_runner_t. + * The returned reader's ctx points to a heap-allocated gpu_reader_t. + * Free with gpu_reader_free(). + */ +gpu_reader_t *gpu_reader_new(cmd_runner_t runner); +void gpu_reader_free(gpu_reader_t *r); + +/* temp_reader_t read_temperatures callback — used via gpu_reader_make_reader() */ +int gpu_read_temperatures(void *ctx, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen); + +/* Returns a temp_reader_t wired to a gpu_reader_t */ +static inline temp_reader_t gpu_reader_make_reader(gpu_reader_t *r) { + return (temp_reader_t){gpu_read_temperatures, r}; +} + +/* Real popen-based command runner (used in production) */ +cmd_runner_t cmd_runner_real(void); + +#endif /* FROSTD_GPU_H */ diff --git a/src/ipmi.c b/src/ipmi.c new file mode 100644 index 0000000..4f3b0d1 --- /dev/null +++ b/src/ipmi.c @@ -0,0 +1,220 @@ +#include "ipmi.h" + +#include +#include +#include + +#include +#include +#include + +/* CPU temperature sensors use entity ID 0x03 (processor). + * libipmimonitoring does not expose entity ID directly, so we filter by + * sensor type Temperature and rely on the sensor name prefix check being + * unnecessary — all Temperature sensors at entity 0x03 are CPU packages. + * In practice, the server also reports inlet/exhaust sensors but those + * have different sensor types (temp is type 0x01 for all, entity differs). + * + * The filtering by entity ID is done in cpu.c rather than here, since + * libipmimonitoring does not provide direct entity ID access in the + * iteration API of this version. cpu.c uses the record_id list approach + * via sensor_readings_by_record_id if needed; for now we expose all + * temperature sensors and let cpu.c filter by name convention. + */ + +#define SDR_CACHE_DIR "/var/lib/frostd" + +/* ---- implementation context ---- */ + +typedef struct { + ipmi_monitoring_ctx_t mon_ctx; /* for sensor reads */ + ipmi_ctx_t raw_ctx; /* for raw commands */ + char errmsg[256]; +} real_ipmi_impl_t; + +static int real_connect(void *impl) { + real_ipmi_impl_t *r = impl; + + /* Initialise ipmimonitoring (idempotent) */ + int errnum; + if (ipmi_monitoring_init(0, &errnum) < 0) { + snprintf(r->errmsg, sizeof(r->errmsg), + "ipmi_monitoring_init: errnum %d", errnum); + return -1; + } + + /* Create monitoring context */ + if (!r->mon_ctx) { + r->mon_ctx = ipmi_monitoring_ctx_create(); + if (!r->mon_ctx) { + snprintf(r->errmsg, sizeof(r->errmsg), "ipmi_monitoring_ctx_create failed"); + return -1; + } + ipmi_monitoring_ctx_sdr_cache_directory(r->mon_ctx, SDR_CACHE_DIR); + } + + /* Create raw IPMI context */ + if (!r->raw_ctx) { + r->raw_ctx = ipmi_ctx_create(); + if (!r->raw_ctx) { + snprintf(r->errmsg, sizeof(r->errmsg), "ipmi_ctx_create failed"); + return -1; + } + /* Auto-discover inband IPMI device */ + int rc = ipmi_ctx_find_inband(r->raw_ctx, NULL, 0, 0, 0, NULL, 0, 0); + if (rc < 0) { + snprintf(r->errmsg, sizeof(r->errmsg), + "ipmi_ctx_find_inband: %s", ipmi_ctx_errormsg(r->raw_ctx)); + return -1; + } + if (rc == 0) { + snprintf(r->errmsg, sizeof(r->errmsg), "no inband IPMI device found"); + return -1; + } + } + return 0; +} + +static void real_close(void *impl) { + real_ipmi_impl_t *r = impl; + if (r->mon_ctx) { + ipmi_monitoring_ctx_destroy(r->mon_ctx); + r->mon_ctx = NULL; + } + if (r->raw_ctx) { + ipmi_ctx_close(r->raw_ctx); + ipmi_ctx_destroy(r->raw_ctx); + r->raw_ctx = NULL; + } +} + +static int read_sensors_by_type(real_ipmi_impl_t *r, unsigned int sensor_type, + temp_sensor_raw_t *temp_out, int temp_max, + fan_reading_raw_t *fan_out, int fan_max) { + unsigned int types[] = {sensor_type}; + int rc = ipmi_monitoring_sensor_readings_by_sensor_type( + r->mon_ctx, NULL, NULL, + IPMI_MONITORING_SENSOR_READING_FLAGS_IGNORE_NON_INTERPRETABLE_SENSORS, + types, 1, NULL, NULL); + if (rc < 0) { + snprintf(r->errmsg, sizeof(r->errmsg), + "sensor_readings_by_sensor_type: %s", + ipmi_monitoring_ctx_errormsg(r->mon_ctx)); + return -1; + } + + int count = 0; + if (ipmi_monitoring_sensor_iterator_first(r->mon_ctx) < 0) + return 0; + + do { + const char *name = ipmi_monitoring_sensor_read_sensor_name(r->mon_ctx); + int units = ipmi_monitoring_sensor_read_sensor_units(r->mon_ctx); + int rtype = ipmi_monitoring_sensor_read_sensor_reading_type(r->mon_ctx); + void *val_p = ipmi_monitoring_sensor_read_sensor_reading(r->mon_ctx); + + if (!name || !val_p) continue; + if (rtype != IPMI_MONITORING_SENSOR_READING_TYPE_DOUBLE) continue; + double val = *(double *)val_p; + + if (sensor_type == IPMI_MONITORING_SENSOR_TYPE_TEMPERATURE && + temp_out && count < temp_max) { + strncpy(temp_out[count].name, name, sizeof(temp_out[count].name) - 1); + temp_out[count].name[sizeof(temp_out[count].name) - 1] = '\0'; + temp_out[count].value = val; + count++; + } else if (sensor_type == IPMI_MONITORING_SENSOR_TYPE_FAN && + fan_out && count < fan_max) { + strncpy(fan_out[count].name, name, sizeof(fan_out[count].name) - 1); + fan_out[count].name[sizeof(fan_out[count].name) - 1] = '\0'; + if (units == IPMI_MONITORING_SENSOR_UNITS_RPM) { + fan_out[count].has_rpm = 1; + fan_out[count].rpm = val; + } else if (units == IPMI_MONITORING_SENSOR_UNITS_PERCENT) { + fan_out[count].has_percent = 1; + fan_out[count].percent = val; + } + count++; + } + } while (ipmi_monitoring_sensor_iterator_next(r->mon_ctx) == 1); + + return count; +} + +static int real_get_temp_sensors(void *impl, temp_sensor_raw_t *out, int max) { + real_ipmi_impl_t *r = impl; + return read_sensors_by_type(r, IPMI_MONITORING_SENSOR_TYPE_TEMPERATURE, + out, max, NULL, 0); +} + +static int real_get_fan_sensors(void *impl, fan_reading_raw_t *out, int max) { + real_ipmi_impl_t *r = impl; + return read_sensors_by_type(r, IPMI_MONITORING_SENSOR_TYPE_FAN, + NULL, 0, out, max); +} + +static int real_raw_command(void *impl, uint8_t netfn, uint8_t cmd, + const uint8_t *data, int data_len, + uint8_t *resp, int *resp_len) { + real_ipmi_impl_t *r = impl; /* needs write access for errmsg */ + + /* ipmi_cmd_raw's request buffer must start with the command byte, + * followed by the command's data bytes. */ + uint8_t rq_buf[256]; + if (data_len < 0 || (size_t)data_len + 1 > sizeof(rq_buf)) { + snprintf(r->errmsg, sizeof(r->errmsg), "raw command data too long"); + return -1; + } + rq_buf[0] = cmd; + if (data_len > 0) memcpy(&rq_buf[1], data, (size_t)data_len); + int rq_len = data_len + 1; + + uint8_t rs_buf[256]; + int rs_len = (int)sizeof(rs_buf); + int rc = ipmi_cmd_raw(r->raw_ctx, 0, netfn, rq_buf, rq_len, rs_buf, rs_len); + if (rc < 0) { + snprintf(r->errmsg, sizeof(r->errmsg), + "ipmi_cmd_raw: %s", ipmi_ctx_errormsg(r->raw_ctx)); + return -1; + } + if (resp && resp_len && *resp_len > 0) { + int copy = (rc < *resp_len) ? rc : *resp_len; + memcpy(resp, rs_buf, copy); + *resp_len = copy; + } + return 0; +} + +static const char *real_last_error(void *impl) { + const real_ipmi_impl_t *r = impl; + return r->errmsg; +} + +/* ---- public API ---- */ + +ipmi_ops_t *ipmi_ops_new_real(void) { + real_ipmi_impl_t *r = calloc(1, sizeof(*r)); + if (!r) return NULL; + + ipmi_ops_t *ops = malloc(sizeof(*ops)); + if (!ops) { free(r); return NULL; } + + *ops = (ipmi_ops_t){ + .connect = real_connect, + .close = real_close, + .get_temp_sensors = real_get_temp_sensors, + .get_fan_sensors = real_get_fan_sensors, + .raw_command = real_raw_command, + .last_error = real_last_error, + .impl = r, + }; + return ops; +} + +void ipmi_ops_free(ipmi_ops_t *ops) { + if (!ops) return; + real_ipmi_impl_t *r = ops->impl; + real_close(r); + free(r); + free(ops); +} diff --git a/src/ipmi.h b/src/ipmi.h new file mode 100644 index 0000000..d1d5b0c --- /dev/null +++ b/src/ipmi.h @@ -0,0 +1,58 @@ +#ifndef FROSTD_IPMI_H +#define FROSTD_IPMI_H + +#include + +#define IPMI_MAX_SENSORS 64 + +/* Raw sensor reading from IPMI for a temperature sensor */ +typedef struct { + char name[64]; + double value; /* degrees C */ + int entity_id; + int entity_instance; +} temp_sensor_raw_t; + +/* Raw fan sensor reading from IPMI */ +typedef struct { + char name[64]; + int has_rpm; + double rpm; + int has_percent; + double percent; +} fan_reading_raw_t; + +/* + * vtable for IPMI operations — production implementation uses FreeIPMI, + * test implementations use mocks. + */ +struct ipmi_ops { + /* Returns 0 on success, -1 on error */ + int (*connect)(void *impl); + void (*close)(void *impl); + + /* Returns number of readings on success, -1 on error */ + int (*get_temp_sensors)(void *impl, temp_sensor_raw_t *out, int max); + int (*get_fan_sensors)(void *impl, fan_reading_raw_t *out, int max); + + /* Returns 0 on success, -1 on error */ + int (*raw_command)(void *impl, uint8_t netfn, uint8_t cmd, + const uint8_t *data, int data_len, + uint8_t *resp, int *resp_len); + + /* Returns a human-readable string for the last error */ + const char *(*last_error)(void *impl); + + void *impl; +}; + +typedef struct ipmi_ops ipmi_ops_t; + +/* Create a real (FreeIPMI-backed) IPMI ops instance. + * Returns NULL on failure (logs reason to stderr). */ +ipmi_ops_t *ipmi_ops_new_real(void); + +/* Free an ipmi_ops_t created by ipmi_ops_new_real. */ +void ipmi_ops_free(ipmi_ops_t *ops); + +#endif /* FROSTD_IPMI_H */ diff --git a/src/log.c b/src/log.c new file mode 100644 index 0000000..e36a188 --- /dev/null +++ b/src/log.c @@ -0,0 +1,108 @@ +#include "log.h" + +#include +#include +#include + +logger_t *logger_new(FILE *out, log_format_t format) { + logger_t *l = malloc(sizeof(*l)); + if (!l) return NULL; + l->out = out; + l->format = format; + return l; +} + +void logger_free(logger_t *l) { + free(l); +} + +static const char *level_str(log_level_t level) { + switch (level) { + case LOG_LEVEL_DEBUG: return "DEBUG"; + case LOG_LEVEL_INFO: return "INFO"; + case LOG_LEVEL_WARN: return "WARN"; + case LOG_LEVEL_ERROR: return "ERROR"; + } + return "INFO"; +} + +static void iso8601_now(char *buf, size_t len) { + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + struct tm tm; + localtime_r(&ts.tv_sec, &tm); + char tmp[32]; + strftime(tmp, sizeof(tmp), "%Y-%m-%dT%H:%M:%S", &tm); + char tz[8]; + strftime(tz, sizeof(tz), "%z", &tm); + snprintf(buf, len, "%s.%03ld%s", tmp, ts.tv_nsec / 1000000L, tz); +} + +static void write_json_str(FILE *out, const char *s) { + fputc('"', out); + for (; *s; s++) { + switch (*s) { + case '"': fputs("\\\"", out); break; + case '\\': fputs("\\\\", out); break; + case '\n': fputs("\\n", out); break; + case '\r': fputs("\\r", out); break; + case '\t': fputs("\\t", out); break; + default: fputc(*s, out); break; + } + } + fputc('"', out); +} + +static void write_text(logger_t *l, log_level_t level, const char *msg, + const log_field_t *fields, int nfields) { + char ts[40]; + iso8601_now(ts, sizeof(ts)); + fprintf(l->out, "time=%s level=%s msg=%s", ts, level_str(level), msg); + for (int i = 0; i < nfields; i++) { + switch (fields[i].type) { + case LOG_FIELD_STR: + fprintf(l->out, " %s=%s", fields[i].key, fields[i].val.s); + break; + case LOG_FIELD_INT: + fprintf(l->out, " %s=%lld", fields[i].key, fields[i].val.i); + break; + case LOG_FIELD_FLOAT: + fprintf(l->out, " %s=%.2f", fields[i].key, fields[i].val.f); + break; + } + } + fputc('\n', l->out); +} + +static void write_json(logger_t *l, log_level_t level, const char *msg, + const log_field_t *fields, int nfields) { + char ts[40]; + iso8601_now(ts, sizeof(ts)); + fprintf(l->out, "{\"time\":\"%s\",\"level\":\"%s\",\"msg\":", ts, level_str(level)); + write_json_str(l->out, msg); + for (int i = 0; i < nfields; i++) { + fprintf(l->out, ",\"%s\":", fields[i].key); + switch (fields[i].type) { + case LOG_FIELD_STR: + write_json_str(l->out, fields[i].val.s); + break; + case LOG_FIELD_INT: + fprintf(l->out, "%lld", fields[i].val.i); + break; + case LOG_FIELD_FLOAT: + fprintf(l->out, "%.2f", fields[i].val.f); + break; + } + } + fputs("}\n", l->out); +} + +void logger_log(logger_t *l, log_level_t level, const char *msg, + const log_field_t *fields, int nfields) { + if (!l) return; + if (l->format == LOG_FORMAT_JSON) + write_json(l, level, msg, fields, nfields); + else + write_text(l, level, msg, fields, nfields); + fflush(l->out); +} diff --git a/src/log.h b/src/log.h new file mode 100644 index 0000000..eb5105a --- /dev/null +++ b/src/log.h @@ -0,0 +1,81 @@ +#ifndef FROSTD_LOG_H +#define FROSTD_LOG_H + +#include +#include + +typedef enum { + LOG_LEVEL_DEBUG, + LOG_LEVEL_INFO, + LOG_LEVEL_WARN, + LOG_LEVEL_ERROR, +} log_level_t; + +typedef enum { + LOG_FORMAT_TEXT, + LOG_FORMAT_JSON, +} log_format_t; + +typedef struct { + FILE *out; + log_format_t format; +} logger_t; + +/* Log field value types */ +typedef enum { + LOG_FIELD_STR, + LOG_FIELD_INT, + LOG_FIELD_FLOAT, +} log_field_type_t; + +typedef struct { + const char *key; + log_field_type_t type; + union { + const char *s; + long long i; + double f; + } val; +} log_field_t; + +#define LOG_STR(k, v) ((log_field_t){(k), LOG_FIELD_STR, {.s = (v)}}) +#define LOG_INT(k, v) ((log_field_t){(k), LOG_FIELD_INT, {.i = (v)}}) +#define LOG_FLOAT(k, v)((log_field_t){(k), LOG_FIELD_FLOAT, {.f = (v)}}) +#define LOG_END ((log_field_t){NULL, LOG_FIELD_STR, {.s = NULL}}) + +logger_t *logger_new(FILE *out, log_format_t format); +void logger_free(logger_t *l); + +void logger_log(logger_t *l, log_level_t level, const char *msg, + const log_field_t *fields, int nfields); + +/* Convenience macros — __VA_OPT__(,) inserts comma only when fields given */ +#define log_info(l, msg, ...) \ + do { \ + log_field_t _f[] = {__VA_ARGS__ __VA_OPT__(,) LOG_END}; \ + logger_log((l), LOG_LEVEL_INFO, (msg), _f, \ + (int)(sizeof(_f)/sizeof(_f[0])) - 1); \ + } while (0) + +#define log_warn(l, msg, ...) \ + do { \ + log_field_t _f[] = {__VA_ARGS__ __VA_OPT__(,) LOG_END}; \ + logger_log((l), LOG_LEVEL_WARN, (msg), _f, \ + (int)(sizeof(_f)/sizeof(_f[0])) - 1); \ + } while (0) + +#define log_error(l, msg, ...) \ + do { \ + log_field_t _f[] = {__VA_ARGS__ __VA_OPT__(,) LOG_END}; \ + logger_log((l), LOG_LEVEL_ERROR, (msg), _f, \ + (int)(sizeof(_f)/sizeof(_f[0])) - 1); \ + } while (0) + +#define log_debug(l, msg, ...) \ + do { \ + log_field_t _f[] = {__VA_ARGS__ __VA_OPT__(,) LOG_END}; \ + logger_log((l), LOG_LEVEL_DEBUG, (msg), _f, \ + (int)(sizeof(_f)/sizeof(_f[0])) - 1); \ + } while (0) + +#endif /* FROSTD_LOG_H */ diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..ab56b61 --- /dev/null +++ b/src/main.c @@ -0,0 +1,184 @@ +#include "config.h" +#include "cpu.h" +#include "fan.h" +#include "gpu.h" +#include "ipmi.h" +#include "log.h" +#include "metrics.h" +#include "prometheus.h" +#include "service.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#define VERSION "0.1.0" + +volatile sig_atomic_t g_shutdown = 0; + +static void sig_handler(int sig) { + (void)sig; + g_shutdown = 1; +} + +static void setup_signals(void) { + struct sigaction sa = {.sa_handler = sig_handler}; + sigemptyset(&sa.sa_mask); + sigaction(SIGTERM, &sa, NULL); + sigaction(SIGINT, &sa, NULL); +} + +static logger_t *setup_logger(const char *log_file, const char *log_format, + char *errbuf, int errbuflen) { + FILE *out = stdout; + if (log_file && *log_file) { + /* mkdir -p the parent directory */ + char *tmp = strdup(log_file); + char *dir = dirname(tmp); + struct stat st; + if (stat(dir, &st) != 0) { + if (mkdir(dir, 0755) != 0 && errno != EEXIST) { + snprintf(errbuf, errbuflen, "mkdir %s: %s", dir, strerror(errno)); + free(tmp); + return NULL; + } + } + free(tmp); + + out = fopen(log_file, "a"); + if (!out) { + snprintf(errbuf, errbuflen, "open %s: %s", log_file, strerror(errno)); + return NULL; + } + } + + log_format_t fmt = LOG_FORMAT_TEXT; + if (log_format && strcmp(log_format, "json") == 0) + fmt = LOG_FORMAT_JSON; + + return logger_new(out, fmt); +} + +static void print_usage(const char *prog) { + fprintf(stderr, "Usage: %s [-c config] [-version]\n", prog); +} + +int main(int argc, char *argv[]) { + const char *config_path = "/etc/frostd.yaml"; + int show_version = 0; + + /* Pre-scan for -version / --version before getopt consumes the args */ + for (int i = 1; i < argc; i++) { + if (strcmp(argv[i], "-version") == 0 || + strcmp(argv[i], "--version") == 0) { + show_version = 1; + } + } + + opterr = 0; /* suppress getopt error messages; we handle them below */ + int opt; + while ((opt = getopt(argc, argv, "c:")) != -1) { + switch (opt) { + case 'c': + config_path = optarg; + break; + case '?': + if (!show_version) { + print_usage(argv[0]); + return 1; + } + break; + default: + break; + } + } + + if (show_version) { + printf("%s\n", VERSION); + return 0; + } + + /* Load configuration */ + frostd_config_t *cfg = NULL; + char errbuf[512]; + if (config_load(config_path, &cfg, errbuf, sizeof(errbuf)) != 0) { + fprintf(stderr, "frostd: configuration error: %s\n", errbuf); + return 1; + } + + /* Setup logger */ + logger_t *logger = setup_logger(cfg->log_file, cfg->log_format, + errbuf, sizeof(errbuf)); + if (!logger) { + fprintf(stderr, "frostd: failed to open log file: %s\n", errbuf); + config_free(cfg); + return 1; + } + + /* Setup IPMI */ + ipmi_ops_t *ipmi = ipmi_ops_new_real(); + if (!ipmi) { + fprintf(stderr, "frostd: failed to initialise IPMI\n"); + return 1; + } + + /* Build service */ + service_t svc = { + .cfg = cfg, + .fan_ctrl = {.ops = ipmi}, + .monitor_count = 0, + .logger = logger, + }; + + /* Build sensor monitors */ + if (cfg->cpu) { + cpu_reader_t *cr = cpu_reader_new(ipmi_ops_new_real()); + temp_reader_t tr = cpu_reader_make_reader(cr); + svc.monitors[svc.monitor_count++] = + sensor_monitor_new("cpu", cfg->cpu, tr); + } + if (cfg->gpu) { + gpu_reader_t *gr = gpu_reader_new(cmd_runner_real()); + temp_reader_t tr = gpu_reader_make_reader(gr); + svc.monitors[svc.monitor_count++] = + sensor_monitor_new("gpu", cfg->gpu, tr); + } + + /* Setup Prometheus */ + prom_metrics_t *prom = prom_metrics_new(); + svc.prom = prom; + + if (cfg->prometheus && cfg->prometheus->listen_addr && + *cfg->prometheus->listen_addr) { + if (prom_start_server(prom, cfg->prometheus->listen_addr, + logger, errbuf, sizeof(errbuf)) != 0) { + log_error(logger, "failed to start prometheus server", + LOG_STR("error", errbuf)); + } + } + + /* Install signal handlers */ + setup_signals(); + + log_info(logger, "frostd started", + LOG_STR("config", config_path), + LOG_INT("dry_run", cfg->dry_run ? 1 : 0)); + + service_run(&svc); + + log_info(logger, "frostd stopping"); + + /* Cleanup */ + prom_metrics_free(prom); + for (int i = 0; i < svc.monitor_count; i++) + sensor_monitor_free(svc.monitors[i]); + ipmi_ops_free(ipmi); + config_free(cfg); + logger_free(logger); + return 0; +} diff --git a/src/metrics.c b/src/metrics.c new file mode 100644 index 0000000..1834bc1 --- /dev/null +++ b/src/metrics.c @@ -0,0 +1,99 @@ +#include "metrics.h" + +#include +#include +#include + +sensor_monitor_t *sensor_monitor_new(const char *name, sensor_config_t *cfg, + temp_reader_t reader) { + sensor_monitor_t *m = calloc(1, sizeof(*m)); + if (!m) return NULL; + m->name = name; + m->cfg = cfg; + m->reader = reader; + return m; +} + +void sensor_monitor_free(sensor_monitor_t *m) { + if (!m) return; + for (int i = 0; i < m->buf_count; i++) + free(m->bufs[i].samples); + free(m); +} + +static sensor_buf_t *find_or_create_buf(sensor_monitor_t *m, const char *id) { + for (int i = 0; i < m->buf_count; i++) { + if (strcmp(m->bufs[i].id, id) == 0) + return &m->bufs[i]; + } + if (m->buf_count >= METRICS_MAX_SENSOR_IDS) return NULL; + + sensor_buf_t *b = &m->bufs[m->buf_count++]; + strncpy(b->id, id, sizeof(b->id) - 1); + b->id[sizeof(b->id) - 1] = '\0'; + b->samples = calloc(m->cfg->sample_size, sizeof(double)); + b->head = 0; + b->count = 0; + return b; +} + +static void buf_push(sensor_buf_t *b, double temp, int sample_size) { + b->samples[b->head] = temp; + b->head = (b->head + 1) % sample_size; + if (b->count < sample_size) b->count++; +} + +static double buf_mean(const sensor_buf_t *b, int sample_size) { + if (b->count == 0) return 0.0; + double sum = 0.0; + /* Walk backwards from head - count to head */ + int start = (b->head - b->count + sample_size) % sample_size; + for (int i = 0; i < b->count; i++) + sum += b->samples[(start + i) % sample_size]; + return sum / (double)b->count; +} + +int sensor_monitor_poll(sensor_monitor_t *m, + char out_ids[][64], double *out_temps, + double *out_aggs, int max, + char *errbuf, int errbuflen) { + char raw_ids[METRICS_MAX_SENSOR_IDS][64]; + double raw_temps[METRICS_MAX_SENSOR_IDS]; + + int n = m->reader.read_temperatures(m->reader.ctx, + raw_ids, raw_temps, + METRICS_MAX_SENSOR_IDS, + errbuf, errbuflen); + if (n < 0) return -1; + if (n == 0) { + snprintf(errbuf, errbuflen, "%s: no temperature readings returned", m->name); + return -1; + } + + int out_count = (n < max) ? n : max; + for (int i = 0; i < out_count; i++) { + sensor_buf_t *b = find_or_create_buf(m, raw_ids[i]); + if (!b) { + snprintf(errbuf, errbuflen, "%s: too many sensor IDs", m->name); + return -1; + } + buf_push(b, raw_temps[i], m->cfg->sample_size); + + strncpy(out_ids[i], raw_ids[i], 64); + out_ids[i][63] = '\0'; + out_temps[i] = raw_temps[i]; + out_aggs[i] = buf_mean(b, m->cfg->sample_size); + } + return out_count; +} + +int sensor_monitor_aggregates(const sensor_monitor_t *m, + char out_ids[][64], double *out_aggs, int max) { + int count = (m->buf_count < max) ? m->buf_count : max; + for (int i = 0; i < count; i++) { + strncpy(out_ids[i], m->bufs[i].id, 64); + out_ids[i][63] = '\0'; + out_aggs[i] = buf_mean(&m->bufs[i], m->cfg->sample_size); + } + return count; +} diff --git a/src/metrics.h b/src/metrics.h new file mode 100644 index 0000000..2c1cac5 --- /dev/null +++ b/src/metrics.h @@ -0,0 +1,54 @@ +#ifndef FROSTD_METRICS_H +#define FROSTD_METRICS_H + +#include "config.h" +#include + +#define METRICS_MAX_SENSOR_IDS 32 + +/* Interface for reading temperatures — analogous to Go's TempReader interface. */ +typedef struct { + /* Returns number of readings written into ids/temps (max count). + * ids must be an array of char[64]. Returns -1 on error. */ + int (*read_temperatures)(void *ctx, + char ids[][64], double *temps, int max, + char *errbuf, int errbuflen); + void *ctx; +} temp_reader_t; + +typedef struct { + char id[64]; + double *samples; /* circular buffer, length = cfg->sample_size */ + int head; /* next write index */ + int count; /* number of valid samples */ +} sensor_buf_t; + +typedef struct { + const char *name; + sensor_config_t *cfg; + temp_reader_t reader; + sensor_buf_t bufs[METRICS_MAX_SENSOR_IDS]; + int buf_count; +} sensor_monitor_t; + +/* Result of Poll: arrays of sensor IDs, latest temps, and aggregate temps. + * out_ids, out_temps, out_aggs must be arrays of at least METRICS_MAX_SENSOR_IDS. + * out_ids rows are char[64]. Returns number of sensors, or -1 on error. */ +int sensor_monitor_poll(sensor_monitor_t *m, + char out_ids[][64], double *out_temps, + double *out_aggs, int max, + char *errbuf, int errbuflen); + +/* Returns aggregate (rolling average) for each sensor currently buffered. + * Same out arrays as above. Returns count. */ +int sensor_monitor_aggregates(const sensor_monitor_t *m, + char out_ids[][64], double *out_aggs, int max); + +/* Allocate and initialise a sensor monitor. */ +sensor_monitor_t *sensor_monitor_new(const char *name, sensor_config_t *cfg, + temp_reader_t reader); + +/* Free a sensor monitor created with sensor_monitor_new. */ +void sensor_monitor_free(sensor_monitor_t *m); + +#endif /* FROSTD_METRICS_H */ diff --git a/src/prometheus.c b/src/prometheus.c new file mode 100644 index 0000000..c63afad --- /dev/null +++ b/src/prometheus.c @@ -0,0 +1,237 @@ +#include "prometheus.h" + +#include + +#include +#include +#include + +/* ---- text format generation ---- */ + +static int find_sensor(prom_metrics_t *m, const char *sensor) { + for (int i = 0; i < m->sensor_count; i++) + if (strcmp(m->sensor_labels[i], sensor) == 0) return i; + if (m->sensor_count >= PROM_MAX_SENSORS) return -1; + strncpy(m->sensor_labels[m->sensor_count], sensor, PROM_MAX_NAME_LEN - 1); + m->sensor_labels[m->sensor_count][PROM_MAX_NAME_LEN - 1] = '\0'; + return m->sensor_count++; +} + +static int find_or_add_sensor_id(prom_metrics_t *m, int si, const char *id) { + for (int i = 0; i < m->sensor_id_counts[si]; i++) + if (strcmp(m->sensor_id_labels[si][i], id) == 0) return i; + if (m->sensor_id_counts[si] >= PROM_MAX_IDS) return -1; + int ii = m->sensor_id_counts[si]++; + strncpy(m->sensor_id_labels[si][ii], id, PROM_MAX_ID_LEN - 1); + m->sensor_id_labels[si][ii][PROM_MAX_ID_LEN - 1] = '\0'; + return ii; +} + +static int find_fan(prom_metrics_t *m, const char *fan) { + for (int i = 0; i < m->fan_count; i++) + if (strcmp(m->fan_labels[i], fan) == 0) return i; + if (m->fan_count >= PROM_MAX_FANS) return -1; + strncpy(m->fan_labels[m->fan_count], fan, PROM_MAX_NAME_LEN - 1); + m->fan_labels[m->fan_count][PROM_MAX_NAME_LEN - 1] = '\0'; + return m->fan_count++; +} + +/* Generate Prometheus text format into a heap-allocated buffer. + * Caller must free. */ +static char *generate_text(prom_metrics_t *m) { + char *buf = NULL; + size_t sz = 0; + FILE *fp = open_memstream(&buf, &sz); + if (!fp) return NULL; + + pthread_mutex_lock(&m->lock); + + /* frostd_sensor_temperature */ + fputs("# HELP frostd_sensor_temperature Current temperature reading per sensor, in Celsius.\n" + "# TYPE frostd_sensor_temperature gauge\n", fp); + for (int si = 0; si < m->sensor_count; si++) + for (int ii = 0; ii < m->sensor_id_counts[si]; ii++) + fprintf(fp, "frostd_sensor_temperature{sensor=\"%s\",id=\"%s\"} %.2f\n", + m->sensor_labels[si], m->sensor_id_labels[si][ii], + m->sensor_temps[si][ii]); + + /* frostd_sensor_aggregate_temperature */ + fputs("# HELP frostd_sensor_aggregate_temperature Rolling aggregate temperature per sensor type, in Celsius.\n" + "# TYPE frostd_sensor_aggregate_temperature gauge\n", fp); + for (int si = 0; si < m->sensor_count; si++) + for (int ii = 0; ii < m->sensor_id_counts[si]; ii++) + fprintf(fp, "frostd_sensor_aggregate_temperature{sensor=\"%s\",id=\"%s\"} %.2f\n", + m->sensor_labels[si], m->sensor_id_labels[si][ii], + m->agg_temps[si][ii]); + + /* frostd_suggested_fan_speed_percent */ + fputs("# HELP frostd_suggested_fan_speed_percent Suggested fan speed percentage per sensor type.\n" + "# TYPE frostd_suggested_fan_speed_percent gauge\n", fp); + for (int si = 0; si < m->sensor_count; si++) + fprintf(fp, "frostd_suggested_fan_speed_percent{sensor=\"%s\"} %.2f\n", + m->sensor_labels[si], m->suggested_speeds[si]); + + /* frostd_actual_fan_rpm */ + fputs("# HELP frostd_actual_fan_rpm Actual fan speed in RPM.\n" + "# TYPE frostd_actual_fan_rpm gauge\n", fp); + for (int fi = 0; fi < m->fan_count; fi++) + if (m->fan_has_rpm[fi]) + fprintf(fp, "frostd_actual_fan_rpm{fan=\"%s\"} %.2f\n", + m->fan_labels[fi], m->fan_rpm[fi]); + + /* frostd_actual_fan_speed_percent */ + fputs("# HELP frostd_actual_fan_speed_percent Actual fan speed as percentage.\n" + "# TYPE frostd_actual_fan_speed_percent gauge\n", fp); + for (int fi = 0; fi < m->fan_count; fi++) + if (m->fan_has_pct[fi]) + fprintf(fp, "frostd_actual_fan_speed_percent{fan=\"%s\"} %.2f\n", + m->fan_labels[fi], m->fan_pct[fi]); + + /* frostd_system_fan_speed_percent */ + fputs("# HELP frostd_system_fan_speed_percent Commanded system fan speed percentage.\n" + "# TYPE frostd_system_fan_speed_percent gauge\n", fp); + fprintf(fp, "frostd_system_fan_speed_percent %.2f\n", m->system_speed); + + pthread_mutex_unlock(&m->lock); + + fclose(fp); + return buf; +} + +/* ---- libmicrohttpd request handler ---- */ + +static enum MHD_Result handle_request(void *cls, + struct MHD_Connection *conn, + const char *url, + const char *method, + const char *version, + const char *upload_data, + size_t *upload_data_size, + void **con_cls) { + (void)version; (void)upload_data; (void)upload_data_size; (void)con_cls; + + prom_metrics_t *m = cls; + + if (strcmp(url, "/metrics") != 0) { + struct MHD_Response *r = MHD_create_response_from_buffer( + 9, (void *)"Not Found", MHD_RESPMEM_PERSISTENT); + enum MHD_Result ret = MHD_queue_response(conn, MHD_HTTP_NOT_FOUND, r); + MHD_destroy_response(r); + return ret; + } + + if (strcmp(method, "GET") != 0) { + struct MHD_Response *r = MHD_create_response_from_buffer( + 0, (void *)"", MHD_RESPMEM_PERSISTENT); + enum MHD_Result ret = MHD_queue_response(conn, MHD_HTTP_METHOD_NOT_ALLOWED, r); + MHD_destroy_response(r); + return ret; + } + + char *body = generate_text(m); + if (!body) return MHD_NO; + + struct MHD_Response *r = MHD_create_response_from_buffer( + strlen(body), body, MHD_RESPMEM_MUST_FREE); + MHD_add_response_header(r, "Content-Type", + "text/plain; version=0.0.4; charset=utf-8"); + enum MHD_Result ret = MHD_queue_response(conn, MHD_HTTP_OK, r); + MHD_destroy_response(r); + return ret; +} + +/* ---- public API ---- */ + +prom_metrics_t *prom_metrics_new(void) { + prom_metrics_t *m = calloc(1, sizeof(*m)); + if (!m) return NULL; + pthread_mutex_init(&m->lock, NULL); + return m; +} + +void prom_metrics_free(prom_metrics_t *m) { + if (!m) return; + prom_stop_server(m); + pthread_mutex_destroy(&m->lock); + free(m); +} + +int prom_start_server(prom_metrics_t *m, const char *addr, + logger_t *logger, char *errbuf, int errbuflen) { + /* Parse "host:port" or ":port" */ + const char *colon = strrchr(addr, ':'); + unsigned short port = 9100; + if (colon) port = (unsigned short)atoi(colon + 1); + + m->daemon = MHD_start_daemon( + MHD_USE_INTERNAL_POLLING_THREAD, + port, + NULL, NULL, + handle_request, m, + MHD_OPTION_END); + + if (!m->daemon) { + snprintf(errbuf, errbuflen, "MHD_start_daemon failed on %s", addr); + return -1; + } + log_info(logger, "prometheus metrics server listening", + LOG_STR("addr", addr)); + return 0; +} + +void prom_stop_server(prom_metrics_t *m) { + if (m->daemon) { + MHD_stop_daemon(m->daemon); + m->daemon = NULL; + } +} + +void prom_set_sensor_temp(prom_metrics_t *m, + const char *sensor, const char *id, double temp) { + pthread_mutex_lock(&m->lock); + int si = find_sensor(m, sensor); + if (si >= 0) { + int ii = find_or_add_sensor_id(m, si, id); + if (ii >= 0) m->sensor_temps[si][ii] = temp; + } + pthread_mutex_unlock(&m->lock); +} + +void prom_set_agg_temp(prom_metrics_t *m, + const char *sensor, const char *id, double temp) { + pthread_mutex_lock(&m->lock); + int si = find_sensor(m, sensor); + if (si >= 0) { + int ii = find_or_add_sensor_id(m, si, id); + if (ii >= 0) m->agg_temps[si][ii] = temp; + } + pthread_mutex_unlock(&m->lock); +} + +void prom_set_suggested_speed(prom_metrics_t *m, + const char *sensor, double speed) { + pthread_mutex_lock(&m->lock); + int si = find_sensor(m, sensor); + if (si >= 0) m->suggested_speeds[si] = speed; + pthread_mutex_unlock(&m->lock); +} + +void prom_set_fan_rpm(prom_metrics_t *m, const char *fan, double rpm) { + pthread_mutex_lock(&m->lock); + int fi = find_fan(m, fan); + if (fi >= 0) { m->fan_rpm[fi] = rpm; m->fan_has_rpm[fi] = 1; } + pthread_mutex_unlock(&m->lock); +} + +void prom_set_fan_pct(prom_metrics_t *m, const char *fan, double pct) { + pthread_mutex_lock(&m->lock); + int fi = find_fan(m, fan); + if (fi >= 0) { m->fan_pct[fi] = pct; m->fan_has_pct[fi] = 1; } + pthread_mutex_unlock(&m->lock); +} + +void prom_set_system_speed(prom_metrics_t *m, double speed) { + pthread_mutex_lock(&m->lock); + m->system_speed = speed; + pthread_mutex_unlock(&m->lock); +} diff --git a/src/prometheus.h b/src/prometheus.h new file mode 100644 index 0000000..1ebf0fd --- /dev/null +++ b/src/prometheus.h @@ -0,0 +1,66 @@ +#ifndef FROSTD_PROMETHEUS_H +#define FROSTD_PROMETHEUS_H + +#include "log.h" +#include + +#define PROM_MAX_SENSORS 4 +#define PROM_MAX_IDS 32 +#define PROM_MAX_FANS 32 +#define PROM_MAX_ID_LEN 64 +#define PROM_MAX_NAME_LEN 64 + +typedef struct { + /* Sensor temperature: frostd_sensor_temperature{sensor, id} */ + char sensor_labels[PROM_MAX_SENSORS][PROM_MAX_NAME_LEN]; + char sensor_id_labels[PROM_MAX_SENSORS][PROM_MAX_IDS][PROM_MAX_ID_LEN]; + double sensor_temps[PROM_MAX_SENSORS][PROM_MAX_IDS]; + int sensor_id_counts[PROM_MAX_SENSORS]; + int sensor_count; + + /* Aggregate temperature: frostd_sensor_aggregate_temperature{sensor, id} */ + double agg_temps[PROM_MAX_SENSORS][PROM_MAX_IDS]; + + /* Suggested speed: frostd_suggested_fan_speed_percent{sensor} */ + double suggested_speeds[PROM_MAX_SENSORS]; + + /* Fan readings: frostd_actual_fan_rpm{fan}, frostd_actual_fan_speed_percent{fan} */ + char fan_labels[PROM_MAX_FANS][PROM_MAX_NAME_LEN]; + double fan_rpm[PROM_MAX_FANS]; + int fan_has_rpm[PROM_MAX_FANS]; + double fan_pct[PROM_MAX_FANS]; + int fan_has_pct[PROM_MAX_FANS]; + int fan_count; + + /* System speed: frostd_system_fan_speed_percent */ + double system_speed; + + pthread_mutex_t lock; + struct MHD_Daemon *daemon; +} prom_metrics_t; + +/* Allocate and initialise a prom_metrics_t. */ +prom_metrics_t *prom_metrics_new(void); + +/* Free. Stops the HTTP server if running. */ +void prom_metrics_free(prom_metrics_t *m); + +/* Start the libmicrohttpd server on addr (e.g. ":9100"). Returns 0 on success. */ +int prom_start_server(prom_metrics_t *m, const char *addr, + logger_t *logger, char *errbuf, int errbuflen); + +/* Stop the HTTP server. */ +void prom_stop_server(prom_metrics_t *m); + +/* Thread-safe update functions */ +void prom_set_sensor_temp(prom_metrics_t *m, + const char *sensor, const char *id, double temp); +void prom_set_agg_temp(prom_metrics_t *m, + const char *sensor, const char *id, double temp); +void prom_set_suggested_speed(prom_metrics_t *m, + const char *sensor, double speed); +void prom_set_fan_rpm(prom_metrics_t *m, const char *fan, double rpm); +void prom_set_fan_pct(prom_metrics_t *m, const char *fan, double pct); +void prom_set_system_speed(prom_metrics_t *m, double speed); + +#endif /* FROSTD_PROMETHEUS_H */ diff --git a/src/service.c b/src/service.c new file mode 100644 index 0000000..27e6aec --- /dev/null +++ b/src/service.c @@ -0,0 +1,273 @@ +#include "service.h" + +#include +#include +#include +#include +#include + +#include + +/* Set by sigaction handler in main.c */ +extern volatile sig_atomic_t g_shutdown; + +/* ---- helpers ---- */ + +static void timespec_add_sec(struct timespec *ts, double seconds) { + long ns = (long)(seconds * 1e9); + ts->tv_sec += ns / 1000000000L; + ts->tv_nsec += ns % 1000000000L; + if (ts->tv_nsec >= 1000000000L) { + ts->tv_sec++; + ts->tv_nsec -= 1000000000L; + } +} + +/* Returns nonzero if a is strictly before b. */ +static int timespec_lt(const struct timespec *a, const struct timespec *b) { + if (a->tv_sec != b->tv_sec) return a->tv_sec < b->tv_sec; + return a->tv_nsec < b->tv_nsec; +} + +/* + * Signals are delivered to a single thread, and neither clock_nanosleep nor + * pthread_cond_timedwait wake up early on signal delivery. Cap every wait to + * this granularity so every thread notices g_shutdown promptly regardless of + * which thread the signal landed on. + */ +#define SHUTDOWN_POLL_SEC 1.0 + +/* ---- sensor thread ---- */ + +static void *sensor_thread(void *arg) { + sensor_thread_arg_t *a = arg; + sensor_monitor_t *m = a->monitor; + speed_bus_t *bus = a->bus; + logger_t *log = a->logger; + prom_metrics_t *prom = a->prom; + + struct timespec next_tick; + clock_gettime(CLOCK_MONOTONIC, &next_tick); + + while (!g_shutdown) { + timespec_add_sec(&next_tick, m->cfg->sample_interval_sec); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS], aggs[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = sensor_monitor_poll(m, ids, temps, aggs, + METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + if (n < 0) { + log_error(log, "sensor temperature poll failed", + LOG_STR("sensor", a->sensor_name), + LOG_STR("error", errbuf)); + } else { + /* Find max aggregate for speed suggestion */ + double max_agg = 0.0; + for (int i = 0; i < n; i++) + if (aggs[i] > max_agg) max_agg = aggs[i]; + + int speed = suggest_speed(max_agg, + m->cfg->ideal_temp, m->cfg->max_temp); + + log_info(log, "sensor suggested fan speed", + LOG_STR("sensor", a->sensor_name), + LOG_INT("suggest_percent", speed)); + + /* Update Prometheus */ + if (prom) { + for (int i = 0; i < n; i++) { + prom_set_sensor_temp(prom, a->sensor_name, ids[i], temps[i]); + prom_set_agg_temp(prom, a->sensor_name, ids[i], aggs[i]); + } + prom_set_suggested_speed(prom, a->sensor_name, (double)speed); + } + + /* Post speed to bus */ + pthread_mutex_lock(&bus->lock); + bus->speeds[a->sensor_idx] = speed; + bus->updated = 1; + pthread_cond_signal(&bus->cond); + pthread_mutex_unlock(&bus->lock); + } + + /* Sleep until next_tick, polling g_shutdown so a signal delivered to + * another thread is still noticed promptly. */ + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + while (!g_shutdown && timespec_lt(&now, &next_tick)) { + struct timespec wake = now; + timespec_add_sec(&wake, SHUTDOWN_POLL_SEC); + if (timespec_lt(&next_tick, &wake)) wake = next_tick; + clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &wake, NULL); + clock_gettime(CLOCK_MONOTONIC, &now); + } + } + return NULL; +} + +/* ---- log fan speeds ---- */ + +static void log_fan_speeds(service_t *svc, + fan_reading_t *prev, int *prev_count) { + fan_reading_t readings[PROM_MAX_FANS]; + char errbuf[256]; + int n = fan_read_speeds(&svc->fan_ctrl, readings, PROM_MAX_FANS, + errbuf, sizeof(errbuf)); + if (n < 0) { + log_error(svc->logger, "failed to read current fan speeds", + LOG_STR("error", errbuf)); + return; + } + + for (int i = 0; i < n; i++) { + if (readings[i].rpm.valid) { + /* Find prev reading for delta */ + int delta_rpm_valid = 0; + double delta_rpm = 0.0; + for (int j = 0; j < *prev_count; j++) { + if (strcmp(prev[j].name, readings[i].name) == 0 && prev[j].rpm.valid) { + delta_rpm = readings[i].rpm.value - prev[j].rpm.value; + delta_rpm_valid = 1; + break; + } + } + if (delta_rpm_valid) { + log_info(svc->logger, "current fan speed", + LOG_STR("fan", readings[i].name), + LOG_INT("rpm", (long long)readings[i].rpm.value), + LOG_INT("delta", (long long)delta_rpm)); + } else { + log_info(svc->logger, "current fan speed", + LOG_STR("fan", readings[i].name), + LOG_INT("rpm", (long long)readings[i].rpm.value)); + } + if (svc->prom) + prom_set_fan_rpm(svc->prom, readings[i].name, readings[i].rpm.value); + } + if (readings[i].percent.valid) { + if (svc->prom) + prom_set_fan_pct(svc->prom, readings[i].name, readings[i].percent.value); + } + } + + /* Update prev readings */ + if (n <= PROM_MAX_FANS) { + memcpy(prev, readings, n * sizeof(*readings)); + *prev_count = n; + } +} + +/* ---- main service loop ---- */ + +void service_run(service_t *svc) { + pthread_mutex_init(&svc->bus.lock, NULL); + + pthread_condattr_t cond_attr; + pthread_condattr_init(&cond_attr); + pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC); + pthread_cond_init(&svc->bus.cond, &cond_attr); + pthread_condattr_destroy(&cond_attr); + svc->bus.stop = 0; + svc->bus.updated = 0; + for (int i = 0; i < svc->monitor_count; i++) + svc->bus.speeds[i] = 0; + + /* Start sensor threads */ + for (int i = 0; i < svc->monitor_count; i++) { + svc->sensor_args[i] = (sensor_thread_arg_t){ + .sensor_name = svc->monitors[i]->name, + .monitor = svc->monitors[i], + .bus = &svc->bus, + .sensor_idx = i, + .logger = svc->logger, + .prom = svc->prom, + }; + pthread_create(&svc->sensor_threads[i], NULL, + sensor_thread, &svc->sensor_args[i]); + } + + /* Log initial fan speeds */ + fan_reading_t prev_fans[PROM_MAX_FANS] = {0}; + int prev_fan_count = 0; + log_fan_speeds(svc, prev_fans, &prev_fan_count); + + int last_speed = -1; + int pending = 0; + + /* Compute absolute deadline for next fan log */ + struct timespec fan_log_deadline; + clock_gettime(CLOCK_MONOTONIC, &fan_log_deadline); + timespec_add_sec(&fan_log_deadline, svc->cfg->fan_log_interval_sec); + + while (!g_shutdown) { + /* Wait for a speed update or fan-log timeout */ + pthread_mutex_lock(&svc->bus.lock); + while (!svc->bus.updated && !g_shutdown) { + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + struct timespec wake = now; + timespec_add_sec(&wake, SHUTDOWN_POLL_SEC); + if (timespec_lt(&fan_log_deadline, &wake)) wake = fan_log_deadline; + + int rc = pthread_cond_timedwait(&svc->bus.cond, &svc->bus.lock, + &wake); + if (rc == ETIMEDOUT) { + clock_gettime(CLOCK_MONOTONIC, &now); + if (!timespec_lt(&now, &fan_log_deadline)) { + pthread_mutex_unlock(&svc->bus.lock); + log_fan_speeds(svc, prev_fans, &prev_fan_count); + clock_gettime(CLOCK_MONOTONIC, &fan_log_deadline); + timespec_add_sec(&fan_log_deadline, svc->cfg->fan_log_interval_sec); + pthread_mutex_lock(&svc->bus.lock); + } + } + } + if (svc->bus.updated) { + /* Compute max speed across all sensors */ + int max_speed = 0; + for (int i = 0; i < svc->monitor_count; i++) + if (svc->bus.speeds[i] > max_speed) + max_speed = svc->bus.speeds[i]; + svc->bus.updated = 0; + pending = 1; + pthread_mutex_unlock(&svc->bus.lock); + + if (max_speed != last_speed) { + last_speed = max_speed; + if (svc->prom) + prom_set_system_speed(svc->prom, (double)max_speed); + + if (svc->cfg->dry_run) { + log_info(svc->logger, "dry run: skipping fan speed change", + LOG_INT("system_percent", max_speed)); + } else { + log_info(svc->logger, "setting fan speed", + LOG_INT("system_percent", max_speed)); + char errbuf[256]; + if (fan_set_speed(&svc->fan_ctrl, max_speed, + errbuf, sizeof(errbuf)) != 0) { + log_error(svc->logger, "failed to set fan speed", + LOG_STR("error", errbuf)); + } + } + } + } else { + pthread_mutex_unlock(&svc->bus.lock); + } + (void)pending; /* suppress unused warning; pattern matches Go logic */ + pending = 0; + } + + /* Signal sensor threads to stop and wait */ + pthread_mutex_lock(&svc->bus.lock); + svc->bus.stop = 1; + pthread_cond_broadcast(&svc->bus.cond); + pthread_mutex_unlock(&svc->bus.lock); + + for (int i = 0; i < svc->monitor_count; i++) + pthread_join(svc->sensor_threads[i], NULL); + + pthread_cond_destroy(&svc->bus.cond); + pthread_mutex_destroy(&svc->bus.lock); +} diff --git a/src/service.h b/src/service.h new file mode 100644 index 0000000..7e13b9d --- /dev/null +++ b/src/service.h @@ -0,0 +1,52 @@ +#ifndef FROSTD_SERVICE_H +#define FROSTD_SERVICE_H + +#include "config.h" +#include "fan.h" +#include "metrics.h" +#include "prometheus.h" +#include "log.h" + +#include +#include + +#define SERVICE_MAX_MONITORS 8 + +/* Speed bus: sensor threads post speed suggestions here; the main loop reads them. */ +typedef struct { + pthread_mutex_t lock; + pthread_cond_t cond; + int speeds[SERVICE_MAX_MONITORS]; + int updated; + int stop; +} speed_bus_t; + +typedef struct { + const char *sensor_name; /* "cpu" or "gpu" */ + sensor_monitor_t *monitor; + speed_bus_t *bus; + int sensor_idx; + logger_t *logger; + prom_metrics_t *prom; +} sensor_thread_arg_t; + +typedef struct { + frostd_config_t *cfg; + fan_controller_t fan_ctrl; + sensor_monitor_t *monitors[SERVICE_MAX_MONITORS]; + int monitor_count; + logger_t *logger; + prom_metrics_t *prom; + + speed_bus_t bus; + pthread_t sensor_threads[SERVICE_MAX_MONITORS]; + sensor_thread_arg_t sensor_args[SERVICE_MAX_MONITORS]; +} service_t; + +/* + * Run the service until g_shutdown is set (SIGTERM/SIGINT). + * Spawns one sensor thread per monitor, then runs the main loop. + */ +void service_run(service_t *svc); + +#endif /* FROSTD_SERVICE_H */ diff --git a/testhelpers_test.go b/testhelpers_test.go deleted file mode 100644 index 330a82a..0000000 --- a/testhelpers_test.go +++ /dev/null @@ -1,50 +0,0 @@ -package main - -import ( - "context" - "errors" - - ipmi "github.com/bougou/go-ipmi" -) - -// mockIPMIClient implements ipmiClient for tests. -type mockIPMIClient struct { - sensors []*ipmi.Sensor - rawErr error - connectErr error -} - -func (m *mockIPMIClient) Connect(_ context.Context) error { return m.connectErr } -func (m *mockIPMIClient) Close(_ context.Context) error { return nil } - -func (m *mockIPMIClient) GetSensors(_ context.Context, _ ...ipmi.SensorFilterOption) ([]*ipmi.Sensor, error) { - if m.rawErr != nil { - return nil, m.rawErr - } - return m.sensors, nil -} - -func (m *mockIPMIClient) RawCommand(_ context.Context, _ ipmi.NetFn, _ uint8, _ []byte, _ string) (*ipmi.CommandRawResponse, error) { - if m.rawErr != nil { - return nil, m.rawErr - } - return &ipmi.CommandRawResponse{}, nil -} - -func mockIPMIFactory(mock *mockIPMIClient) func() (ipmiClient, error) { - return func() (ipmiClient, error) { return mock, nil } -} - -func mockIPMIFactoryErr(err string) func() (ipmiClient, error) { - return func() (ipmiClient, error) { return nil, errors.New(err) } -} - -// mockRunner implements CommandRunner for tests. -type mockRunner struct { - output []byte - err error -} - -func (m *mockRunner) Run(_ string, _ ...string) ([]byte, error) { - return m.output, m.err -} diff --git a/tests/test_config.c b/tests/test_config.c new file mode 100644 index 0000000..299d3f5 --- /dev/null +++ b/tests/test_config.c @@ -0,0 +1,301 @@ +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "../src/config.h" + +static char g_tmpfile[256]; + +static char *write_temp_config(const char *content) { + strcpy(g_tmpfile, "/tmp/frostd_test_XXXXXX.yaml"); + int fd = mkstemps(g_tmpfile, 5); + if (fd < 0) return NULL; + write(fd, content, strlen(content)); + close(fd); + return g_tmpfile; +} + +static int teardown(void **state) { + (void)state; + if (g_tmpfile[0]) unlink(g_tmpfile); + g_tmpfile[0] = '\0'; + return 0; +} + +static void test_happy_path(void **state) { + (void)state; + char *path = write_temp_config( + "log_file: /var/log/frostd/frostd.log\n" + "cpu:\n" + " ideal_temp: 45\n" + " max_temp: 80\n" + " sample_size: 5\n" + " sample_interval: 10s\n" + "gpu:\n" + " ideal_temp: 50\n" + " max_temp: 85\n" + " sample_size: 4\n" + " sample_interval: 20s\n"); + assert_non_null(path); + + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_non_null(cfg); + assert_string_equal("/var/log/frostd/frostd.log", cfg->log_file); + assert_false(cfg->dry_run); + assert_non_null(cfg->cpu); + assert_float_equal(45.0, cfg->cpu->ideal_temp, 0.001); + assert_float_equal(80.0, cfg->cpu->max_temp, 0.001); + assert_int_equal(5, cfg->cpu->sample_size); + assert_float_equal(10.0, cfg->cpu->sample_interval_sec, 0.001); + assert_non_null(cfg->gpu); + assert_float_equal(50.0, cfg->gpu->ideal_temp, 0.001); + config_free(cfg); +} + +static void test_dry_run_enabled(void **state) { + (void)state; + char *path = write_temp_config( + "dry_run: true\n" + "cpu:\n" + " ideal_temp: 40\n" + " max_temp: 75\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_true(cfg->dry_run); + config_free(cfg); +} + +static void test_dry_run_default(void **state) { + (void)state; + char *path = write_temp_config("cpu: {}\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_false(cfg->dry_run); + config_free(cfg); +} + +static void test_defaults(void **state) { + (void)state; + char *path = write_temp_config("cpu: {}\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_string_equal("text", cfg->log_format); + assert_float_equal(40.0, cfg->cpu->ideal_temp, 0.001); + assert_float_equal(75.0, cfg->cpu->max_temp, 0.001); + assert_int_equal(3, cfg->cpu->sample_size); + assert_float_equal(15.0, cfg->cpu->sample_interval_sec, 0.001); + config_free(cfg); +} + +static void test_log_format_json(void **state) { + (void)state; + char *path = write_temp_config("log_format: json\ncpu: {}\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_string_equal("json", cfg->log_format); + config_free(cfg); +} + +static void test_log_format_invalid(void **state) { + (void)state; + char *path = write_temp_config("log_format: xml\ncpu: {}\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + int rc = config_load(path, &cfg, errbuf, sizeof(errbuf)); + assert_int_not_equal(0, rc); + assert_non_null(strstr(errbuf, "log_format")); +} + +static void test_no_devices(void **state) { + (void)state; + char *path = write_temp_config("log_file: /tmp/test.log\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + int rc = config_load(path, &cfg, errbuf, sizeof(errbuf)); + assert_int_not_equal(0, rc); + assert_non_null(strstr(errbuf, "at least one sensor type")); +} + +static void test_ideal_temp_equal_max_temp(void **state) { + (void)state; + char *path = write_temp_config( + "cpu:\n" + " ideal_temp: 75\n" + " max_temp: 75\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_not_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); +} + +static void test_ideal_temp_greater_than_max_temp(void **state) { + (void)state; + char *path = write_temp_config( + "cpu:\n" + " ideal_temp: 80\n" + " max_temp: 75\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_not_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); +} + +static void test_sample_size_negative(void **state) { + (void)state; + char *path = write_temp_config( + "cpu:\n" + " ideal_temp: 40\n" + " max_temp: 75\n" + " sample_size: -1\n" + " sample_interval: 15s\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + int rc = config_load(path, &cfg, errbuf, sizeof(errbuf)); + assert_int_not_equal(0, rc); + assert_non_null(strstr(errbuf, "sample_size")); +} + +static void test_negative_sample_interval(void **state) { + (void)state; + char *path = write_temp_config( + "cpu:\n" + " ideal_temp: 40\n" + " max_temp: 75\n" + " sample_size: 3\n" + " sample_interval: -5s\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + int rc = config_load(path, &cfg, errbuf, sizeof(errbuf)); + assert_int_not_equal(0, rc); + assert_non_null(strstr(errbuf, "sample_interval")); +} + +static void test_invalid_yaml(void **state) { + (void)state; + char *path = write_temp_config(":::invalid yaml:::\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_not_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); +} + +static void test_missing_file(void **state) { + (void)state; + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_not_equal(0, + config_load("/nonexistent/path/frostd.yaml", &cfg, errbuf, sizeof(errbuf))); +} + +static void test_prometheus_with_listen_addr(void **state) { + (void)state; + char *path = write_temp_config( + "cpu: {}\n" + "prometheus:\n" + " listen_addr: \":9100\"\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_non_null(cfg->prometheus); + assert_string_equal(":9100", cfg->prometheus->listen_addr); + config_free(cfg); +} + +static void test_prometheus_absent(void **state) { + (void)state; + char *path = write_temp_config("cpu: {}\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_null(cfg->prometheus); + config_free(cfg); +} + +static void test_prometheus_empty_listen_addr(void **state) { + (void)state; + char *path = write_temp_config("cpu: {}\nprometheus: {}\n"); + frostd_config_t *cfg = NULL; + char errbuf[256]; + assert_int_equal(0, config_load(path, &cfg, errbuf, sizeof(errbuf))); + assert_non_null(cfg->prometheus); + /* listen_addr omitted → NULL pointer */ + assert_null(cfg->prometheus->listen_addr); + config_free(cfg); +} + +static void test_parse_duration_seconds(void **state) { + (void)state; + double sec; + assert_int_equal(0, parse_duration("15s", &sec)); + assert_float_equal(15.0, sec, 0.001); +} + +static void test_parse_duration_minutes(void **state) { + (void)state; + double sec; + assert_int_equal(0, parse_duration("2m", &sec)); + assert_float_equal(120.0, sec, 0.001); +} + +static void test_parse_duration_hours(void **state) { + (void)state; + double sec; + assert_int_equal(0, parse_duration("1h", &sec)); + assert_float_equal(3600.0, sec, 0.001); +} + +static void test_parse_duration_bare_number(void **state) { + (void)state; + double sec; + assert_int_equal(0, parse_duration("30", &sec)); + assert_float_equal(30.0, sec, 0.001); +} + +static void test_parse_duration_negative(void **state) { + (void)state; + double sec; + assert_int_not_equal(0, parse_duration("-5s", &sec)); +} + +static void test_parse_duration_invalid(void **state) { + (void)state; + double sec; + assert_int_not_equal(0, parse_duration("abc", &sec)); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test_teardown(test_happy_path, teardown), + cmocka_unit_test_teardown(test_dry_run_enabled, teardown), + cmocka_unit_test_teardown(test_dry_run_default, teardown), + cmocka_unit_test_teardown(test_defaults, teardown), + cmocka_unit_test_teardown(test_log_format_json, teardown), + cmocka_unit_test_teardown(test_log_format_invalid, teardown), + cmocka_unit_test_teardown(test_no_devices, teardown), + cmocka_unit_test_teardown(test_ideal_temp_equal_max_temp, teardown), + cmocka_unit_test_teardown(test_ideal_temp_greater_than_max_temp, teardown), + cmocka_unit_test_teardown(test_sample_size_negative, teardown), + cmocka_unit_test_teardown(test_negative_sample_interval, teardown), + cmocka_unit_test_teardown(test_invalid_yaml, teardown), + cmocka_unit_test_teardown(test_missing_file, teardown), + cmocka_unit_test_teardown(test_prometheus_with_listen_addr, teardown), + cmocka_unit_test_teardown(test_prometheus_absent, teardown), + cmocka_unit_test_teardown(test_prometheus_empty_listen_addr, teardown), + cmocka_unit_test(test_parse_duration_seconds), + cmocka_unit_test(test_parse_duration_minutes), + cmocka_unit_test(test_parse_duration_hours), + cmocka_unit_test(test_parse_duration_bare_number), + cmocka_unit_test(test_parse_duration_negative), + cmocka_unit_test(test_parse_duration_invalid), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/tests/test_cpu.c b/tests/test_cpu.c new file mode 100644 index 0000000..eb25155 --- /dev/null +++ b/tests/test_cpu.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include + +#include +#include +#include + +#include "test_helpers.h" +#include "../src/cpu.h" + +static void test_returns_processor_temps(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = { + .temp_sensors = { + {.name = "CPU1 Temp", .value = 45.0}, + {.name = "CPU2 Temp", .value = 50.0}, + {.name = "", .value = 23.0}, /* inlet — no name → filtered */ + }, + .temp_count = 3, + }; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + cpu_reader_t *r = cpu_reader_new(&ops); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = cpu_read_temperatures(r, ids, temps, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + + assert_int_equal(2, n); + double t_cpu1 = -1, t_cpu2 = -1; + for (int i = 0; i < n; i++) { + if (strcmp(ids[i], "CPU1 Temp") == 0) t_cpu1 = temps[i]; + if (strcmp(ids[i], "CPU2 Temp") == 0) t_cpu2 = temps[i]; + } + assert_float_equal(45.0, t_cpu1, 0.001); + assert_float_equal(50.0, t_cpu2, 0.001); + + cpu_reader_free(r); +} + +static void test_deduplicates_sensor_names(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = { + .temp_sensors = { + {.name = "Temp", .value = 45.0}, + {.name = "Temp", .value = 50.0}, + {.name = "Temp", .value = 55.0}, + }, + .temp_count = 3, + }; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + cpu_reader_t *r = cpu_reader_new(&ops); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = cpu_read_temperatures(r, ids, temps, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + + assert_int_equal(3, n); + double t1 = -1, t2 = -1, t3 = -1; + for (int i = 0; i < n; i++) { + if (strcmp(ids[i], "Temp") == 0) t1 = temps[i]; + if (strcmp(ids[i], "Temp_2") == 0) t2 = temps[i]; + if (strcmp(ids[i], "Temp_3") == 0) t3 = temps[i]; + } + assert_float_equal(45.0, t1, 0.001); + assert_float_equal(50.0, t2, 0.001); + assert_float_equal(55.0, t3, 0.001); + + cpu_reader_free(r); +} + +static void test_ignores_non_processor_sensors(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = { + .temp_sensors = {{.name = "Inlet Temp", .value = 23.0}}, + .temp_count = 1, + }; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + cpu_reader_t *r = cpu_reader_new(&ops); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = cpu_read_temperatures(r, ids, temps, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + assert_int_equal(-1, n); + assert_non_null(strstr(errbuf, "no CPU temperature sensors found")); + + cpu_reader_free(r); +} + +static void test_empty_sensor_list(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.temp_count = 0}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + cpu_reader_t *r = cpu_reader_new(&ops); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + assert_int_equal(-1, + cpu_read_temperatures(r, ids, temps, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf))); + + cpu_reader_free(r); +} + +static void test_connect_error(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.connect_fail = 1}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + cpu_reader_t *r = cpu_reader_new(&ops); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + assert_int_equal(-1, + cpu_read_temperatures(r, ids, temps, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf))); + + cpu_reader_free(r); +} + +static void test_sensors_error(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.temp_fail = 1}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + cpu_reader_t *r = cpu_reader_new(&ops); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + assert_int_equal(-1, + cpu_read_temperatures(r, ids, temps, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf))); + + cpu_reader_free(r); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_returns_processor_temps), + cmocka_unit_test(test_deduplicates_sensor_names), + cmocka_unit_test(test_ignores_non_processor_sensors), + cmocka_unit_test(test_empty_sensor_list), + cmocka_unit_test(test_connect_error), + cmocka_unit_test(test_sensors_error), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/tests/test_fan.c b/tests/test_fan.c new file mode 100644 index 0000000..a6d1bcd --- /dev/null +++ b/tests/test_fan.c @@ -0,0 +1,169 @@ +#include +#include +#include +#include + +#include +#include + +#include "test_helpers.h" +#include "../src/fan.h" + +/* ---- SuggestSpeed tests ---- */ + +static void test_suggest_speed_at_ideal(void **state) { + (void)state; + assert_int_equal(0, suggest_speed(40.0, 40.0, 75.0)); +} + +static void test_suggest_speed_below_ideal(void **state) { + (void)state; + assert_int_equal(0, suggest_speed(35.0, 40.0, 75.0)); +} + +static void test_suggest_speed_at_max(void **state) { + (void)state; + assert_int_equal(100, suggest_speed(75.0, 40.0, 75.0)); +} + +static void test_suggest_speed_above_max(void **state) { + (void)state; + assert_int_equal(100, suggest_speed(90.0, 40.0, 75.0)); +} + +static void test_suggest_speed_midpoint(void **state) { + (void)state; + /* ideal=40, max=75, actual=57.5 → (17.5)^2 * (100/1225) = 25 */ + assert_int_equal(25, suggest_speed(57.5, 40.0, 75.0)); +} + +static void test_suggest_speed_three_quarter(void **state) { + (void)state; + /* actual = 40 + 0.75*35 = 66.25 → (26.25)^2 * (100/1225) ≈ 56.25 → 56 */ + assert_int_equal(56, suggest_speed(66.25, 40.0, 75.0)); +} + +/* ---- fan_set_speed tests ---- */ + +static void test_set_speed_ok(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {0}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + char errbuf[256]; + assert_int_equal(0, fan_set_speed(&ctrl, 50, errbuf, sizeof(errbuf))); + assert_int_equal(2, mctx.raw_call_count); +} + +static void test_set_speed_out_of_range(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {0}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + char errbuf[256]; + assert_int_equal(-1, fan_set_speed(&ctrl, 101, errbuf, sizeof(errbuf))); + assert_int_equal(-1, fan_set_speed(&ctrl, -1, errbuf, sizeof(errbuf))); +} + +static void test_set_speed_ipmi_error(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.raw_fail = 1}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + char errbuf[256]; + assert_int_equal(-1, fan_set_speed(&ctrl, 50, errbuf, sizeof(errbuf))); +} + +static void test_set_speed_connect_error(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.connect_fail = 1}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + char errbuf[256]; + assert_int_equal(-1, fan_set_speed(&ctrl, 50, errbuf, sizeof(errbuf))); +} + +/* ---- fan_read_speeds tests ---- */ + +static void test_read_fan_speeds_rpm(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = { + .fan_sensors = {{ + .name = "Fan1", + .has_rpm = 1, .rpm = 3600.0, + .has_percent = 0, + }}, + .fan_count = 1, + }; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + fan_reading_t readings[16]; + char errbuf[256]; + int n = fan_read_speeds(&ctrl, readings, 16, errbuf, sizeof(errbuf)); + assert_int_equal(1, n); + assert_string_equal("Fan1", readings[0].name); + assert_true(readings[0].rpm.valid); + assert_float_equal(3600.0, readings[0].rpm.value, 0.001); + assert_false(readings[0].percent.valid); +} + +static void test_read_fan_speeds_percent(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = { + .fan_sensors = {{ + .name = "Fan1", + .has_percent = 1, .percent = 50.0, + .has_rpm = 0, + }}, + .fan_count = 1, + }; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + fan_reading_t readings[16]; + char errbuf[256]; + int n = fan_read_speeds(&ctrl, readings, 16, errbuf, sizeof(errbuf)); + assert_int_equal(1, n); + assert_true(readings[0].percent.valid); + assert_float_equal(50.0, readings[0].percent.value, 0.001); + assert_false(readings[0].rpm.valid); +} + +static void test_read_fan_speeds_ipmi_error(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.fan_fail = 1}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + fan_reading_t readings[16]; + char errbuf[256]; + assert_int_equal(-1, fan_read_speeds(&ctrl, readings, 16, errbuf, sizeof(errbuf))); +} + +static void test_read_fan_speeds_connect_error(void **state) { + (void)state; + mock_ipmi_ctx_t mctx = {.connect_fail = 1}; + ipmi_ops_t ops = make_mock_ipmi(&mctx); + fan_controller_t ctrl = {.ops = &ops}; + fan_reading_t readings[16]; + char errbuf[256]; + assert_int_equal(-1, fan_read_speeds(&ctrl, readings, 16, errbuf, sizeof(errbuf))); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_suggest_speed_at_ideal), + cmocka_unit_test(test_suggest_speed_below_ideal), + cmocka_unit_test(test_suggest_speed_at_max), + cmocka_unit_test(test_suggest_speed_above_max), + cmocka_unit_test(test_suggest_speed_midpoint), + cmocka_unit_test(test_suggest_speed_three_quarter), + cmocka_unit_test(test_set_speed_ok), + cmocka_unit_test(test_set_speed_out_of_range), + cmocka_unit_test(test_set_speed_ipmi_error), + cmocka_unit_test(test_set_speed_connect_error), + cmocka_unit_test(test_read_fan_speeds_rpm), + cmocka_unit_test(test_read_fan_speeds_percent), + cmocka_unit_test(test_read_fan_speeds_ipmi_error), + cmocka_unit_test(test_read_fan_speeds_connect_error), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/tests/test_gpu.c b/tests/test_gpu.c new file mode 100644 index 0000000..a78c435 --- /dev/null +++ b/tests/test_gpu.c @@ -0,0 +1,98 @@ +#include +#include +#include +#include + +#include +#include +#include + +#include "test_helpers.h" +#include "../src/gpu.h" + +/* ---- parse_gpu_temps tests ---- */ + +static void test_parse_single_gpu(void **state) { + (void)state; + char ids[16][64]; + double temps[16]; + char errbuf[256]; + int n = parse_gpu_temps("72\n", ids, temps, 16, errbuf, sizeof(errbuf)); + assert_int_equal(1, n); + assert_string_equal("Temp", ids[0]); + assert_float_equal(72.0, temps[0], 0.001); +} + +static void test_parse_multiple_gpus(void **state) { + (void)state; + char ids[16][64]; + double temps[16]; + char errbuf[256]; + int n = parse_gpu_temps("68\n74\n", ids, temps, 16, errbuf, sizeof(errbuf)); + assert_int_equal(2, n); + assert_string_equal("Temp", ids[0]); + assert_float_equal(68.0, temps[0], 0.001); + assert_string_equal("Temp_2", ids[1]); + assert_float_equal(74.0, temps[1], 0.001); +} + +static void test_parse_empty_output(void **state) { + (void)state; + char ids[16][64]; + double temps[16]; + char errbuf[256]; + assert_int_equal(-1, parse_gpu_temps("", ids, temps, 16, errbuf, sizeof(errbuf))); +} + +static void test_parse_invalid_line(void **state) { + (void)state; + char ids[16][64]; + double temps[16]; + char errbuf[256]; + assert_int_equal(-1, parse_gpu_temps("not a number\n", ids, temps, 16, errbuf, sizeof(errbuf))); +} + +/* ---- gpu_read_temperatures tests ---- */ + +static void test_read_temperatures_calls_nvidia_smi(void **state) { + (void)state; + mock_runner_ctx_t rctx = {.output = "72\n"}; + cmd_runner_t runner = make_mock_runner(&rctx); + gpu_reader_t *r = gpu_reader_new(runner); + + char ids[16][64]; + double temps[16]; + char errbuf[256]; + int n = gpu_read_temperatures(r, ids, temps, 16, errbuf, sizeof(errbuf)); + assert_int_equal(1, n); + assert_string_equal("Temp", ids[0]); + assert_float_equal(72.0, temps[0], 0.001); + + gpu_reader_free(r); +} + +static void test_read_temperatures_command_error(void **state) { + (void)state; + mock_runner_ctx_t rctx = {.output = NULL}; + cmd_runner_t runner = make_mock_runner(&rctx); + gpu_reader_t *r = gpu_reader_new(runner); + + char ids[16][64]; + double temps[16]; + char errbuf[256]; + assert_int_equal(-1, gpu_read_temperatures(r, ids, temps, 16, errbuf, sizeof(errbuf))); + + gpu_reader_free(r); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_parse_single_gpu), + cmocka_unit_test(test_parse_multiple_gpus), + cmocka_unit_test(test_parse_empty_output), + cmocka_unit_test(test_parse_invalid_line), + cmocka_unit_test(test_read_temperatures_calls_nvidia_smi), + cmocka_unit_test(test_read_temperatures_command_error), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/tests/test_helpers.c b/tests/test_helpers.c new file mode 100644 index 0000000..e6afa51 --- /dev/null +++ b/tests/test_helpers.c @@ -0,0 +1,84 @@ +#include "test_helpers.h" + +#include +#include + +/* ---- Mock IPMI vtable functions ---- */ + +static int mock_connect(void *impl) { + mock_ipmi_ctx_t *m = impl; + return m->connect_fail ? -1 : 0; +} + +static void mock_close(void *impl) { + (void)impl; +} + +static int mock_get_temp_sensors(void *impl, temp_sensor_raw_t *out, int max) { + mock_ipmi_ctx_t *m = impl; + if (m->temp_fail) return -1; + int n = (m->temp_count < max) ? m->temp_count : max; + memcpy(out, m->temp_sensors, n * sizeof(*out)); + return n; +} + +static int mock_get_fan_sensors(void *impl, fan_reading_raw_t *out, int max) { + mock_ipmi_ctx_t *m = impl; + if (m->fan_fail) return -1; + int n = (m->fan_count < max) ? m->fan_count : max; + memcpy(out, m->fan_sensors, n * sizeof(*out)); + return n; +} + +static int mock_raw_command(void *impl, uint8_t netfn, uint8_t cmd, + const uint8_t *data, int data_len, + uint8_t *resp, int *resp_len) { + mock_ipmi_ctx_t *m = impl; + m->last_raw_netfn = netfn; + m->last_raw_cmd = cmd; + int dlen = (data_len < 32) ? data_len : 32; + memcpy(m->last_raw_data, data, dlen); + m->last_raw_data_len = dlen; + m->raw_call_count++; + (void)resp; (void)resp_len; + return m->raw_fail ? -1 : 0; +} + +static const char *mock_last_error(void *impl) { + mock_ipmi_ctx_t *m = impl; + return m->errmsg[0] ? m->errmsg : "mock error"; +} + +ipmi_ops_t make_mock_ipmi(mock_ipmi_ctx_t *ctx) { + return (ipmi_ops_t){ + .connect = mock_connect, + .close = mock_close, + .get_temp_sensors = mock_get_temp_sensors, + .get_fan_sensors = mock_get_fan_sensors, + .raw_command = mock_raw_command, + .last_error = mock_last_error, + .impl = ctx, + }; +} + +/* ---- Mock command runner ---- */ + +static int mock_run(void *ctx, + const char *prog, const char *const *args, + char *buf, int buflen, char *errbuf, int errbuflen) { + (void)prog; (void)args; + mock_runner_ctx_t *r = ctx; + if (!r->output) { + snprintf(errbuf, errbuflen, "nvidia-smi not found"); + return -1; + } + int n = (int)strlen(r->output); + if (n >= buflen) n = buflen - 1; + memcpy(buf, r->output, n); + buf[n] = '\0'; + return n; +} + +cmd_runner_t make_mock_runner(mock_runner_ctx_t *ctx) { + return (cmd_runner_t){mock_run, ctx}; +} diff --git a/tests/test_helpers.h b/tests/test_helpers.h new file mode 100644 index 0000000..d2516ce --- /dev/null +++ b/tests/test_helpers.h @@ -0,0 +1,40 @@ +#ifndef FROSTD_TEST_HELPERS_H +#define FROSTD_TEST_HELPERS_H + +#include + +#include "../src/ipmi.h" +#include "../src/metrics.h" + +/* ---- Mock IPMI context ---- */ + +typedef struct { + temp_sensor_raw_t temp_sensors[IPMI_MAX_SENSORS]; + int temp_count; + fan_reading_raw_t fan_sensors[IPMI_MAX_SENSORS]; + int fan_count; + int connect_fail; + int temp_fail; + int fan_fail; + int raw_fail; + uint8_t last_raw_netfn; + uint8_t last_raw_cmd; + uint8_t last_raw_data[32]; + int last_raw_data_len; + int raw_call_count; + char errmsg[128]; +} mock_ipmi_ctx_t; + +ipmi_ops_t make_mock_ipmi(mock_ipmi_ctx_t *ctx); + +/* ---- Mock command runner ---- */ + +typedef struct { + const char *output; /* NULL → return error */ +} mock_runner_ctx_t; + +/* Returns a cmd_runner_t backed by mock_runner_ctx_t */ +#include "../src/gpu.h" +cmd_runner_t make_mock_runner(mock_runner_ctx_t *ctx); + +#endif /* FROSTD_TEST_HELPERS_H */ diff --git a/tests/test_metrics.c b/tests/test_metrics.c new file mode 100644 index 0000000..275d18b --- /dev/null +++ b/tests/test_metrics.c @@ -0,0 +1,194 @@ +#include +#include +#include +#include + +#include +#include +#include + +#include "../src/metrics.h" +#include "../src/config.h" + +/* --- static test reader --- */ +typedef struct { + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS]; + int count; + int fail; /* non-zero to return error */ +} static_reader_ctx_t; + +static int static_read(void *ctx, + char out_ids[][64], double *out_temps, int max, + char *errbuf, int errbuflen) { + static_reader_ctx_t *r = ctx; + if (r->fail) { + snprintf(errbuf, errbuflen, "ipmitool failed"); + return -1; + } + int n = (r->count < max) ? r->count : max; + for (int i = 0; i < n; i++) { + strncpy(out_ids[i], r->ids[i], 64); + out_temps[i] = r->temps[i]; + } + return n; +} + +static sensor_config_t *make_sensor_config(int sample_size) { + sensor_config_t *cfg = calloc(1, sizeof(*cfg)); + cfg->ideal_temp = 40.0; + cfg->max_temp = 75.0; + cfg->sample_size = sample_size; + cfg->sample_interval_sec = 15.0; + return cfg; +} + +/* --- tests --- */ + +static void test_accumulates_samples(void **state) { + (void)state; + static_reader_ctx_t rctx = { + .ids = {"s0", "s1"}, + .temps = {50.0, 60.0}, + .count = 2, + }; + sensor_config_t *cfg = make_sensor_config(3); + sensor_monitor_t *m = sensor_monitor_new("cpu", cfg, (temp_reader_t){static_read, &rctx}); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS], aggs[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = sensor_monitor_poll(m, ids, temps, aggs, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + + assert_int_equal(2, n); + /* find s0 and s1 */ + double agg_s0 = -1, agg_s1 = -1; + for (int i = 0; i < n; i++) { + if (strcmp(ids[i], "s0") == 0) agg_s0 = aggs[i]; + if (strcmp(ids[i], "s1") == 0) agg_s1 = aggs[i]; + } + assert_float_equal(50.0, agg_s0, 0.001); + assert_float_equal(60.0, agg_s1, 0.001); + + sensor_monitor_free(m); + free(cfg); +} + +static void test_caps_samples_at_sample_size(void **state) { + (void)state; + static_reader_ctx_t rctx = {.ids = {"s0"}, .temps = {0.0}, .count = 1}; + sensor_config_t *cfg = make_sensor_config(3); + sensor_monitor_t *m = sensor_monitor_new("cpu", cfg, (temp_reader_t){static_read, &rctx}); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS], aggs[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + + double poll_vals[] = {0.0, 10.0, 20.0, 30.0, 40.0}; + for (int i = 0; i < 5; i++) { + rctx.temps[0] = poll_vals[i]; + sensor_monitor_poll(m, ids, temps, aggs, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + } + + /* After 5 polls with sample_size=3, last 3 values are 20, 30, 40 */ + char agg_ids[METRICS_MAX_SENSOR_IDS][64]; + double agg_vals[METRICS_MAX_SENSOR_IDS]; + int nc = sensor_monitor_aggregates(m, agg_ids, agg_vals, METRICS_MAX_SENSOR_IDS); + assert_int_equal(1, nc); + assert_float_equal((20.0 + 30.0 + 40.0) / 3.0, agg_vals[0], 0.001); + + sensor_monitor_free(m); + free(cfg); +} + +static void test_aggregates_before_any_polls(void **state) { + (void)state; + static_reader_ctx_t rctx = {.ids = {"s0"}, .temps = {50.0}, .count = 1}; + sensor_config_t *cfg = make_sensor_config(3); + sensor_monitor_t *m = sensor_monitor_new("cpu", cfg, (temp_reader_t){static_read, &rctx}); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double aggs[METRICS_MAX_SENSOR_IDS]; + int n = sensor_monitor_aggregates(m, ids, aggs, METRICS_MAX_SENSOR_IDS); + assert_int_equal(0, n); + + sensor_monitor_free(m); + free(cfg); +} + +static void test_reader_error(void **state) { + (void)state; + static_reader_ctx_t rctx = {.fail = 1}; + sensor_config_t *cfg = make_sensor_config(3); + sensor_monitor_t *m = sensor_monitor_new("cpu", cfg, (temp_reader_t){static_read, &rctx}); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS], aggs[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = sensor_monitor_poll(m, ids, temps, aggs, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + assert_int_equal(-1, n); + + sensor_monitor_free(m); + free(cfg); +} + +static void test_empty_readings(void **state) { + (void)state; + static_reader_ctx_t rctx = {.count = 0}; + sensor_config_t *cfg = make_sensor_config(3); + sensor_monitor_t *m = sensor_monitor_new("cpu", cfg, (temp_reader_t){static_read, &rctx}); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS], aggs[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + int n = sensor_monitor_poll(m, ids, temps, aggs, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + assert_int_equal(-1, n); + + sensor_monitor_free(m); + free(cfg); +} + +static void test_multiple_sensor_ids_independent_aggregates(void **state) { + (void)state; + static_reader_ctx_t rctx = { + .ids = {"s0", "s1"}, + .temps = {50.0, 70.0}, + .count = 2, + }; + sensor_config_t *cfg = make_sensor_config(2); + sensor_monitor_t *m = sensor_monitor_new("cpu", cfg, (temp_reader_t){static_read, &rctx}); + + char ids[METRICS_MAX_SENSOR_IDS][64]; + double temps[METRICS_MAX_SENSOR_IDS], aggs[METRICS_MAX_SENSOR_IDS]; + char errbuf[256]; + + sensor_monitor_poll(m, ids, temps, aggs, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + + rctx.temps[0] = 60.0; + rctx.temps[1] = 80.0; + int n = sensor_monitor_poll(m, ids, temps, aggs, METRICS_MAX_SENSOR_IDS, errbuf, sizeof(errbuf)); + assert_int_equal(2, n); + + double agg_s0 = -1, agg_s1 = -1; + for (int i = 0; i < n; i++) { + if (strcmp(ids[i], "s0") == 0) agg_s0 = aggs[i]; + if (strcmp(ids[i], "s1") == 0) agg_s1 = aggs[i]; + } + assert_float_equal((50.0 + 60.0) / 2.0, agg_s0, 0.001); + assert_float_equal((70.0 + 80.0) / 2.0, agg_s1, 0.001); + + sensor_monitor_free(m); + free(cfg); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_accumulates_samples), + cmocka_unit_test(test_caps_samples_at_sample_size), + cmocka_unit_test(test_aggregates_before_any_polls), + cmocka_unit_test(test_reader_error), + cmocka_unit_test(test_empty_readings), + cmocka_unit_test(test_multiple_sensor_ids_independent_aggregates), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +}