Added readycheck and depends_on keys that allow Panes and Windows to

depend on each other.

Author: kevinms

README.md

@@ -1,6 +1,7 @@
 
-=== Similar projects
+=== Directly Inspired By:
 
 * teamocil
 * tmuxinator
+* tmuxp
 * tmuxstart

main.go

@@ -7,30 +7,51 @@ import (
 	"log"
 	"os"
 	"os/exec"
-	"strings"
+	"time"
 
 	"gopkg.in/yaml.v2"
 )
 
+type Pane struct {
+	Object `yaml:",inline"`
+	Dir    string
+	Focus  bool
+	Cmd    string
+	target string
+}
+
+type Window struct {
+	Object `yaml:",inline"`
+	Dir    string
+	Focus  bool
+	Layout string
+	Panes  []*Pane
+}
+
 type Project struct {
 	Name    string
 	Dir     string
-	Windows []struct {
-		Name   string
-		Dir    string
-		Layout string
-		Focus  bool
-		Panes  []string
-	}
+	PreCmd  string `yaml:"pre_cmd"`
+	PostCmd string `yaml:"post_cmd"`
+	Windows []*Window
 }
 
-func run(name string, args ...string) {
-	cmd := exec.Command(name, args...)
+func run(format string, args ...interface{}) error {
+	cmdStr := fmt.Sprintf(format, args...)
+	cmd := exec.Command("/bin/sh", "-c", cmdStr)
+
+	fmt.Println(cmdStr)
+	_, err := cmd.CombinedOutput()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
 
-	fmt.Println(name, strings.Join(args[:], " "))
-	out, err := cmd.CombinedOutput()
+func shell(format string, args ...interface{}) {
+	err := run(format, args...)
 	if err != nil {
-		fmt.Printf("Output: %s", out)
 		log.Fatal(err)
 	}
 }
@@ -39,19 +60,19 @@ var sessionStarted bool
 
 func NewWindow(session, dir string) {
 	if sessionStarted {
-		run("tmux", "new-window", "-d", "-t "+session, "-c "+dir)
+		shell("tmux new-window -d -t %s -c %s", session, dir)
 	} else {
-		run("tmux", "new-session", "-d", "-s "+session, "-c "+dir)
+		shell("tmux new-session -d -s %s -c %s", session, dir)
 		sessionStarted = true
 	}
 }
 
 func NewPane(target, dir string) {
-	run("tmux", "split-window", "-t "+target, "-c "+dir)
+	shell("tmux split-window -t %s -c %s", target, dir)
 }
 
 func SelectWindow(target string) {
-	run("tmux", "select-window", "-t "+target)
+	shell("tmux select-window -t %s", target)
 }
 
 func SelectLayout(target, layout string) {
@@ -67,19 +88,23 @@ func SelectLayout(target, layout string) {
 	default:
 		log.Fatal("Bad layout: " + layout)
 	}
-	run("tmux", "select-layout", "-t "+target, layout)
+	shell("tmux select-layout -t %s %s", target, layout)
 }
 
 func SendLine(target, text string) {
 	if text == "" {
 		return
 	}
-	run("tmux", "send-keys", "-l", "-t "+target, text)
-	run("tmux", "send-keys", "-R", "-t "+target, "Enter")
+	shell("tmux send-keys -t %s '%s'", target, text)
+	shell("tmux send-keys -R -t %s 'Enter'", target)
 }
 
 func KillSession(session string) {
-	run("tmux", "kill-session", "-t "+session)
+	shell("tmux kill-session -t %s", session)
+}
+
+func SetEnvironment(session, key, value string) {
+	shell("tmux set-environment -t %s %s %s", session, key, value)
 }
 
 func coalesce(args ...string) string {
@@ -91,42 +116,139 @@ func coalesce(args ...string) string {
 	return ""
 }
 
+func (project *Project) getDir(w *Window, paneIndex int) string {
+	if paneIndex > len(w.Panes) {
+		log.Fatal("Pane index out of bounds?!")
+	}
+
+	if paneIndex == 0 && len(w.Panes) == 0 {
+		// The window has no explicit panes
+		return coalesce(w.Dir, project.Dir, ".")
+	}
+
+	return coalesce(w.Panes[paneIndex].Dir, w.Dir, project.Dir, ".")
+}
+
+func (p *Pane) Run() {
+	SendLine(p.target, p.Cmd)
+}
+
+func (w *Window) Run() {
+}
+
+func (w *Window) DoReadyCheck() {
+	for {
+		ready := true
+
+		for _, p := range w.Panes {
+			if p == nil {
+				continue
+			}
+			if !p.IsReady() {
+				ready = false
+				time.Sleep(100 * time.Millisecond)
+				break
+			}
+		}
+
+		if ready {
+			return
+		}
+	}
+}
+
+func (p *Pane) DoReadyCheck() {
+	if p.ReadyCheck.Test == "" {
+		return
+	}
+
+	for {
+		if err := run(p.ReadyCheck.Test); err == nil {
+			break
+		}
+
+		if p.ReadyCheck.Retries <= 0 {
+			log.Fatal("Object test failed?!")
+		} else {
+			p.ReadyCheck.Retries--
+			time.Sleep(p.ReadyCheck.Interval)
+		}
+	}
+}
+
+func shellInDir(dir, cmd string) {
+	shell("cd %s;%s", coalesce(dir, "."), cmd)
+}
+
 func up(session string, project *Project) {
+	if project.PreCmd != "" {
+		shellInDir(project.Dir, project.PreCmd)
+	}
+
+	// Spawn all the windows/panes
 	for wi, w := range project.Windows {
+		if w == nil {
+			continue
+		}
 		target := fmt.Sprintf("%s:%d", session, wi)
-		dir := coalesce(w.Dir, project.Dir, ".")
+		dir := project.getDir(w, 0)
 
 		NewWindow(session, dir)
 
 		for pi, p := range w.Panes {
+			if p == nil {
+				continue
+			}
+			p.target = fmt.Sprintf("%s:%d.%d", session, wi, pi)
+			dir := project.getDir(w, pi)
 			if pi > 0 {
 				NewPane(target, dir)
 			}
-			SendLine(target, p)
 		}
 
 		SelectLayout(target, w.Layout)
 	}
 
+	// Run the commands concurrently
+	for _, w := range project.Windows {
+		if w == nil {
+			continue
+		}
+		addRunner(w)
+		for _, p := range w.Panes {
+			if p == nil {
+				continue
+			}
+			addRunner(p)
+		}
+	}
+	runAll()
+
+	// Set which window has focus
 	for wi, w := range project.Windows {
+		if w == nil {
+			continue
+		}
 		if w.Focus {
 			target := fmt.Sprintf("%s:%d", session, wi)
 			SelectWindow(target)
 		}
 	}
+
+	if project.PostCmd != "" {
+		shellInDir(project.Dir, project.PostCmd)
+	}
 }
 
 func down(session string, project *Project) {
 	KillSession(session)
 }
 
-var defaultFile = "tmux-compose.yml"
-
 func main() {
 	var overrideName string
 	var composeFile string
 	flag.StringVar(&overrideName, "s", "", "Override the config files session name.")
-	flag.StringVar(&composeFile, "f", defaultFile, "Specify an alternate compose file")
+	flag.StringVar(&composeFile, "f", "tmux-compose.yml", "Specify an alternate compose file")
 	flag.Parse()
 
 	if flag.Arg(0) == "" {

runner.go

@@ -0,0 +1,113 @@
+package main
+
+import (
+	"log"
+	"sync"
+	"time"
+)
+
+// A window is ready when all it's children are ready.
+// A pane is ready when the readycheck is successful.
+// A pane without a readycheck is always ready.
+
+type Object struct {
+	Name       string
+	ReadyCheck struct {
+		Test     string
+		Interval time.Duration
+		Retries  int
+	}
+	DependsOn []string `yaml:"depends_on"`
+	mutex     sync.Mutex
+	ready     bool
+}
+
+var allRunners []Runner
+var byName = make(map[string]Runner)
+
+type Runner interface {
+	GetObject() *Object
+	DependenciesReady() bool
+	IsReady() bool
+	MarkReady()
+	DoReadyCheck()
+	Run()
+}
+
+func (o *Object) GetObject() *Object {
+	return o
+}
+
+func (o *Object) DependenciesReady() bool {
+	for _, name := range o.DependsOn {
+		other := byName[name]
+		if !other.IsReady() {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (o *Object) IsReady() bool {
+	o.mutex.Lock()
+	defer o.mutex.Unlock()
+	return o.ready
+}
+
+func (o *Object) MarkReady() {
+	o.mutex.Lock()
+	o.ready = true
+	o.mutex.Unlock()
+}
+
+func addRunner(r Runner) {
+	allRunners = append(allRunners, r)
+
+	name := r.GetObject().Name
+	if name == "" {
+		return
+	}
+	if _, ok := byName[name]; ok {
+		log.Fatalf("Duplicate name: '%s'", name)
+	}
+	byName[name] = r
+}
+
+func (o *Object) Validate() {
+	for _, name := range o.DependsOn {
+		if _, ok := byName[name]; !ok {
+			log.Fatalf("Dependency does not exist: %s", name)
+		}
+	}
+}
+
+func validateDependencies() {
+	for _, r := range allRunners {
+		r.GetObject().Validate()
+	}
+}
+
+func runAll() {
+	validateDependencies()
+
+	var wg sync.WaitGroup
+
+	for _, r := range allRunners {
+		// Don't use loop variables in goroutine
+		wg.Add(1)
+
+		go func(r Runner) {
+			for !r.DependenciesReady() {
+				time.Sleep(10 * time.Millisecond)
+			}
+			r.Run()
+			r.DoReadyCheck()
+			r.MarkReady()
+
+			wg.Done()
+		}(r)
+	}
+
+	wg.Wait()
+}