dap: add debug adapter implementation

Adds a simple implementation of the debug adapter that supports the very
basics of a debug adapter.

It supports the launch request, the configuration done request, the
creation of threads, stopping, resuming, and disconnecting from server.

It does not support custom breakpoints, stack traces, or variable
inspection yet. These are planned to be added in the future. It also
does not support sending output through the debug adapter yet.

Signed-off-by: Jonathan A. Sternberg <[email protected]>

Author: jsternberg

build/build.go

@@ -313,9 +313,12 @@ func toRepoOnly(in string) (string, error) {
 	return strings.Join(out, ","), nil
 }
 
-type Handler struct {
-	Evaluate func(ctx context.Context, c gateway.Client, res *gateway.Result) error
-}
+type (
+	EvaluateFunc func(ctx context.Context, name string, c gateway.Client, res *gateway.Result) error
+	Handler      struct {
+		Evaluate EvaluateFunc
+	}
+)
 
 func Build(ctx context.Context, nodes []builder.Node, opts map[string]Options, docker *dockerutil.Client, cfg *confutil.Config, w progress.Writer) (resp map[string]*client.SolveResponse, err error) {
 	return BuildWithResultHandler(ctx, nodes, opts, docker, cfg, w, nil)
@@ -510,12 +513,25 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opts map[
 						rKey := resultKey(dp.driverIndex, k)
 						results.Set(rKey, res)
 
+						forceEval := false
 						if children := childTargets[rKey]; len(children) > 0 {
-							if err := waitForChildren(ctx, bh, c, res, results, children); err != nil {
+							// wait for the child targets to register their LLB before evaluating
+							_, err := results.Get(ctx, children...)
+							if err != nil {
 								return nil, err
 							}
-						} else if bh != nil && bh.Evaluate != nil {
-							if err := bh.Evaluate(ctx, c, res); err != nil {
+							forceEval = true
+						}
+
+						// invoke custom evaluate handler if it is present
+						if bh != nil && bh.Evaluate != nil {
+							if err := bh.Evaluate(ctx, k, c, res); err != nil {
+								return nil, err
+							}
+						} else if forceEval {
+							if err := res.EachRef(func(ref gateway.Reference) error {
+								return ref.Evaluate(ctx)
+							}); err != nil {
 								return nil, err
 							}
 						}
@@ -1199,29 +1215,6 @@ func solve(ctx context.Context, c gateway.Client, req gateway.SolveRequest) (*ga
 	return res, nil
 }
 
-func waitForChildren(ctx context.Context, bh *Handler, c gateway.Client, res *gateway.Result, results *waitmap.Map, children []string) error {
-	// wait for the child targets to register their LLB before evaluating
-	_, err := results.Get(ctx, children...)
-	if err != nil {
-		return err
-	}
-	// we need to wait until the child targets have completed before we can release
-	eg, ctx := errgroup.WithContext(ctx)
-	eg.Go(func() error {
-		if bh != nil && bh.Evaluate != nil {
-			return bh.Evaluate(ctx, c, res)
-		}
-		return res.EachRef(func(ref gateway.Reference) error {
-			return ref.Evaluate(ctx)
-		})
-	})
-	eg.Go(func() error {
-		_, err := results.Get(ctx, children...)
-		return err
-	})
-	return eg.Wait()
-}
-
 func catchFrontendError(retErr, frontendErr *error) {
 	*frontendErr = *retErr
 	if errors.Is(*retErr, ErrRestart) {

build/invoke.go

@@ -14,18 +14,18 @@ import (
 )
 
 type InvokeConfig struct {
-	Entrypoint []string
-	Cmd        []string
-	NoCmd      bool
-	Env        []string
-	User       string
-	NoUser     bool
-	Cwd        string
-	NoCwd      bool
-	Tty        bool
-	Rollback   bool
-	Initial    bool
-	SuspendOn  SuspendOn
+	Entrypoint []string  `json:"entrypoint,omitempty"`
+	Cmd        []string  `json:"cmd,omitempty"`
+	NoCmd      bool      `json:"noCmd,omitempty"`
+	Env        []string  `json:"env,omitempty"`
+	User       string    `json:"user,omitempty"`
+	NoUser     bool      `json:"noUser,omitempty"`
+	Cwd        string    `json:"cwd,omitempty"`
+	NoCwd      bool      `json:"noCwd,omitempty"`
+	Tty        bool      `json:"tty,omitempty"`
+	Rollback   bool      `json:"rollback,omitempty"`
+	Initial    bool      `json:"initial,omitempty"`
+	SuspendOn  SuspendOn `json:"suspendOn,omitempty"`
 }
 
 func (cfg *InvokeConfig) NeedsDebug(err error) bool {
@@ -43,6 +43,18 @@ func (s SuspendOn) DebugEnabled(err error) bool {
 	return err != nil || s == SuspendAlways
 }
 
+func (s *SuspendOn) UnmarshalText(text []byte) error {
+	switch string(text) {
+	case "error":
+		*s = SuspendError
+	case "always":
+		*s = SuspendAlways
+	default:
+		return errors.Errorf("unknown suspend name: %s", string(text))
+	}
+	return nil
+}
+
 type Container struct {
 	cancelOnce      sync.Once
 	containerCancel func(error)

commands/build.go

@@ -21,7 +21,6 @@ import (
 	"github.com/docker/buildx/build"
 	"github.com/docker/buildx/builder"
 	"github.com/docker/buildx/commands/debug"
-	"github.com/docker/buildx/monitor"
 	"github.com/docker/buildx/store"
 	"github.com/docker/buildx/store/storeutil"
 	"github.com/docker/buildx/util/buildflags"
@@ -56,7 +55,6 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
-	"github.com/tonistiigi/go-csvvalue"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/metric"
 	"google.golang.org/grpc/codes"
@@ -102,7 +100,7 @@ type buildOptions struct {
 	exportPush   bool
 	exportLoad   bool
 
-	invokeConfig *invokeConfig
+	debugger debug.Debugger
 }
 
 func (o *buildOptions) toOptions() (*BuildOptions, error) {
@@ -408,25 +406,25 @@ func getImageID(resp map[string]string) string {
 }
 
 func runBuildWithOptions(ctx context.Context, dockerCli command.Cli, opts *BuildOptions, options buildOptions, printer *progress.Printer) (_ *client.SolveResponse, _ *build.Inputs, retErr error) {
-	if options.invokeConfig != nil && (options.dockerfileName == "-" || options.contextPath == "-") {
-		// stdin must be usable for monitor
-		return nil, nil, errors.Errorf("Dockerfile or context from stdin is not supported with invoke")
-	}
+	var bh build.Handler
+	if options.debugger != nil {
+		if options.dockerfileName == "-" || options.contextPath == "-" {
+			// stdin must be usable for debugger
+			return nil, nil, errors.Errorf("Dockerfile or context from stdin is not supported with debugger")
+		}
 
-	var (
-		in io.ReadCloser
-		m  *monitor.Monitor
-		bh build.Handler
-	)
-	if options.invokeConfig == nil {
-		in = dockerCli.In()
-	} else {
-		m = monitor.New(&options.invokeConfig.InvokeConfig, dockerCli.In(), os.Stdout, os.Stderr, printer)
-		defer m.Close()
+		dbg, err := options.debugger.Start(dockerCli, printer)
+		if err != nil {
+			return nil, nil, err
+		}
+		defer dbg.Stop()
+
+		bh = dbg.Handler()
 
-		bh = m.Handler()
+		dockerCli.SetIn(nil)
 	}
 
+	in := dockerCli.In()
 	for {
 		resp, inputs, err := RunBuild(ctx, dockerCli, opts, in, printer, &bh)
 		if err != nil {
@@ -450,13 +448,15 @@ type debuggableBuild struct {
 	rootOpts  *rootOptions
 }
 
-func (b *debuggableBuild) NewDebugger(cfg *debug.DebugConfig) *cobra.Command {
-	return buildCmd(b.dockerCli, b.rootOpts, cfg)
+func (b *debuggableBuild) WithDebugger(debugger debug.Debugger) *cobra.Command {
+	return buildCmd(b.dockerCli, b.rootOpts, debugger)
 }
 
-func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugConfig *debug.DebugConfig) *cobra.Command {
+func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugger debug.Debugger) *cobra.Command {
 	cFlags := &commonFlags{}
-	options := &buildOptions{}
+	options := &buildOptions{
+		debugger: debugger,
+	}
 
 	cmd := &cobra.Command{
 		Use:     "build [OPTIONS] PATH | URL | -",
@@ -481,14 +481,6 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugConfig *debug.D
 			options.progress = cFlags.progress
 			cmd.Flags().VisitAll(checkWarnedFlags)
 
-			if debugConfig != nil && (debugConfig.InvokeFlag != "" || debugConfig.OnFlag != "") {
-				iConfig := new(invokeConfig)
-				if err := iConfig.parseInvokeConfig(debugConfig.InvokeFlag, debugConfig.OnFlag); err != nil {
-					return err
-				}
-				options.invokeConfig = iConfig
-			}
-
 			return runBuild(cmd.Context(), dockerCli, *options)
 		},
 		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
@@ -880,96 +872,6 @@ func printValue(w io.Writer, printer callFunc, version string, format string, re
 	return printer([]byte(res["result.json"]), w)
 }
 
-type invokeConfig struct {
-	build.InvokeConfig
-	invokeFlag string
-}
-
-func (cfg *invokeConfig) parseInvokeConfig(invoke, on string) error {
-	switch on {
-	case "always":
-		cfg.SuspendOn = build.SuspendAlways
-	case "error":
-		cfg.SuspendOn = build.SuspendError
-	default:
-		if invoke != "" {
-			cfg.SuspendOn = build.SuspendAlways
-		}
-	}
-
-	cfg.invokeFlag = invoke
-	cfg.Tty = true
-	cfg.NoCmd = true
-	switch invoke {
-	case "default", "":
-		return nil
-	case "on-error":
-		// NOTE: we overwrite the command to run because the original one should fail on the failed step.
-		// TODO: make this configurable via flags or restorable from LLB.
-		// Discussion: https://github.com/docker/buildx/pull/1640#discussion_r1113295900
-		cfg.Cmd = []string{"/bin/sh"}
-		cfg.NoCmd = false
-		return nil
-	}
-
-	csvParser := csvvalue.NewParser()
-	csvParser.LazyQuotes = true
-	fields, err := csvParser.Fields(invoke, nil)
-	if err != nil {
-		return err
-	}
-	if len(fields) == 1 && !strings.Contains(fields[0], "=") {
-		cfg.Cmd = []string{fields[0]}
-		cfg.NoCmd = false
-		return nil
-	}
-	cfg.NoUser = true
-	cfg.NoCwd = true
-	for _, field := range fields {
-		parts := strings.SplitN(field, "=", 2)
-		if len(parts) != 2 {
-			return errors.Errorf("invalid value %s", field)
-		}
-		key := strings.ToLower(parts[0])
-		value := parts[1]
-		switch key {
-		case "args":
-			cfg.Cmd = append(cfg.Cmd, maybeJSONArray(value)...)
-			cfg.NoCmd = false
-		case "entrypoint":
-			cfg.Entrypoint = append(cfg.Entrypoint, maybeJSONArray(value)...)
-			if cfg.Cmd == nil {
-				cfg.Cmd = []string{}
-				cfg.NoCmd = false
-			}
-		case "env":
-			cfg.Env = append(cfg.Env, maybeJSONArray(value)...)
-		case "user":
-			cfg.User = value
-			cfg.NoUser = false
-		case "cwd":
-			cfg.Cwd = value
-			cfg.NoCwd = false
-		case "tty":
-			cfg.Tty, err = strconv.ParseBool(value)
-			if err != nil {
-				return errors.Errorf("failed to parse tty: %v", err)
-			}
-		default:
-			return errors.Errorf("unknown key %q", key)
-		}
-	}
-	return nil
-}
-
-func maybeJSONArray(v string) []string {
-	var list []string
-	if err := json.Unmarshal([]byte(v), &list); err == nil {
-		return list
-	}
-	return []string{v}
-}
-
 func callAlias(target *string, value string) cobrautil.BoolFuncValue {
 	return func(s string) error {
 		v, err := strconv.ParseBool(s)

commands/debug/dap.go

@@ -0,0 +1,31 @@
+package debug
+
+import (
+	"context"
+	"io"
+
+	"github.com/docker/buildx/dap"
+	"github.com/docker/buildx/util/progress"
+	"github.com/docker/cli/cli/command"
+	"github.com/pkg/errors"
+)
+
+type AdapterProtocolDebugger struct{}
+
+func (d *AdapterProtocolDebugger) Start(dockerCli command.Cli, printer *progress.Printer) (DebuggerInstance, error) {
+	conn := dap.IoConn(readWriter{
+		Reader: dockerCli.In(),
+		Writer: dockerCli.Out(),
+	})
+
+	adapter := dap.New()
+	if err := adapter.Start(context.Background(), conn); err != nil {
+		return nil, errors.Wrap(err, "debug adapter did not start")
+	}
+	return adapter, nil
+}
+
+type readWriter struct {
+	io.Reader
+	io.Writer
+}