fix(cli): restore fan settings when fan init is interrupted

The measurement leaves the fan in manual mode at whatever PWM value was
probed last. Interrupting the CLI initialization with SIGINT/SIGTERM killed
the process without any cleanup, leaving the fan stuck there.

Split RunInitialization() into a public wrapper that captures the fan state
and owns the restore on any failure, and a private worker holding the
sequence itself. The initialization sequence is context-aware, so the CLI
cancels the context via signal.NotifyContext on SIGINT/SIGTERM and the
controller restores the fan state on its own, without the CLI knowing
anything about fan state internals.

Author: epicfail

cmd/fan/init.go

@@ -1,6 +1,11 @@
 package fan
 
 import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+
 	"github.com/markusressel/fan2go/internal"
 	"github.com/markusressel/fan2go/internal/configuration"
 	"github.com/markusressel/fan2go/internal/control_loop"
@@ -56,7 +61,10 @@ var initCmd = &cobra.Command{
 			return err
 		}
 
-		_, err = fanController.RunInitialization()
+		ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+		defer stop()
+
+		_, err = fanController.RunInitialization(ctx)
 		if err == nil {
 			ui.Success("Done!")
 			// print measured fan curve

internal/controller/controller.go

@@ -46,6 +46,9 @@ type FanController interface {
 
 	// UpdateCurve dynamically updates the curve reference
 	UpdateCurve(curve curves.SpeedCurve)
+
+	// RunInitialization runs the fan initialization sequence.
+	RunInitialization(ctx context.Context) (map[int]float64, error)
 }
 
 type FanStateSnapshot struct {
@@ -231,7 +234,7 @@ func (f *DefaultFanController) Run(ctx context.Context) error {
 	// wait a bit to gather monitoring data
 	time.Sleep(2*time.Second + configuration.CurrentConfig.TempSensorPollingRate)
 
-	fanPwmData, err := f.runInitializationIfNeeded()
+	fanPwmData, err := f.runInitializationIfNeeded(ctx)
 	if err != nil {
 		return err
 	}
@@ -344,7 +347,7 @@ func (f *DefaultFanController) Run(ctx context.Context) error {
 	return err
 }
 
-func (f *DefaultFanController) runInitializationIfNeeded() (map[int]float64, error) {
+func (f *DefaultFanController) runInitializationIfNeeded(ctx context.Context) (map[int]float64, error) {
 	fan := f.fan
 	// check if we have data for this fan in persistence,
 	// if not we need to run the initialization sequence
@@ -354,7 +357,7 @@ func (f *DefaultFanController) runInitializationIfNeeded() (map[int]float64, err
 		config := fan.GetConfig()
 		if config.HwMon != nil || config.Nvidia != nil {
 			ui.Warning("Fan '%s' has not yet been analyzed, starting initialization sequence...", fan.GetId())
-			fanCurveData, err := f.RunInitialization()
+			fanCurveData, err := f.RunInitialization(ctx)
 			if err != nil {
 				return nil, err
 			}
@@ -368,25 +371,32 @@ func (f *DefaultFanController) runInitializationIfNeeded() (map[int]float64, err
 	return fanRpmData, err
 }
 
-func (f *DefaultFanController) RunInitialization() (map[int]float64, error) {
-	fan := f.fan
-
-	// the `fan init` CLI command calls this directly (without Run()), so the original fan state may not have been captured yet
+func (f *DefaultFanController) RunInitialization(ctx context.Context) (map[int]float64, error) {
 	err := f.storeCurrentFanState()
 	if err != nil {
 		return nil, err
 	}
 
-	err = f.computeFanSpecificMappings()
+	curveData, err := f.runInitialization(ctx)
+	if err != nil {
+		f.restoreControlMode()
+		return nil, err
+	}
+	return curveData, nil
+}
+
+func (f *DefaultFanController) runInitialization(ctx context.Context) (map[int]float64, error) {
+	fan := f.fan
+
+	err := f.computeFanSpecificMappings()
 	if err != nil {
 		ui.Error("Fan %s: Error computing fan specific mappings: %v", fan.GetId(), err)
 		return nil, err
 	}
 
 	fanAnalyzer := NewFanCurveAnalyzer(f)
-	curveData, err := fanAnalyzer.RunInitializationSequence()
+	curveData, err := fanAnalyzer.RunInitializationSequence(ctx)
 	if err != nil {
-		f.restoreControlMode()
 		return nil, err
 	}
 
@@ -407,7 +417,6 @@ func (f *DefaultFanController) RunInitialization() (map[int]float64, error) {
 
 	fanRpmData, err := f.persistence.LoadFanRpmData(fan)
 	if err != nil {
-		f.restoreControlMode()
 		return nil, err
 	}
 

internal/controller/controller_test.go

@@ -2121,7 +2121,7 @@ func TestRunInitialization_FailedInit_RestoresOriginalControlMode(t *testing.T)
 		updateRate:  time.Duration(100),
 	}
 
-	_, err := controller.RunInitialization()
+	_, err := controller.RunInitialization(context.Background())
 
 	assert.Error(t, err)
 	assert.NotContains(t, fan.controlModeHistory, fans.ControlModeDisabled,
@@ -2130,6 +2130,50 @@ func TestRunInitialization_FailedInit_RestoresOriginalControlMode(t *testing.T)
 		"failed init must restore the original (automatic) control mode")
 }
 
+func TestRunInitialization_Cancelled_RestoresOriginalControlMode(t *testing.T) {
+	originalConfig := configuration.CurrentConfig
+	defer func() {
+		configuration.CurrentConfig = originalConfig
+	}()
+	configuration.CurrentConfig.FanController.PwmSetDelay = 1 * time.Millisecond
+	// non-zero so the cancelled context is the only ready channel in sleepWithContext
+	configuration.CurrentConfig.FanResponseDelay = 1
+	configuration.CurrentConfig.Analysis.SampleCount = 1
+	configuration.CurrentConfig.Analysis.SampleDelay = 0
+	configuration.CurrentConfig.Analysis.SettleTimeout = 0
+
+	fan := &mockFanForFailedInit{
+		MockFan: MockFan{
+			ID:          "fan",
+			RPM:         0,
+			ControlMode: fans.ControlModeAutomatic,
+			PwmMap:      &configuration.PwmMapConfig{Identity: &configuration.PwmMapIdentityConfig{}},
+			SetPwmToGetPwmMap: &configuration.SetPwmToGetPwmMapConfig{
+				Identity: &configuration.SetPwmToGetPwmMapIdentityConfig{},
+			},
+			ControlModeConfig: &configuration.ControlModeConfig{
+				OnExit: &configuration.OnExitConfig{Restore: &configuration.OnExitRestoreConfig{}},
+			},
+		},
+	}
+	controller := DefaultFanController{
+		persistence: mockPersistence{hasPwmMap: false},
+		fan:         fan,
+		updateRate:  time.Duration(100),
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	_, err := controller.RunInitialization(ctx)
+
+	assert.True(t, errors.Is(err, context.Canceled))
+	assert.NotContains(t, fan.controlModeHistory, fans.ControlModeDisabled,
+		"the zero value of ControlMode must never be written to the fan")
+	assert.Equal(t, fans.ControlModeAutomatic, fan.ControlMode,
+		"cancelled init must restore the original (automatic) control mode")
+}
+
 // --- setPwmToGetPwmMap / pwmMap edge-case tests ---
 
 func TestFanController_ComputeSetPwmToGetPwmMap_AllWritesFail(t *testing.T) {

internal/controller/fan_analysis.go

@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"context"
 	"fmt"
 	"math"
 	"sort"
@@ -14,6 +15,15 @@ import (
 
 const pwmMismatchRetries = 2
 
+func sleepWithContext(ctx context.Context, d time.Duration) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-time.After(d):
+		return nil
+	}
+}
+
 type FanCurveAnalyzer struct {
 	fanController *DefaultFanController
 }
@@ -26,7 +36,7 @@ func NewFanCurveAnalyzer(
 	}
 }
 
-func (f *FanCurveAnalyzer) RunInitializationSequence() (rpmCurve map[int]float64, err error) {
+func (f *FanCurveAnalyzer) RunInitializationSequence(ctx context.Context) (rpmCurve map[int]float64, err error) {
 	fan := f.fanController.fan
 
 	if !fan.Supports(fans.FeatureRpmSensor) {
@@ -51,21 +61,21 @@ func (f *FanCurveAnalyzer) RunInitializationSequence() (rpmCurve map[int]float64
 	initStarted := time.Now()
 
 	startBoundaryStarted := time.Now()
-	startIdx, _, err := f.detectStartBoundary(fan, distinct, curveData)
+	startIdx, _, err := f.detectStartBoundary(ctx, fan, distinct, curveData)
 	if err != nil {
 		return nil, err
 	}
 	ui.Info("Fan %s: Boundary discovery (start) finished in %s", fan.GetId(), time.Since(startBoundaryStarted).Round(time.Millisecond))
 
 	maxBoundaryStarted := time.Now()
-	maxIdx, _, err := f.detectMaxBoundary(fan, distinct, startIdx, curveData)
+	maxIdx, _, err := f.detectMaxBoundary(ctx, fan, distinct, startIdx, curveData)
 	if err != nil {
 		return nil, err
 	}
 	ui.Info("Fan %s: Boundary discovery (max) finished in %s", fan.GetId(), time.Since(maxBoundaryStarted).Round(time.Millisecond))
 
 	interiorStarted := time.Now()
-	curveData, err = f.sampleInteriorCoarse(fan, distinct, startIdx, maxIdx, curveData)
+	curveData, err = f.sampleInteriorCoarse(ctx, fan, distinct, startIdx, maxIdx, curveData)
 	if err != nil {
 		return nil, err
 	}
@@ -82,6 +92,7 @@ func (f *FanCurveAnalyzer) RunInitializationSequence() (rpmCurve map[int]float64
 }
 
 func (f *FanCurveAnalyzer) detectStartBoundary(
+	ctx context.Context,
 	fan fans.Fan,
 	distinct []int,
 	curveData map[int]float64,
@@ -95,7 +106,7 @@ func (f *FanCurveAnalyzer) detectStartBoundary(
 	for low <= high {
 		mid := (low + high) / 2
 		pwm := distinct[mid]
-		rpm, measureErr := f.measureAtPwm(fan, pwm, configuration.CurrentConfig.Analysis.SettleTimeout)
+		rpm, measureErr := f.measureAtPwm(ctx, fan, pwm, configuration.CurrentConfig.Analysis.SettleTimeout)
 		if measureErr != nil {
 			return 0, 0, measureErr
 		}
@@ -134,6 +145,7 @@ func (f *FanCurveAnalyzer) detectStartBoundary(
 }
 
 func (f *FanCurveAnalyzer) detectMaxBoundary(
+	ctx context.Context,
 	fan fans.Fan,
 	distinct []int,
 	startIdx int,
@@ -162,7 +174,7 @@ func (f *FanCurveAnalyzer) detectMaxBoundary(
 	ui.Info("Fan %s: Discovering max boundary...", fan.GetId())
 	for idx := lastIdx; idx >= topStartIdx; idx -= step {
 		pwm := distinct[idx]
-		rpm, measureErr := f.measureAtPwm(fan, pwm, 0)
+		rpm, measureErr := f.measureAtPwm(ctx, fan, pwm, 0)
 		if measureErr != nil {
 			return 0, 0, measureErr
 		}
@@ -186,7 +198,7 @@ func (f *FanCurveAnalyzer) detectMaxBoundary(
 		pwm := distinct[idx]
 		rpm, exists := fastScan[pwm]
 		if !exists {
-			measureRpm, measureErr := f.measureAtPwm(fan, pwm, 0)
+			measureRpm, measureErr := f.measureAtPwm(ctx, fan, pwm, 0)
 			if measureErr != nil {
 				return 0, 0, measureErr
 			}
@@ -204,7 +216,7 @@ func (f *FanCurveAnalyzer) detectMaxBoundary(
 	}
 
 	if roughIdx >= 0 {
-		confirmedIdx, confirmedPwm, confirmErr := f.confirmMaxBoundary(fan, distinct, startIdx, roughIdx, curveData)
+		confirmedIdx, confirmedPwm, confirmErr := f.confirmMaxBoundary(ctx, fan, distinct, startIdx, roughIdx, curveData)
 		if confirmErr != nil {
 			return 0, 0, confirmErr
 		}
@@ -219,6 +231,7 @@ func (f *FanCurveAnalyzer) detectMaxBoundary(
 }
 
 func (f *FanCurveAnalyzer) confirmMaxBoundary(
+	ctx context.Context,
 	fan fans.Fan,
 	distinct []int,
 	startIdx int,
@@ -246,7 +259,7 @@ func (f *FanCurveAnalyzer) confirmMaxBoundary(
 	peakConfirmed := 0.0
 	for _, idx := range confirmIndices {
 		pwm := distinct[idx]
-		rpm, measureErr := f.measureAtPwm(fan, pwm, configuration.CurrentConfig.Analysis.SettleTimeout)
+		rpm, measureErr := f.measureAtPwm(ctx, fan, pwm, configuration.CurrentConfig.Analysis.SettleTimeout)
 		if measureErr != nil {
 			return 0, 0, measureErr
 		}
@@ -284,6 +297,7 @@ func (f *FanCurveAnalyzer) confirmMaxBoundary(
 }
 
 func (f *FanCurveAnalyzer) sampleInteriorCoarse(
+	ctx context.Context,
 	fan fans.Fan,
 	distinct []int,
 	startIdx int,
@@ -308,7 +322,7 @@ func (f *FanCurveAnalyzer) sampleInteriorCoarse(
 			continue
 		}
 		settleTimeout := settleTimeoutForPwmJump(lastMeasuredPwm, pwm, configuration.CurrentConfig.Analysis.SettleTimeout)
-		rpm, err := f.measureAtPwm(fan, pwm, settleTimeout)
+		rpm, err := f.measureAtPwm(ctx, fan, pwm, settleTimeout)
 		if err != nil {
 			return curveData, err
 		}
@@ -394,13 +408,15 @@ func (f *FanCurveAnalyzer) rpmCurveMeasurementCleanup(curveData map[int]float64)
 // expected value after setting it even after waiting FanResponseDelay (indicates the hardware ignored the request).
 // If settleTimeout > 0, waitForFanToSettle is called with that timeout (used for large PWM steps).
 // If settleTimeout == 0, a plain FanResponseDelay sleep is used instead (sufficient for small steps).
-func (f *FanCurveAnalyzer) measureAtPwm(fan fans.Fan, pwm int, settleTimeout time.Duration) (float64, error) {
+func (f *FanCurveAnalyzer) measureAtPwm(ctx context.Context, fan fans.Fan, pwm int, settleTimeout time.Duration) (float64, error) {
 	actualPwm := f.fanController.applyPwmMapToTarget(pwm)
 	matchedPwm := false
 	for attempt := 0; attempt <= pwmMismatchRetries; attempt++ {
 		if attempt > 0 {
 			// The reported PWM may lag behind the requested value on some hardware, so wait FanResponseDelay before retrying.
-			time.Sleep(time.Duration(configuration.CurrentConfig.FanResponseDelay) * time.Second)
+			if err := sleepWithContext(ctx, time.Duration(configuration.CurrentConfig.FanResponseDelay)*time.Second); err != nil {
+				return 0, err
+			}
 		}
 		err := f.fanController.setPwm(actualPwm)
 		if err != nil {
@@ -427,10 +443,14 @@ func (f *FanCurveAnalyzer) measureAtPwm(fan fans.Fan, pwm int, settleTimeout tim
 	}
 
 	if settleTimeout > 0 {
-		f.waitForFanToSettle(fan, settleTimeout)
+		if err := f.waitForFanToSettle(ctx, fan, settleTimeout); err != nil {
+			return 0, err
+		}
 	} else {
 		// Small PWM step — a response-delay sleep is sufficient.
-		time.Sleep(time.Duration(configuration.CurrentConfig.FanResponseDelay) * time.Second)
+		if err := sleepWithContext(ctx, time.Duration(configuration.CurrentConfig.FanResponseDelay)*time.Second); err != nil {
+			return 0, err
+		}
 	}
 
 	sampleCount := configuration.CurrentConfig.Analysis.SampleCount
@@ -441,7 +461,9 @@ func (f *FanCurveAnalyzer) measureAtPwm(fan fans.Fan, pwm int, settleTimeout tim
 	samples := make([]float64, 0, sampleCount)
 	for i := 0; i < sampleCount; i++ {
 		if i > 0 {
-			time.Sleep(sampleDelay)
+			if err := sleepWithContext(ctx, sampleDelay); err != nil {
+				return 0, err
+			}
 		}
 		r, err := fan.GetRpm()
 		if err != nil {
@@ -459,7 +481,7 @@ func (f *FanCurveAnalyzer) measureAtPwm(fan fans.Fan, pwm int, settleTimeout tim
 // waitForFanToSettle waits until the fan's RPM readings are stable (requiredConsecutive consecutive
 // readings with diff <= MaxRpmDiffForSettledFan). If timeout > 0 and the deadline is exceeded, a
 // warning is logged and the function returns early rather than blocking forever.
-func (f *FanCurveAnalyzer) waitForFanToSettle(fan fans.Fan, timeout time.Duration) {
+func (f *FanCurveAnalyzer) waitForFanToSettle(ctx context.Context, fan fans.Fan, timeout time.Duration) error {
 	const requiredConsecutive = 3
 	const settleSampleInterval = 500 * time.Millisecond
 	const settleWindowSize = 8
@@ -484,9 +506,11 @@ func (f *FanCurveAnalyzer) waitForFanToSettle(fan fans.Fan, timeout time.Duratio
 	for consecutiveStable < requiredConsecutive {
 		if timeout > 0 && time.Now().After(deadline) {
 			ui.Warning("Fan %s did not settle within %v, continuing anyway (%d/%d stable readings)", fan.GetId(), timeout, consecutiveStable, requiredConsecutive)
-			return
+			return nil
+		}
+		if err := sleepWithContext(ctx, settleSampleInterval); err != nil {
+			return err
 		}
-		time.Sleep(settleSampleInterval)
 
 		currentRpm, err := fan.GetRpm()
 		if err != nil {
@@ -519,6 +543,7 @@ func (f *FanCurveAnalyzer) waitForFanToSettle(fan fans.Fan, timeout time.Duratio
 			fan.GetId(), consecutiveStable, requiredConsecutive, meanNow, rangeNow)
 	}
 	ui.Debug("Fan %s has settled (%d consecutive stable readings)", fan.GetId(), requiredConsecutive)
+	return nil
 }
 
 func evaluateAdaptiveSettling(window []float64, prevMean *float64, prevRange *float64, baseThreshold float64) (bool, float64, float64) {