ttarpit/main.go

package main

import (
  "fmt"
  "os/exec"
  "log"
  "io"
  "os"
  "io/fs"
  "path/filepath"
  "errors"
  "lcthw.dev/go/ttarpit/config"
  "github.com/fsnotify/fsnotify"
)


func LaunchLogger(in io.Reader, out io.Writer, err error) {
  if err != nil { log.Fatal(err) }

  go func() {
    if _, err := io.Copy(out, in)

    err != nil { log.Printf("LOGGER: %v", err) }
  }()
}

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
    }

    fmt.Println("STARTING", proc.Command)

    stderr, err := proc.ExecCmd.StderrPipe();
    LaunchLogger(stderr, 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")
    proc.Ready<- "ready"
    proc.ExecCmd.Wait()
    fmt.Println("PROCESS", proc.Command, "EXITED")
  }
}

func RunBuild() {
  fmt.Println("CONFIG:", config.Settings.ConfigPath)
  fmt.Println("COMMANDs:", config.Settings.Processes)

  for name, proc := range config.Settings.Processes {
    fmt.Println("PROCESS:", name)

    proc.Ready = make(chan string)
    LaunchProcess(&proc)
  }
}

func AddWatchDir(watcher *fsnotify.Watcher, name string) error {
  return filepath.WalkDir(name,
  func(path string, d fs.DirEntry, err error) error {
    if err != nil {
      log.Printf("WATCH ERROR! walking=%s path=%s: err=%v", name, path, err)
      return err
    }

    if d.IsDir() {
      log.Println("WATCHING: ", path)
      err = watcher.Add(path)
      if err != nil {
        log.Printf("failed to watch %s", path)
        return err
      }
    }

    return nil
  })
}

func WatchDir() {
  watcher, err := fsnotify.NewWatcher()
  if err != nil {
    log.Fatal("Failed to start fsnotify", err)
  }
  defer watcher.Close()

  go func() {
    for {
      select {
      case event, ok := <-watcher.Events:
        if !ok {
          return
        }

        if event.Has(fsnotify.Create) {
          log.Println("---> CREATE", event.Name)
          // ADD DIR
        } else {
          log.Println("event:", event)
        }
        // check if match then do thing
        go RunBuild()
      case err, ok := <-watcher.Errors:
        if !ok {
          return
        }
        log.Println("error: ", err)
      }
    }
  }()

  err = AddWatchDir(watcher, ".")

  if err != nil {
    log.Fatal(err, "Failed to watch .")
  }

  <-make(chan struct{})
}


func main() {
  config.Load()

  fmt.Println("WAITING....")
  WatchDir()
}