Example using ps notify

ps-notify-example.go

package main

import (
	"bytes"
	"log"
	"os"
	"os/exec"
	"syscall"

	"github.com/cloudfoundry/gosigar/psnotify"
)

type Result struct {
	hostname string
	exitCode int
	stdout   string
	stderr   string
}

func execCommand(command ...string) Result {

	var stdoutBuf bytes.Buffer
	var stderrBuf bytes.Buffer

	exit := 0

	cmd := exec.Command("bash", command...)

	cmd.Stdout = &stdoutBuf
	cmd.Stderr = &stderrBuf
	/*
		stdin, err := cmd.StdinPipe()
		if err != nil {
			log.Fatalf("error getting stdin pipe")
		}
		defer stdin.Close()
	*/
	startErr := cmd.Start()
	if startErr != nil {
		log.Fatalf("cmd.Start: %v", startErr)
	}

	//	io.Copy(stdin, bytes.NewBuffer(scriptBytes))
	//	stdin.Close()

	er := cmd.Wait()

	if er != nil {
		if exiterr, ok := er.(*exec.ExitError); ok {
			if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
				exit = status.ExitStatus()
			}
		}
	}

	result := Result{hostname: "localhost", exitCode: exit, stdout: stdoutBuf.String(), stderr: stderrBuf.String()}

	return result
}

func main() {
	watcher, err := psnotify.NewWatcher()
	if err != nil {
		log.Fatal(err)
	}

	// Process events
	go func() {
		for {
			select {
			case ev := <-watcher.Fork:
				log.Println("fork event:", ev)
			case ev := <-watcher.Exec:
				log.Println("exec event:", ev)
			case ev := <-watcher.Exit:
				log.Println("exit event:", ev)
			case err := <-watcher.Error:
				log.Println("error:", err)
			}
		}
	}()

	err = watcher.Watch(os.Getpid(), psnotify.PROC_EVENT_ALL)
	if err != nil {
		log.Fatal(err)
	}

	execCommand("echo 'Hello' && sleep 10 && echo 'Goodbye'")

	/* ... do stuff ... */
	watcher.Close()
}