bake: add execution modes and concurrency control with --jobs

build/build_test.go

@@ -2,16 +2,58 @@ package build
 
 import (
 	"bytes"
+	"context"
+	stderrors "errors"
 	"testing"
 
 	"github.com/docker/buildx/builder"
 	"github.com/docker/buildx/driver"
 	"github.com/moby/buildkit/client"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
+func TestHandlerCompleted(t *testing.T) {
+	failure := stderrors.New("failed")
+	for _, tt := range []struct {
+		name     string
+		err      error
+		canceled bool
+		aborted  bool
+	}{
+		{name: "success"},
+		{name: "failure", err: failure},
+		{name: "dependency", err: targetAbortError{failure}, aborted: true},
+		{name: "wrapped dependency", err: errors.Wrap(targetAbortError{failure}, "target"), aborted: true},
+		{name: "canceled", err: context.Canceled, aborted: true},
+		{name: "deadline", err: context.DeadlineExceeded, aborted: true},
+		{name: "canceled with cause", err: failure, canceled: true, aborted: true},
+		{name: "canceled RPC", err: status.Error(codes.Canceled, "canceled"), canceled: true, aborted: true},
+		{name: "success before cancellation", canceled: true},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithCancelCause(t.Context())
+			defer cancel(nil)
+			if tt.canceled {
+				cancel(failure)
+			}
+			calls := 0
+			h := &Handler{Completed: func(name string, result TargetResult) {
+				calls++
+				require.Equal(t, "target", name)
+				require.Equal(t, tt.err, result.Err)
+				require.Equal(t, tt.aborted, result.Aborted)
+			}}
+			h.completed(ctx, "target", tt.err)
+			require.Equal(t, 1, calls)
+		})
+	}
+}
+
 type warnOutputFactory struct {
 	driver.Factory
 	name string

build/linked_targets_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/docker/buildx/util/waitmap"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/require"
 )
@@ -39,16 +40,22 @@ func TestLinkedTargetStateChainRetainsParents(t *testing.T) {
 	}
 
 	go func() {
-		done["root"] <- state.run(t.Context(), "root", struct{}{}, func() error { return nil })
+		done["root"] <- state.run(t.Context(), "root", struct{}{}, linkedTargetHooks{
+			evaluate: func() error { return nil },
+		})
 	}()
 	go func() {
-		done["middle"] <- state.run(t.Context(), "middle", struct{}{}, func() error { return nil })
+		done["middle"] <- state.run(t.Context(), "middle", struct{}{}, linkedTargetHooks{
+			evaluate: func() error { return nil },
+		})
 	}()
 	go func() {
-		done["leaf"] <- state.run(t.Context(), "leaf", struct{}{}, func() error {
-			close(leafStarted)
-			<-releaseLeaf
-			return nil
+		done["leaf"] <- state.run(t.Context(), "leaf", struct{}{}, linkedTargetHooks{
+			evaluate: func() error {
+				close(leafStarted)
+				<-releaseLeaf
+				return nil
+			},
 		})
 	}()
 
@@ -83,7 +90,9 @@ func TestLinkedTargetStateDiamondEvaluatesBranchesInParallel(t *testing.T) {
 	done := make(chan error, 4)
 	run := func(key string, evaluate func() error) {
 		go func() {
-			done <- state.run(t.Context(), key, struct{}{}, evaluate)
+			done <- state.run(t.Context(), key, struct{}{}, linkedTargetHooks{
+				evaluate: evaluate,
+			})
 		}()
 	}
 	run("root", func() error { return nil })
@@ -126,12 +135,204 @@ func TestLinkedTargetStateCancellation(t *testing.T) {
 	cause := errors.New("target failed")
 	done := make(chan error, 1)
 	go func() {
-		done <- state.run(ctx, "child", struct{}{}, func() error { return nil })
+		done <- state.run(ctx, "child", struct{}{}, linkedTargetHooks{
+			evaluate: func() error { return nil },
+		})
 	}()
 	cancel(cause)
 	require.ErrorIs(t, <-done, cause)
 }
 
+func TestLinkedTargetStatePropagatesDependencyErrors(t *testing.T) {
+	state := newLinkedTargetState(
+		map[string][]string{"child": {"parent"}},
+		map[string][]string{"parent": {"child"}},
+	)
+	cause := errors.New("parent failed")
+	state.fail("parent", cause)
+
+	err := state.run(t.Context(), "child", struct{}{}, linkedTargetHooks{
+		evaluate: func() error { return nil },
+	})
+	require.ErrorIs(t, err, cause)
+}
+
+func TestSyncEvaluateWaitsForAllTargets(t *testing.T) {
+	targets := []string{"foo", "bar"}
+	results := waitmap.New()
+
+	fooStarted := make(chan struct{})
+	done := map[string]chan error{
+		"foo": make(chan error, 1),
+		"bar": make(chan error, 1),
+	}
+
+	go func() {
+		results.Set("foo", struct{}{})
+		if _, err := results.Get(t.Context(), targets...); err != nil {
+			done["foo"] <- err
+			return
+		}
+		close(fooStarted)
+		done["foo"] <- nil
+	}()
+
+	assertNotSignaled(t, fooStarted)
+	assertNotCompleted(t, done["foo"])
+
+	go func() {
+		results.Set("bar", struct{}{})
+		if _, err := results.Get(t.Context(), targets...); err != nil {
+			done["bar"] <- err
+			return
+		}
+		done["bar"] <- nil
+	}()
+
+	require.NoError(t, <-done["foo"])
+	require.NoError(t, <-done["bar"])
+}
+
+func TestSyncEvaluateCancellation(t *testing.T) {
+	results := waitmap.New()
+	ctx, cancel := context.WithCancelCause(t.Context())
+	cause := errors.New("target failed")
+
+	done := make(chan error, 1)
+	go func() {
+		results.Set("foo", struct{}{})
+		_, err := results.Get(ctx, "foo", "bar")
+		done <- err
+	}()
+
+	cancel(cause)
+	require.ErrorIs(t, <-done, cause)
+}
+
+func TestSyncEvaluateDoesNotDeadlockLinkedTargets(t *testing.T) {
+	linked := newLinkedTargetState(
+		map[string][]string{"child": {"parent"}},
+		map[string][]string{"parent": {"child"}},
+	)
+	results := waitmap.New()
+	evaluated := waitmap.New()
+
+	done := map[string]chan error{
+		"parent": make(chan error, 1),
+		"child":  make(chan error, 1),
+	}
+
+	for _, key := range []string{"parent", "child"} {
+		go func() {
+			done[key] <- linked.run(t.Context(), key, struct{}{}, linkedTargetHooks{
+				preEvaluate: func() error {
+					results.Set(key, struct{}{})
+					_, err := results.Get(t.Context(), "parent", "child")
+					return err
+				},
+				evaluate: func() error {
+					return nil
+				},
+				postEvaluate: func() error {
+					evaluated.Set(key, struct{}{})
+					_, err := evaluated.Get(t.Context(), "parent", "child")
+					return err
+				},
+			})
+		}()
+	}
+
+	require.NoError(t, <-done["parent"])
+	require.NoError(t, <-done["child"])
+}
+
+func TestSyncEvaluatePropagatesEvaluationErrors(t *testing.T) {
+	linked := newLinkedTargetState(map[string][]string{}, map[string][]string{})
+	evaluated := waitmap.New()
+	cause := errors.New("target failed")
+	done := map[string]chan error{
+		"success": make(chan error, 1),
+		"failure": make(chan error, 1),
+	}
+
+	go func() {
+		done["success"] <- linked.run(t.Context(), "success", struct{}{}, linkedTargetHooks{
+			evaluate: func() error {
+				return nil
+			},
+			postEvaluate: func() error {
+				evaluated.Set("success", struct{}{})
+				results, err := evaluated.Get(t.Context(), "success", "failure")
+				if err != nil {
+					return err
+				}
+				return wrapResultError(results, "aborted: another target failed")
+			},
+		})
+	}()
+
+	assertNotCompleted(t, done["success"])
+
+	go func() {
+		err := linked.run(t.Context(), "failure", struct{}{}, linkedTargetHooks{
+			evaluate: func() error {
+				return cause
+			},
+		})
+		evaluated.Set("failure", err)
+		done["failure"] <- err
+	}()
+
+	err := <-done["success"]
+	require.ErrorContains(t, err, "aborted: another target failed")
+	require.ErrorIs(t, err, cause)
+	require.ErrorIs(t, <-done["failure"], cause)
+}
+
+func TestResultErrorReturnsFirstErrorInKeyOrder(t *testing.T) {
+	alpha := errors.New("alpha failed")
+	beta := errors.New("beta failed")
+
+	err := resultError(map[string]any{
+		"b":  beta,
+		"ok": struct{}{},
+		"a":  alpha,
+	})
+
+	require.EqualError(t, err, "alpha failed")
+	require.ErrorIs(t, err, alpha)
+}
+
+func TestSyncTargetStateWrapsPropagatedErrors(t *testing.T) {
+	state := &syncTargetState{
+		targets:   []string{"success", "failure"},
+		results:   waitmap.New(),
+		evaluated: waitmap.New(),
+	}
+	cause := errors.New("target failed")
+	done := make(chan error, 1)
+
+	go func() {
+		done <- state.waitResult(t.Context(), "success", struct{}{})
+	}()
+
+	assertNotCompleted(t, done)
+	state.fail("failure", cause)
+
+	err := <-done
+	require.ErrorContains(t, err, "aborted: another target failed")
+	require.ErrorIs(t, err, cause)
+}
+
+func TestWrapResultErrorDoesNotNestAbortErrors(t *testing.T) {
+	cause := errors.New("target failed")
+	first := wrapResultError(map[string]any{"root": cause}, "aborted: dependency target failed")
+	second := wrapResultError(map[string]any{"mid": first}, "aborted: dependency target failed")
+
+	require.EqualError(t, second, "aborted: dependency target failed: target failed")
+	require.ErrorIs(t, second, cause)
+}
+
 func assertNotCompleted(t *testing.T, ch <-chan error) {
 	t.Helper()
 	select {