feat(devx): creating proc and waitfor

Author: katallaxie

.golangci.yml

@@ -186,6 +186,11 @@ issues:
         - gosec
         - gas
 
+    - text: "G204:"
+      linters:
+        - gosec
+        - gas
+
   # Independently from option `exclude` we use default exclude patterns,
   # it can be disabled by this option. To list all
   # excluded by default patterns execute `golangci-lint run --help`.

devx/runproc/filewatcher.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+type Watcher struct {
+	p []string
+
+	state string
+}
+
+func calcTree(patterns []string) string {
+	var files []string
+	for _, p := range patterns {
+		f, err := filepath.Glob(p)
+		if err != nil {
+			continue
+		}
+		files = append(files, f...)
+	}
+
+	sort.Strings(files)
+
+	var t strings.Builder
+	for _, f := range files {
+		info, err := os.Stat(f)
+		if err != nil {
+			continue
+		}
+		t.WriteString(f + "\n")
+		t.WriteString(info.ModTime().String() + "\n")
+		t.WriteString(strconv.FormatInt(info.Size(), 10) + "\n")
+	}
+
+	return t.String()
+}
+
+func (w *Watcher) Changed() bool {
+	tree := calcTree(w.p)
+	if tree == w.state {
+		return false
+	}
+
+	w.state = tree
+	return true
+}
+
+func Watch(patterns []string) *Watcher {
+	sort.Strings(patterns)
+
+	return &Watcher{p: patterns, state: calcTree(patterns)}
+}

devx/runproc/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"log"
+	"os"
+	"os/signal"
+)
+
+func main() {
+	file := flag.String("f", "", "Procfile to run.")
+	localFile := flag.String("l", "", "Local Procfile to append.")
+	flag.Parse()
+
+	log.SetFlags(log.Lshortfile)
+
+	if *file == "" {
+		log.Fatal("No Procfile specified.")
+	}
+
+	data, err := os.ReadFile(*file)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var envData []byte
+	if *localFile != "" {
+		envData, _ = os.ReadFile(*localFile)
+	}
+
+	buf := bytes.NewBuffer(data)
+	buf.WriteString("\n")
+	buf.Write(envData)
+
+	tasks, err := Parse(buf)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	log.SetFlags(log.Lshortfile)
+
+	run := NewRunner(tasks)
+
+	ch := make(chan os.Signal, 3)
+	signal.Notify(ch, shutdownSignals...)
+	go func() {
+		<-ch
+		go run.Stop()
+		<-ch
+		os.Exit(1)
+	}()
+
+	err = run.Run()
+	if err != nil {
+		log.Fatalln(err)
+	}
+}

devx/runproc/parse.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strings"
+)
+
+func isAlphaNum(r byte) bool {
+	switch {
+	case r >= 'a' && r <= 'z':
+	case r >= 'A' && r <= 'Z':
+	case r >= '0' && r <= '9':
+	case r == '_':
+	default:
+		return false
+	}
+	return true
+}
+
+func Parse(r io.Reader) ([]Task, error) {
+	s := bufio.NewScanner(r)
+	var tasks []Task
+	var t Task
+	var line int
+	for s.Scan() {
+		line++
+		str := strings.TrimSpace(s.Text())
+		if str == "" {
+			t = Task{}
+			continue
+		}
+		if str[0] == '@' {
+			// parameter
+			parts := strings.SplitN(str[1:], "=", 2)
+			switch strings.TrimSpace(parts[0]) {
+			case "oneshot":
+				t.OneShot = true
+			case "watch-file":
+				if len(parts) != 2 {
+					return nil, fmt.Errorf("line %d: missing file path for watch-file", line)
+				}
+				t.WatchFiles = append(t.WatchFiles, parts[1])
+			default:
+				return nil, fmt.Errorf("line %d: invalid option '%s'", line, parts[0])
+			}
+		}
+		if !isAlphaNum(str[0]) {
+			// comment/ignored
+			continue
+		}
+
+		parts := strings.SplitN(str, ":", 2)
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("line %d: invalid proc definition '%s' (missing ':')", line, parts[0])
+		}
+		t.Name = strings.TrimSpace(parts[0])
+		t.Command = strings.TrimSpace(parts[1])
+		tasks = append(tasks, t)
+		t = Task{}
+	}
+	return tasks, s.Err()
+}

devx/runproc/prefixer.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"bytes"
+	"io"
+)
+
+type prefixer struct {
+	prefix string
+	out    io.Writer
+	buf    []byte
+}
+
+func NewPrefixer(out io.Writer, prefix string) io.Writer {
+	return &prefixer{
+		out:    out,
+		prefix: prefix,
+	}
+}
+
+func (w *prefixer) writePrefix() error {
+	_, err := io.WriteString(w.out, w.prefix+" | ")
+	return err
+}
+
+func (w *prefixer) Write(p []byte) (int, error) {
+	var n int
+	for {
+		l := bytes.IndexByte(p, '\n')
+		if l == -1 {
+			w.buf = append(w.buf, p...)
+			return n + len(p), nil
+		}
+		w.buf = append(w.buf, p[:l+1]...)
+		n += l + 1
+
+		err := w.writePrefix()
+		if err != nil {
+			return n, err
+		}
+
+		// replace yarn escape sequences
+		w.buf = bytes.ReplaceAll(w.buf, []byte("\x1b[2K"), nil)
+		w.buf = bytes.ReplaceAll(w.buf, []byte("\x1b[1G"), nil)
+
+		_, err = w.out.Write(w.buf)
+		if err != nil {
+			return n, err
+		}
+		w.buf = w.buf[:0]
+
+		_, err = w.out.Write([]byte("\x1b[0m"))
+		if err != nil {
+			return n, err
+		}
+
+		p = p[l+1:]
+	}
+}