First ability to build itself.

.gitignore

@@ -31,5 +31,5 @@ config.toml
 public
 *.idx
 *.sqlite3
-./ttarpit
-./tester
+ttarpit
+tester

.ttarpit.json

@@ -1,26 +1,11 @@
 {
+  "Includes": [
+    "^.*.go$"
+  ],
   "Processes": {
     "tester1": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "1"]
-    }
-  },
-  "Processes": {
-    "tester2": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "2"]
-    }
-  },
-  "Processes": {
-    "tester3": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "3"]
-    }
-  },
-  "Processes": {
-    "tester4": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "4"]
+      "Command": "make",
+      "Args": ["build"]
     }
   }
 }

config/settings.go

@@ -11,13 +11,14 @@ import (
 type Process struct {
   Command string
   Args []string
-  Ready chan string
   ExecCmd *exec.Cmd
 }
 
 type config struct {
   Processes map[string]Process
+  Includes []string
   ConfigPath string
+  BuildRunning bool
 }
 
 var Settings config

main.go

@@ -6,6 +6,9 @@ import (
   "log"
   "io"
   "os"
+  "time"
+  "slices"
+  "regexp"
   "io/fs"
   "path/filepath"
   "errors"
@@ -13,7 +16,6 @@ import (
   "github.com/fsnotify/fsnotify"
 )
 
-
 func LaunchLogger(in io.Reader, out io.Writer, err error) {
   if err != nil { log.Fatal(err) }
 
@@ -25,43 +27,67 @@ func LaunchLogger(in io.Reader, out io.Writer, err error) {
 }
 
 func LaunchProcess(proc *config.Process) {
-  for {
-    proc.ExecCmd = exec.Command(proc.Command, proc.Args...)
-    if errors.Is(proc.ExecCmd.Err, exec.ErrDot) {
-      proc.ExecCmd.Err = nil
-    }
+  proc.ExecCmd = exec.Command(proc.Command, proc.Args...)
+  if errors.Is(proc.ExecCmd.Err, exec.ErrDot) {
+    proc.ExecCmd.Err = nil
+  }
 
-    fmt.Println("STARTING", proc.Command)
+  fmt.Println("STARTING", proc.Command)
 
-    stderr, err := proc.ExecCmd.StderrPipe();
-    LaunchLogger(stderr, os.Stdout, err)
+  stderr, err := proc.ExecCmd.StderrPipe();
+  LaunchLogger(stderr, os.Stdout, err)
 
-    stdout, err := proc.ExecCmd.StdoutPipe();
-    LaunchLogger(stdout, os.Stdout, err)
+  stdout, err := proc.ExecCmd.StdoutPipe();
+  LaunchLogger(stdout, os.Stdout, err)
+
+  err = proc.ExecCmd.Start()
+  if err != nil {
+    log.Fatalf("FAIL %s %s err=%v", proc.Command, proc.Args, err)
+  }
+
+  fmt.Println("WAITING for", proc.Command)
+
+  fmt.Println("SENDING READY on channel")
+
+  fmt.Println("SENT READY")
+  proc.ExecCmd.Wait()
+  fmt.Println("PROCESS", proc.Command, "EXITED")
+}
+
+func MatchesPath(fp string) bool {
+  fp = filepath.ToSlash(fp)
+
+  is_included := slices.ContainsFunc(config.Settings.Includes, func (reg string) bool {
+    matches, err := regexp.MatchString(reg, fp)
 
-    err = proc.ExecCmd.Start()
     if err != nil {
-      log.Fatalf("FAIL %s %s err=%v", proc.Command, proc.Args, err)
+      log.Panic("invalid excludes regex", reg, "error: ", err)
     }
 
-    fmt.Println("WAITING for", proc.Command)
+    return matches
+  })
 
-    fmt.Println("SENDING READY on channel")
-    proc.Ready<- "ready"
-    proc.ExecCmd.Wait()
-    fmt.Println("PROCESS", proc.Command, "EXITED")
-  }
+  return is_included
 }
 
 func RunBuild() {
-  fmt.Println("CONFIG:", config.Settings.ConfigPath)
-  fmt.Println("COMMANDs:", config.Settings.Processes)
+  if !config.Settings.BuildRunning {
+    config.Settings.BuildRunning = true
+    defer func(){config.Settings.BuildRunning = false}()
+
+    fmt.Println("CONFIG:", config.Settings.ConfigPath)
+    fmt.Println("COMMANDs:", config.Settings.Processes)
 
-  for name, proc := range config.Settings.Processes {
-    fmt.Println("PROCESS:", name)
+    for name, proc := range config.Settings.Processes {
+      fmt.Println("PROCESS:", name)
+
+      LaunchProcess(&proc)
+      fmt.Println("=================== PROCESS EXIT")
+    }
 
-    proc.Ready = make(chan string)
-    LaunchProcess(&proc)
+    time.Sleep(1000 * time.Millisecond)
+  } else {
+    fmt.Println("!!!! BUILD SKIP, already running")
   }
 }
 
@@ -103,12 +129,15 @@ func WatchDir() {
 
         if event.Has(fsnotify.Create) {
           log.Println("---> CREATE", event.Name)
-          // ADD DIR
+          AddWatchDir(watcher, event.Name)
+        } else if event.Has(fsnotify.Write) {
+          // check if match then do thing
+          if MatchesPath(event.Name) {
+            go RunBuild()
+          }
         } else {
           log.Println("event:", event)
         }
-        // check if match then do thing
-        go RunBuild()
       case err, ok := <-watcher.Errors:
         if !ok {
           return

tools/cmd/tester/main.go

@@ -13,7 +13,7 @@ func Worker(name string, count int, done chan<- int, stop <-chan int) {
   for i := 0; i < count; i++ {
     select {
     case <-stop:
-      fmt.Println("Worker stopped:", name)
+      fmt.Println("TESTER Worker stopped:", name)
       done<- 1
       return
     default:
@@ -44,28 +44,26 @@ func Supervisor(id int, count int) {
 
         select {
         case <-workerDone:
-          fmt.Println("Supervisor: Worker Done")
+          fmt.Println("TESTER Supervisor: Worker Done")
           time.Sleep(500 * time.Millisecond)
         case <-stop:
-          fmt.Println("Supervisor: Stop")
+          fmt.Println("TESTER Supervisor: Stop")
           return
         }
       }
     }()
   }
 
-  /*
   go func() {
     // test shutdown
     time.Sleep(10000 * time.Millisecond)
+    fmt.Println("TESTER FORCE STOP!")
     close(stop)
   }()
-  */
 
   wg.Wait()
 }
 
-
 func main() {
   count := flag.Int("count", 10, "Seconds to wait")