Method Exec

cmd/dagger/shell_exec.go:152–284

Exec is the main handler for executing simple commands. It is called for all [syntax.CallExpr] nodes where the first argument is neither a declared shell function nor a builtin. This handler is responsible to interpreting functions and module references as commands that can be executed, and wraps

(next interp.ExecHandlerFunc)

// This handler is responsible to interpreting functions and module references
// as commands that can be executed, and wraps any returned errors.
func (h *shellCallHandler) Exec(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
	return func(ctx context.Context, args []string) (rerr error) {
		// This avoids interpreter builtins running first, which would make it
		// impossible to have a function named "echo", for example. We can
		// remove `__dag` from this point onward.
		if args[0] == shellInternalCmd {
			args = args[1:]
		}

		// If argument is a state value, just pass it on to stdout directly.
		// Example: `$FOO` or `$FOO | bar`
		if GetStateKey(args[0]) != "" {
			hctx := interp.HandlerCtx(ctx)
			fmt.Fprint(hctx.Stdout, args[0])
			return nil
		}

		// It's a cascading error if the state from the previous handler in a
		// pipeline failed.
		var cascadingErr bool

		// Read stdin. If not nil this will block until the previous handler
		// has finished. If state is nil here it means it's the first command
		// in a pipeline (foo | bar).
		st, err := h.loadInput(ctx, args)
		if st != nil {
			cascadingErr = st.IsHandlerError()
		}

		// Having a span for each handler makes it much easier to debug what
		// the shell is doing.
		opts := make([]trace.SpanStartOption, 0, 2)
		opts = append(opts, trace.WithAttributes(attribute.StringSlice("dagger.io/shell.handler.args", args)))
		// Don't show span by default unless there's an error or we're debugging
		// (with `.debug`).
		if !h.Debug() {
			opts = append(opts, telemetry.Passthrough())
		}
		ctx, span := Tracer().Start(ctx, args[0], opts...)
		defer telemetry.EndWithCause(span, &rerr)

		defer func() {
			if cascadingErr {
				// Early exit if an error is passed through stdin.
				span.SetAttributes(
					attribute.Bool(telemetry.CanceledAttr, true),
				)
			} else if rerr != nil {
				// TODO: it's helpful to show the span on error when it's a usage
				// issue, but if it's from resolving a query it shows the error
				// twice. Could still be useful though, to pinpoint exactly which
				// part of the script triggered it.
				attrs := []attribute.KeyValue{
					attribute.Bool(telemetry.UIPassthroughAttr, false),
				}
				var he *HandlerError
				if errors.As(rerr, &he) {
					attrs = append(attrs, attribute.Int("dagger.io/shell.handler.exit", he.ExitCode))