(#2116) Support disown in exec watcher

.appveyor.yml

@@ -4,15 +4,15 @@ clone_folder: c:\gopath\src\github.com\choria-io\go-choria
 
 environment:
   GOPATH: c:\gopath
-  GOVERSION: "1.20"
+  GOVERSION: "1.21.0"
   MCOLLECTIVE_CERTNAME: rip.mcollective
   RUBY_VERSION: 24
   CGO_ENABLED: 0
 
 init:
   - git config --global core.autocrlf input
 
-stack: go 1.18
+stack: go 1.21
 
 install:
   # Install the specific Go version.

aagent/watchers/execwatcher/exec.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022, R.I. Pienaar and the Choria Project contributors
+// Copyright (c) 2019-2024, R.I. Pienaar and the Choria Project contributors
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -49,6 +49,7 @@
 	OutputAsData            bool          `mapstructure:"parse_as_data"`
 	SuppressSuccessAnnounce bool          `mapstructure:"suppress_success_announce"`
 	GatherInitialState      bool          `mapstructure:"gather_initial_state"`
+	Disown                  bool          `mapstructure:"disown"`
 	Timeout                 time.Duration
 }
 
@@ -240,103 +241,123 @@
 	return s
 }
 
 func (w *Watcher) watch(ctx context.Context) (state State, err error) {
 	if !w.ShouldWatch() {
 		return Skipped, nil
 	}
 
 	if w.properties.Governor != "" {
 		fin, err := w.EnterGovernor(ctx, w.properties.Governor, w.properties.GovernorTimeout)
 		if err != nil {
 			w.Errorf("Cannot enter Governor %s: %s", w.properties.Governor, err)
 			return Error, err
 		}
 		defer fin()
 	}
 
 	start := time.Now()
 	defer func() {
 		w.mu.Lock()
 		w.previousRunTime = time.Since(start)
 		w.mu.Unlock()
 	}()
 
 	w.Infof("Running %s", w.properties.Command)
 
 	timeoutCtx, cancel := context.WithTimeout(ctx, w.properties.Timeout)
 	defer cancel()
 
 	parsedCommand, err := w.ProcessTemplate(w.properties.Command)
 	if err != nil {
 		return Error, fmt.Errorf("could not process command template: %s", err)
 	}
 
 	splitcmd, err := shlex.Split(parsedCommand)
 	if err != nil {
 		w.Errorf("Exec watcher %s failed: %s", w.properties.Command, err)
 		return Error, err
 	}
 
 	if len(splitcmd) == 0 {
 		w.Errorf("Invalid command %q", w.properties.Command)
 		return Error, err
 	}
 
 	var args []string
 	if len(splitcmd) > 1 {
 		args = splitcmd[1:]
 	}
 
 	df, err := w.DataCopyFile()
 	if err != nil {
 		w.Errorf("Could not get a copy of the data into a temporary file, skipping execution: %s", err)
 		return Error, err
 	}
 	defer os.Remove(df)
 
 	ff, err := w.FactsFile()
 	if err != nil {
 		w.Errorf("Could not expose machine facts, skipping execution: %s", err)
 		return Error, err
 	}
 	defer os.Remove(ff)
 
-	cmd := exec.CommandContext(timeoutCtx, splitcmd[0], args...)
+	var cmd *exec.Cmd
+	if w.properties.Disown {
+		cmd = exec.Command(splitcmd[0], args...)
+	} else {
+		cmd = exec.CommandContext(timeoutCtx, splitcmd[0], args...)
+	}
 	cmd.Dir = w.machine.Directory()
 
 	cmd.Env = append(cmd.Env, fmt.Sprintf("MACHINE_WATCHER_NAME=%s", w.name))
 	cmd.Env = append(cmd.Env, fmt.Sprintf("MACHINE_NAME=%s", w.machine.Name()))
 	cmd.Env = append(cmd.Env, fmt.Sprintf("PATH=%s%s%s", os.Getenv("PATH"), string(os.PathListSeparator), w.machine.Directory()))
 	cmd.Env = append(cmd.Env, fmt.Sprintf("WATCHER_DATA=%s", df))
 	cmd.Env = append(cmd.Env, fmt.Sprintf("WATCHER_FACTS=%s", ff))
 
 	for _, e := range w.properties.Environment {
 		es, err := w.ProcessTemplate(e)
 		if err != nil {
 			return Error, fmt.Errorf("could not process environment template: %s", err)
 		}
 		cmd.Env = append(cmd.Env, es)
 	}
 
-	output, err := cmd.CombinedOutput()
+	var output []byte
+
+	if w.properties.Disown {
+		w.Infof("Running command disowned from parent")
+		err = disown(cmd)
+		if err != nil {
+			return Error, fmt.Errorf("could not disown process: %w", err)
+		}
+		err = cmd.Start()
+		if err == nil {
+			go func() { cmd.Wait() }()
+		}
+	} else {
+		output, err = cmd.CombinedOutput()
+	}
+
 	if err != nil {
 		w.Errorf("Exec watcher %s failed: %s", w.properties.Command, err)
 		return Error, err
 	}
 
 	w.Debugf("Output from %s: %s", w.properties.Command, output)
 
 	if w.properties.OutputAsData {
 		err = w.setOutputAsData(output)
 		if err != nil {
 			w.Errorf("Could not save output data: %s", err)
 			return Error, err
 		}
 	}
 
 	return Success, nil
 }
 
 func (w *Watcher) setOutputAsData(output []byte) error {
 	dat := map[string]string{}
 	err := json.Unmarshal(output, &dat)

aagent/watchers/execwatcher/exec_unix.go

@@ -0,0 +1,21 @@
+// Copyright (c) 2024, R.I. Pienaar and the Choria Project contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+//go:build !windows
+
+package execwatcher
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func disown(cmd *exec.Cmd) error {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setpgid: true,
+		Pgid:    0,
+	}
+
+	return nil
+}

aagent/watchers/execwatcher/exec_windows.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2024, R.I. Pienaar and the Choria Project contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package execwatcher
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+func disown(cmd *exec.Cmd) error {
+	return fmt.Errorf("disown is not supported on windows")
+}