Skip Deinit() when modules were never initialized

.golangci.yml

@@ -163,6 +163,7 @@ linters:
       max-distance: 6
       ignore-names:
         - err
+        - fn
         - wg
         - s
         - ch

cmds/dutagent/dutagent.go

@@ -75,7 +75,8 @@ type agent struct {
 	server      string
 
 	// state
-	config config
+	config            config
+	modulesNeedDeinit bool
 }
 
 // config holds the dutagent configuration that is parsed from YAML data.
@@ -95,9 +96,8 @@ const (
 // Afterwards agt.exit is called. If clean-up fails, agt.exit is called with code 1,
 // otherwise with provided exitCode.
 func (agt *agent) cleanup(code exitCode) {
-	devlist := agt.config.Devices
-	if devlist != nil {
-		err := dutagent.Deinit(devlist)
+	if agt.modulesNeedDeinit {
+		err := dutagent.Deinit(agt.config.Devices)
 		if err != nil {
 			printInitErr(err)
 			log.Print("System might be in an UNKNOWN STATE !!!")
@@ -136,6 +136,8 @@ func (agt *agent) loadConfig() error {
 }
 
 func (agt *agent) initModules() error {
+	agt.modulesNeedDeinit = true
+
 	return dutagent.Init(agt.config.Devices)
 }
 

internal/dutagent/init.go

@@ -11,6 +11,25 @@ import (
 	"github.com/BlindspotSoftware/dutctl/pkg/dut"
 )
 
+// catchPanic calls fn and recovers from any panic, returning it as an error.
+// This intentionally does NOT re-panic. A module panic is recorded as an error
+// so the Init/Deinit loop can continue with the remaining modules.
+func catchPanic(fn func() error) error {
+	var err error
+
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				err = fmt.Errorf("panic: %v", r)
+			}
+		}()
+
+		err = fn()
+	}()
+
+	return err
+}
+
 // ModuleInitError is a container for errors that occur during module
 // initialization.
 type ModuleInitError struct {
@@ -45,7 +64,7 @@ func Init(devices dut.Devlist) error {
 	for devname, device := range devices {
 		for cmdname, cmd := range device.Cmds {
 			for _, module := range cmd.Modules {
-				err := module.Init()
+				err := catchPanic(module.Init)
 				if err != nil {
 					ierr.Errs = append(ierr.Errs, ModuleInitErrorDetails{
 						Dev: devname,
@@ -81,7 +100,7 @@ func Deinit(devices dut.Devlist) error {
 	for devname, device := range devices {
 		for cmdname, cmd := range device.Cmds {
 			for _, module := range cmd.Modules {
-				err := module.Deinit()
+				err := catchPanic(module.Deinit)
 				if err != nil {
 					derr.Errs = append(derr.Errs, ModuleInitErrorDetails{
 						Dev: devname,

pkg/module/gpio/gpio.go

@@ -139,6 +139,10 @@ func (b *Button) Init() error {
 func (b *Button) Deinit() error {
 	log.Println("gpio.Button module: Deinit called")
 
+	if b.gpio == nil {
+		return nil
+	}
+
 	return b.Low(b.Pin)
 }
 
@@ -258,6 +262,10 @@ func (s *Switch) Init() error {
 func (s *Switch) Deinit() error {
 	log.Println("gpio.Switch module: Deinit called")
 
+	if s.gpio == nil {
+		return nil
+	}
+
 	return s.Low(s.Pin)
 }
 

pkg/module/module.go

@@ -43,6 +43,9 @@ type Module interface {
 	// Deinit is called when the module is unloaded by dutagent or an internal error occurs.
 	// It is used to clean up any resources that were allocated during the Init phase and
 	// shall guarantee a graceful shutdown of the service.
+	//
+	// Implementations must be safe to call even if Init was never called or failed partway.
+	// Init may fail after partially allocating resources that still need cleanup.
 	Deinit() error
 	// Run is the entry point and executes the module with the given arguments.
 	Run(ctx context.Context, s Session, args ...string) error