RSDK-9591 - Kill all lingering module process before exiting

module/modmanager/manager.go

@@ -203,6 +203,19 @@
 	return err
 }
 
+// Kill kills module processes. This is best effort as we do not
+// have a lock during this function. Taking the lock will mean that
+// we may be blocked, and we do not want to be blocked.
+func (mgr *Manager) Kill() {
+	if mgr.restartCtxCancel != nil {
+		mgr.restartCtxCancel()
+	}
+	mgr.modules.Range(func(_ string, mod *module) bool {
+		mod.killProcess()
+		return true
+	})
+}
+
 // Handles returns all the models for each module registered.
 func (mgr *Manager) Handles() map[string]modlib.HandlerMap {
 	res := map[string]modlib.HandlerMap{}
@@ -1221,6 +1234,14 @@
 	return nil
 }
 
+func (m *module) killProcess() {
+	if m.process == nil {
+		return
+	}
+	m.logger.Infof("Killing module: %s process", m.cfg.Name)
+	m.process.Kill()
+}
+
 func (m *module) registerResources(mgr modmaninterface.ModuleManager) {
 	for api, models := range m.handles {
 		if _, ok := resource.LookupGenericAPIRegistration(api.API); !ok {

module/modmaninterface/interface.go

@@ -30,4 +30,5 @@ type ModuleManager interface {
 	FirstRun(ctx context.Context, conf config.Module) error
 
 	Close(ctx context.Context) error
+	Kill()
 }

robot/impl/local_robot.go

@@ -187,6 +187,14 @@ func (r *localRobot) Close(ctx context.Context) error {
 	return err
 }
 
+// Kill will attempt to kill any processes on the system started by the robot as quickly as possible.
+// This operation is not clean and will not wait for completion.
+func (r *localRobot) Kill() {
+	if r.manager != nil {
+		r.manager.Kill()
+	}
+}
+
 // StopAll cancels all current and outstanding operations for the robot and stops all actuators and movement.
 func (r *localRobot) StopAll(ctx context.Context, extra map[resource.Name]map[string]interface{}) error {
 	// Stop all operations

robot/impl/resource_manager.go

@@ -599,6 +599,16 @@ func (manager *resourceManager) Close(ctx context.Context) error {
 	return allErrs
 }
 
+// Kill attempts to kill all module processes.
+func (manager *resourceManager) Kill() {
+	// TODO: Kill processes in processManager as well.
+
+	// moduleManager may be nil in tests
+	if manager.moduleManager != nil {
+		manager.moduleManager.Kill()
+	}
+}
+
 // completeConfig process the tree in reverse order and attempts to build or reconfigure
 // resources that are wrapped in a placeholderResource. this function will attempt to
 // process resources concurrently when they do not depend on each other unless

robot/impl/resource_manager_test.go

@@ -1325,6 +1325,7 @@ func (fp *fakeProcess) Start(ctx context.Context) error {
 func (fp *fakeProcess) Stop() error {
 	return nil
 }
+func (fp *fakeProcess) Kill() {}
 
 func (fp *fakeProcess) Status() error {
 	return nil

robot/robot.go

@@ -186,6 +186,11 @@ type LocalRobot interface {
 
 	// RestartAllowed returns whether the robot can safely be restarted.
 	RestartAllowed() bool
+
+	// Kill will attempt to kill any processes on the system started by the robot as quickly as possible.
+	// This operation is not clean and will not wait for completion.
+	// Only use this if comfortable with leaking resources (in cases where exiting the program as quickly as possible is desired).
+	Kill()
 }
 
 // A RemoteRobot is a Robot that was created through a connection.

web/server/entrypoint.go

@@ -25,6 +25,7 @@ import (
 	"go.viam.com/rdk/config"
 	"go.viam.com/rdk/logging"
 	"go.viam.com/rdk/resource"
+	"go.viam.com/rdk/robot"
 	robotimpl "go.viam.com/rdk/robot/impl"
 	"go.viam.com/rdk/robot/web"
 	weboptions "go.viam.com/rdk/robot/web/options"
@@ -261,6 +262,8 @@ func (s *robotServer) serveWeb(ctx context.Context, cfg *config.Config) (err err
 	forceShutdown := make(chan struct{})
 	defer func() { <-forceShutdown }()
 
+	var myRobot robot.LocalRobot
+
 	utils.PanicCapturingGo(func() {
 		defer close(forceShutdown)
 
@@ -280,6 +283,9 @@ func (s *robotServer) serveWeb(ctx context.Context, cfg *config.Config) (err err
 				case <-doneServing:
 					return true
 				default:
+					if myRobot != nil {
+						myRobot.Kill()
+					}
 					s.logger.Fatalw("server failed to cleanly shutdown after deadline", "deadline", hungShutdownDeadline)
 					return true
 				}
@@ -398,7 +404,7 @@ func (s *robotServer) serveWeb(ctx context.Context, cfg *config.Config) (err err
 		robotOptions = append(robotOptions, robotimpl.WithFTDC())
 	}
 
-	myRobot, err := robotimpl.New(ctx, processedConfig, s.logger, robotOptions...)
+	myRobot, err = robotimpl.New(ctx, processedConfig, s.logger, robotOptions...)
 	if err != nil {
 		cancel()
 		return err