bob run: start tui before build (#112)

* run: start the tui without waiting for build results
* run: add startup fix
* run: execute all builds in a pipeline

Co-authored-by: equanox <[email protected]>

Author: zuzuleinen

bob/run.go

@@ -10,6 +10,7 @@ import (
 	"github.com/benchkram/bob/bob/bobfile"
 	"github.com/benchkram/bob/pkg/boberror"
 	"github.com/benchkram/bob/pkg/ctl"
+	"github.com/benchkram/bob/pkg/sliceutil"
 )
 
 // Examples of possible interactive usecase
@@ -20,8 +21,7 @@ import (
 // 2: [Done] plain docker-compose run with dependcies to build-cmds
 //    containing instructions how to build the container image.
 //
-// TODO:
-// 3: init script requiring a executable to run before
+// 3: [Done] init script requiring a executable to run before
 //    containing a health endpoint (REST?). So the init script can be
 //    sure about the service to be functional.
 //
@@ -31,30 +31,26 @@ import (
 //
 // Canceling the cmd from the outside must be done through the context.
 //
-// TODO: Forbid circular dependecys.
-func (b *B) Run(ctx context.Context, runName string) (_ ctl.Commander, err error) {
+// FIXME: Forbid circular dependecys.
+func (b *B) Run(ctx context.Context, runTaskName string) (_ ctl.Commander, err error) {
 	defer errz.Recover(&err)
 
 	aggregate, err := b.Aggregate()
 	errz.Fatal(err)
 
 	b.PrintVersionCompatibility(aggregate)
 
-	runTask, ok := aggregate.RTasks[runName]
+	runTask, ok := aggregate.RTasks[runTaskName]
 	if !ok {
 		return nil, ErrRunDoesNotExist
 	}
 
 	// gather interactive tasks
-	childInteractiveTasks := b.runTasksInPipeline(runName, aggregate)
+	childInteractiveTasks := runTasksInPipeline(runTaskName, aggregate)
 	interactiveTasks := []string{runTask.Name()}
 	interactiveTasks = append(interactiveTasks, childInteractiveTasks...)
 
 	// build dependencies & main runTask
-	for _, task := range interactiveTasks {
-		err = executeBuildTasksInPipeline(ctx, task, aggregate, b.nix)
-		errz.Fatal(err)
-	}
 
 	// generate run controls to steer the run cmd.
 	runCommands := []ctl.Command{}
@@ -67,7 +63,7 @@ func (b *B) Run(ctx context.Context, runName string) (_ ctl.Commander, err error
 		runCommands = append(runCommands, command)
 	}
 
-	builder := NewBuilder(b, runName, aggregate, executeBuildTasksInPipeline)
+	builder := NewBuilder(b, runTaskName, aggregate, executeBuildTasksInPipeline)
 	commander := ctl.NewCommander(ctx, builder, runCommands...)
 
 	return commander, nil
@@ -78,10 +74,10 @@ func (b *B) Run(ctx context.Context, runName string) (_ ctl.Commander, err error
 //
 // It will not error but return a empty error in case the runName
 // does not exists.
-func (b *B) runTasksInPipeline(runName string, aggregate *bobfile.Bobfile) []string {
+func runTasksInPipeline(runTaskName string, aggregate *bobfile.Bobfile) []string {
 	runTasks := []string{}
 
-	run, ok := aggregate.RTasks[runName]
+	run, ok := aggregate.RTasks[runTaskName]
 	if !ok {
 		return nil
 	}
@@ -93,7 +89,7 @@ func (b *B) runTasksInPipeline(runName string, aggregate *bobfile.Bobfile) []str
 		runTasks = append(runTasks, task)
 
 		// assure all it's dependent runTasks are also added.
-		childs := b.runTasksInPipeline(task, aggregate)
+		childs := runTasksInPipeline(task, aggregate)
 		runTasks = append(runTasks, childs...)
 	}
 
@@ -137,40 +133,49 @@ func isRunTask(name string, aggregate *bobfile.Bobfile) bool {
 // 	return ok
 // }
 
-// executeBuildTasksInPipeline takes a run task but only executes the dependent build tasks
-func executeBuildTasksInPipeline(ctx context.Context, runname string, aggregate *bobfile.Bobfile, nix *NixBuilder) (err error) {
+// executeBuildTasksInPipeline takes a run task and starts the required builds.
+func executeBuildTasksInPipeline(
+	ctx context.Context,
+	runTaskName string,
+	aggregate *bobfile.Bobfile,
+	nix *NixBuilder,
+) (err error) {
 	defer errz.Recover(&err)
 
-	interactive, ok := aggregate.RTasks[runname]
+	_, ok := aggregate.RTasks[runTaskName]
 	if !ok {
 		return ErrRunDoesNotExist
 	}
+	runTasksInPipeline := runTasksInPipeline(runTaskName, aggregate)
 
-	// Gather build tasks
-	buildTasks := []string{}
-	for _, child := range interactive.DependsOn {
-		if isRunTask(child, aggregate) {
-			continue
-		}
-		buildTasks = append(buildTasks, child)
+	// Gather build tasks from run task dependencies.
+	// This is required to get the top most build tasks and start a build for each.
+	// Each run task could have could have distinct build pipeline beneth it.
+	// This implies that multiple unrelated builds could be started
+	// on a run invocation.
+
+	// umbrella run task
+	buildTasks, err := gatherBuildTasks(runTaskName, aggregate)
+	errz.Fatal(err)
+	// child run tasks
+	for _, runTaskName := range runTasksInPipeline {
+		childBuildTasks, err := gatherBuildTasks(runTaskName, aggregate)
+		errz.Fatal(err)
+		buildTasks = append(buildTasks, childBuildTasks...)
 	}
+	buildTasks = sliceutil.Unique(buildTasks)
 
 	// Build nix dependencies
 	if nix != nil {
 		fmt.Println("Building nix dependencies...")
 		err = nix.BuildNixDependencies(aggregate, buildTasks)
 		errz.Fatal(err)
-		fmt.Println("Succeded building nix dependencies")
+		fmt.Println("Succeeded building nix dependencies")
 	}
 
-	// Run dependent build tasks
-	// before starting the run task
-	for _, child := range interactive.DependsOn {
-		if isRunTask(child, aggregate) {
-			continue
-		}
-
-		playbook, err := aggregate.Playbook(child)
+	// Initiate each build
+	for _, buildTask := range buildTasks {
+		playbook, err := aggregate.Playbook(buildTask)
 		if err != nil {
 			if errors.Is(err, boberror.ErrTaskDoesNotExist) {
 				continue
@@ -184,3 +189,21 @@ func executeBuildTasksInPipeline(ctx context.Context, runname string, aggregate
 
 	return nil
 }
+
+// gatherBuildTasks returns all direct build tasks in the pipeline of a run task.
+func gatherBuildTasks(runTaskName string, aggregate *bobfile.Bobfile) ([]string, error) {
+	runTask, ok := aggregate.RTasks[runTaskName]
+	if !ok {
+		return nil, ErrRunDoesNotExist
+	}
+
+	buildTasks := []string{}
+	for _, child := range runTask.DependsOn {
+		if isRunTask(child, aggregate) {
+			continue
+		}
+		buildTasks = append(buildTasks, child)
+	}
+
+	return buildTasks, nil
+}

pkg/ctl/commander.go

@@ -46,7 +46,7 @@ type Builder interface {
 	Build(context.Context) error
 }
 
-// NewCommander creates a commander object which can be started and stoped
+// NewCommander creates a commander object which can be started and stopped
 // until shutdown is called, then it becomes noop.
 //
 // The commander allows it to control multiple commands while taking
@@ -55,7 +55,7 @@ type Builder interface {
 // TODO: Could be benficial for a TUI to directly control the commands.
 //       That needs somehow blocking of a starting/stopping of the whole commander
 //       while a child is doing some work. This is currently not implemented.
-//       It's possible to control the underlying commands directly through
+//       It is possible to control the underlying commands directly through
 //       `Subcommands()` but that could probably lead to nasty start/stop loops.
 //  ___________             ___________             ___________
 // |           | Command() |           | Command() |           |
@@ -106,10 +106,6 @@ func NewCommander(ctx context.Context, builder Builder, ctls ...Command) Command
 						err := c.Stop()
 						boblog.Log.Error(err, "Error on stopping comander")
 
-						// Trigger a rebuild.
-						err = c.builder.Build(ctx)
-						errz.Fatal(err)
-
 						err = c.Start()
 						boblog.Log.Error(err, "Error during comander run")
 
@@ -138,8 +134,13 @@ func (c *commander) Subcommands() []Command {
 }
 
 // Start cmds in inverse order.
-// Blocks subsquent calls until the first one is completed.
+// Blocks subsequent calls until the first one is completed.
 func (c *commander) Start() (err error) {
+	defer errz.Recover(&err)
+
+	err = c.builder.Build(c.ctx)
+	errz.Fatal(err)
+
 	return c.start()
 }
 

tui/model.go

@@ -191,12 +191,12 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 
 	case tea.KeyMsg:
-		//for _, r := range msg.Runes {
+		// for _, r := range msg.Runes {
 		//	print(fmt.Sprintf("%s\n", strconv.QuoteRuneToASCII(r)))
-		//}
+		// }
 
 		switch {
-		//case string(msg.Runes[0]) == "[":
+		// case string(msg.Runes[0]) == "[":
 		//	errz.Log(fmt.Errorf("%#v", msg.Runes[0]))
 
 		case key.Matches(msg, m.keys.NextTab):
@@ -387,9 +387,9 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	m.content, updateCmd = m.content.Update(msg)
 	cmds = append(cmds, updateCmd)
 
-	//if m.error != nil {
+	// if m.error != nil {
 	//	//cmds = append(cmds, stop(m))
-	//}
+	// }
 
 	return m, tea.Batch(cmds...)
 }

tui/tui.go

@@ -21,6 +21,7 @@ type TUI struct {
 }
 
 func New() (*TUI, error) {
+
 	evts := make(chan interface{}, 1024)
 
 	stdout := os.Stdout
@@ -35,6 +36,14 @@ func New() (*TUI, error) {
 	os.Stdout = wout
 	os.Stderr = wout
 
+	// FIXME: this is a hack to indicate a line to read to multiScanner().
+	// If we don't do this, the scanner assumes theres is nothing to do and shuts down.
+	// The TUI does not start and the program will exit.
+	//
+	// This happens only occasionaly on mid-size projects (i've no idea why).
+	// Though, it works fine with the standard server-db example.
+	fmt.Fprint(wout, "\n")
+
 	buf, err := multiScanner(0, evts, rout)
 	if err != nil {
 		errz.Log(err)
@@ -51,6 +60,7 @@ func New() (*TUI, error) {
 }
 
 func (t *TUI) Start(cmder ctl.Commander) {
+
 	t.started = true
 
 	programEvts := make(chan interface{}, 1)