Supports sending output to clients when running programs remotely

pkg/proc/gdbserial/gdbserver.go

@@ -84,6 +84,7 @@ import (
 	"github.com/go-delve/delve/pkg/proc/internal/ebpf"
 	"github.com/go-delve/delve/pkg/proc/linutil"
 	"github.com/go-delve/delve/pkg/proc/macutil"
+	"github.com/go-delve/delve/pkg/proc/redirect"
 	isatty "github.com/mattn/go-isatty"
 )
 
@@ -450,7 +451,7 @@ func getLdEnvVars() []string {
 // LLDBLaunch starts an instance of lldb-server and connects to it, asking
 // it to launch the specified target program with the specified arguments
 // (cmd) on the specified directory wd.
-func LLDBLaunch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs []string, tty string, redirects [3]string) (*proc.Target, error) {
+func LLDBLaunch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs []string, tty string, redirects redirect.Redirect) (*proc.Target, error) {
 	if runtime.GOOS == "windows" {
 		return nil, ErrUnsupportedOS
 	}
@@ -483,11 +484,20 @@ func LLDBLaunch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs [
 		} else {
 			found := [3]bool{}
 			names := [3]string{"stdin", "stdout", "stderr"}
-			for i := range redirects {
-				if redirects[i] != "" {
+			rds := [3]string{}
+			if paths, err := redirects.RedirectPath(); err != nil {
+				if !errors.Is(redirect.ErrorNotImplemented, err) {
+					return nil, err
+				}
+			} else {
+				rds = paths
+			}
+
+			for i := range rds {
+				if rds[i] != "" {
 					found[i] = true
 					hasRedirects = true
-					args = append(args, fmt.Sprintf("--%s-path", names[i]), redirects[i])
+					args = append(args, fmt.Sprintf("--%s-path", names[i]), rds[i])
 				}
 			}
 

pkg/proc/gdbserial/rr.go

@@ -83,11 +83,13 @@ func openRedirects(redirects [3]string, quiet bool) (stdin, stdout, stderr *os.F
 			}
 			return dflt
 		}
+
 		var f *os.File
 		f, err = os.Create(path)
 		if f != nil {
 			toclose = append(toclose, f)
 		}
+
 		return f
 	}
 

pkg/proc/native/nonative_darwin.go

@@ -11,12 +11,13 @@ import (
 	"github.com/go-delve/delve/pkg/proc"
 	"github.com/go-delve/delve/pkg/proc/amd64util"
 	"github.com/go-delve/delve/pkg/proc/internal/ebpf"
+	"github.com/go-delve/delve/pkg/proc/redirect"
 )
 
 var ErrNativeBackendDisabled = errors.New("native backend disabled during compilation")
 
 // Launch returns ErrNativeBackendDisabled.
-func Launch(_ []string, _ string, _ proc.LaunchFlags, _ []string, _ string, _ [3]string) (*proc.Target, error) {
+func Launch(_ []string, _ string, _ proc.LaunchFlags, _ []string, _ string, _ redirect.Redirect) (*proc.Target, error) {
 	return nil, ErrNativeBackendDisabled
 }
 

pkg/proc/native/proc.go

@@ -5,6 +5,7 @@ import (
 	"runtime"
 
 	"github.com/go-delve/delve/pkg/proc"
+	"github.com/go-delve/delve/pkg/util"
 )
 
 // Process represents all of the information the debugger
@@ -324,7 +325,11 @@ func openRedirects(redirects [3]string, foreground bool) (stdin, stdout, stderr
 			return dflt
 		}
 		var f *os.File
-		f, err = os.Create(path)
+		if pipe, ok := util.GetRedirectStrore().Load(path); ok {
+			f = pipe.Writer
+		} else {
+			f, err = os.Create(path)
+		}
 		if f != nil {
 			toclose = append(toclose, f)
 		}

pkg/proc/redirect/redirect.go

@@ -0,0 +1,20 @@
+package redirect
+
+import (
+	"errors"
+	"os"
+)
+
+var ErrorNotImplemented = errors.New("not implemented")
+
+// Redirect
+type Redirect interface {
+	// RedirectPath
+	RedirectPath() (redirects [3]string, err error)
+	// RedirectFile
+	RedirectReaderFile() (readerFile [3]*os.File, err error)
+	// RedirectWriterFile
+	RedirectWriterFile() (writerFile [3]*os.File, err error)
+	// ReStart
+	ReStart() error
+}

pkg/util/redirect.go

@@ -0,0 +1,36 @@
+package util
+
+import (
+	"os"
+	"sync"
+)
+
+var (
+	redirectMap = &RedirectStroe{rs: sync.Map{}}
+)
+
+type RedirectStroe struct {
+	rs sync.Map
+}
+
+func GetRedirectStrore() *RedirectStroe {
+	return redirectMap
+}
+
+func (r *RedirectStroe) Store(key string, val *Pipe) {
+	r.rs.Store(key, val)
+}
+
+func (r *RedirectStroe) Load(key string) (*Pipe, bool) {
+	val, ok := r.rs.Load(key)
+	if ok {
+		return val.(*Pipe), true
+	}
+
+	return nil, false
+}
+
+type Pipe struct {
+	Reader *os.File
+	Writer *os.File
+}

service/dap/server.go

@@ -159,8 +159,29 @@ type Session struct {
 	// changeStateMu must be held for a request to protect itself from another goroutine
 	// changing the state of the running process at the same time.
 	changeStateMu sync.Mutex
+
+	// outputMode specifies how to print the program's output.
+	outputMode outputMode
+
+	// stdoutReader the programs's stdout.
+	stdoutReader io.ReadCloser
+
+	// stderrReader the program's stderr.
+	stderrReader io.ReadCloser
+
+	// wg the WaitGroup that needs to wait before sending a terminated event.
+	wg sync.WaitGroup
 }
 
+type outputMode int8
+
+const (
+	// outputToStd os.Stdin and os.Stdout
+	outputToStd outputMode = 1 << iota
+	// outputToDAP Sending program output to the client.
+	outputToDAP
+)
+
 // Config is all the information needed to start the debugger, handle
 // DAP connection traffic and signal to the server when it is time to stop.
 type Config struct {
@@ -786,6 +807,13 @@ func (s *Session) handleRequest(request dap.Message) {
 }
 
 func (s *Session) send(message dap.Message) {
+	if event, ok := message.(*dap.OutputEvent); ok {
+		if event.GetEvent().Event == "terminated" {
+			// wait for all tasks(output redirects) to finish
+			s.wg.Wait()
+		}
+	}
+
 	jsonmsg, _ := json.Marshal(message)
 	s.config.log.Debug("[-> to client]", string(jsonmsg))
 	// TODO(polina): consider using a channel for all the sends and to have a dedicated
@@ -974,7 +1002,7 @@ func (s *Session) onLaunchRequest(request *dap.LaunchRequest) {
 
 		var cmd string
 		var out []byte
-		var err error
+
 		switch args.Mode {
 		case "debug":
 			cmd, out, err = gobuild.GoBuildCombinedOutput(args.Output, []string{args.Program}, args.BuildFlags)
@@ -1025,9 +1053,61 @@ func (s *Session) onLaunchRequest(request *dap.LaunchRequest) {
 	argsToLog.Cwd, _ = filepath.Abs(args.Cwd)
 	s.config.log.Debugf("launching binary '%s' with config: %s", debugbinary, prettyPrint(argsToLog))
 
+	var redirected = false
+	s.outputMode |= outputToStd
+	switch args.OutputMode {
+	case "remote":
+		s.outputMode |= outputToDAP
+		redirected = true
+	case "only-remote":
+		s.outputMode = outputToDAP
+		redirected = true
+	case "local", "":
+		// noting
+	default:
+		s.sendShowUserErrorResponse(request.Request, FailedToLaunch, "Failed to launch",
+			fmt.Sprintf("invalid debug configuration - unsupported 'outputMode' attribute %q", args.OutputMode))
+		return
+	}
+
+	readerFunc := func(reader io.Reader, category string) {
+		var stdWriter io.Writer
+		if category == "stdout" {
+			stdWriter = os.Stdout
+		} else {
+			stdWriter = os.Stderr
+		}
+
+		var out [1024]byte
+		for {
+			n, err := reader.Read(out[:])
+			if err != nil {
+				if errors.Is(io.EOF, err) {
+					return
+				}
+				s.config.log.Errorf("failed read by %s - %v ", category, err)
+				return
+			}
+			outs := string(out[:n])
+
+			if s.outputMode&outputToStd != 0 {
+				fmt.Fprintf(stdWriter, outs)
+			}
+
+			if s.outputMode&outputToDAP != 0 {
+				s.send(&dap.OutputEvent{
+					Event: *newEvent("output"),
+					Body: dap.OutputEventBody{
+						Output:   outs,
+						Category: category,
+					}})
+			}
+		}
+	}
+
 	if args.NoDebug {
 		s.mu.Lock()
-		cmd, err := s.newNoDebugProcess(debugbinary, args.Args, s.config.Debugger.WorkingDir)
+		cmd, err := s.newNoDebugProcess(debugbinary, args.Args, s.config.Debugger.WorkingDir, redirected)
 		s.mu.Unlock()
 		if err != nil {
 			s.sendShowUserErrorResponse(request.Request, FailedToLaunch, "Failed to launch", err.Error())
@@ -1039,16 +1119,65 @@ func (s *Session) onLaunchRequest(request *dap.LaunchRequest) {
 
 		// Start the program on a different goroutine, so we can listen for disconnect request.
 		go func() {
+			if redirected {
+				s.wg.Add(1)
+				go func() {
+					defer s.wg.Done()
+					readerFunc(s.stdoutReader, "stdout")
+				}()
+
+				s.wg.Add(1)
+				go func() {
+					defer s.wg.Done()
+					readerFunc(s.stderrReader, "stderr")
+				}()
+				// Wait for the input and output to be read
+			}
 			if err := cmd.Wait(); err != nil {
 				s.config.log.Debugf("program exited with error: %v", err)
 			}
+
 			close(s.noDebugProcess.exited)
 			s.logToConsole(proc.ErrProcessExited{Pid: cmd.ProcessState.Pid(), Status: cmd.ProcessState.ExitCode()}.Error())
 			s.send(&dap.TerminatedEvent{Event: *newEvent("terminated")})
 		}()
 		return
 	}
 
+	if redirected {
+		redirector, err := NewRedirector()
+		if err != nil {
+			s.sendShowUserErrorResponse(request.Request, InternalError, "Internal Error",
+				fmt.Sprintf("failed to generate stdio pipes - %v", err))
+			return
+		}
+
+		s.config.Debugger.Redirect = redirector
+		s.wg.Add(1)
+		go func() {
+			defer s.wg.Done()
+			if err = redirector.ReadRedirect("stdout", func(reader io.Reader) {
+				readerFunc(reader, "stdout")
+			}); err != nil {
+				s.sendShowUserErrorResponse(request.Request, InternalError, "Internal Error",
+					fmt.Sprintf("failed to open stdout pipe - %v", err))
+				return
+			}
+
+		}()
+		s.wg.Add(1)
+		go func() {
+			defer s.wg.Done()
+			if err = redirector.ReadRedirect("stderr", func(reader io.Reader) {
+				readerFunc(reader, "stderr")
+			}); err != nil {
+				s.sendShowUserErrorResponse(request.Request, FailedToLaunch, "Failed to launch",
+					fmt.Sprintf("failed to open stderr pipe - %v", err))
+				return
+			}
+		}()
+	}
+
 	func() {
 		s.mu.Lock()
 		defer s.mu.Unlock() // Make sure to unlock in case of panic that will become internal error
@@ -1082,15 +1211,30 @@ func (s *Session) getPackageDir(pkg string) string {
 
 // newNoDebugProcess is called from onLaunchRequest (run goroutine) and
 // requires holding mu lock. It prepares process exec.Cmd to be started.
-func (s *Session) newNoDebugProcess(program string, targetArgs []string, wd string) (*exec.Cmd, error) {
+func (s *Session) newNoDebugProcess(program string, targetArgs []string, wd string, redirected bool) (cmd *exec.Cmd, err error) {
 	if s.noDebugProcess != nil {
 		return nil, fmt.Errorf("another launch request is in progress")
 	}
-	cmd := exec.Command(program, targetArgs...)
-	cmd.Stdout, cmd.Stderr, cmd.Stdin, cmd.Dir = os.Stdout, os.Stderr, os.Stdin, wd
-	if err := cmd.Start(); err != nil {
+
+	cmd = exec.Command(program, targetArgs...)
+	cmd.Stdin, cmd.Dir = os.Stdin, wd
+
+	if redirected {
+		if s.stderrReader, err = cmd.StderrPipe(); err != nil {
+			return nil, err
+		}
+
+		if s.stdoutReader, err = cmd.StdoutPipe(); err != nil {
+			return nil, err
+		}
+	} else {
+		cmd.Stdout, cmd.Stderr = os.Stdin, os.Stderr
+	}
+
+	if err = cmd.Start(); err != nil {
 		return nil, err
 	}
+
 	s.noDebugProcess = &process{Cmd: cmd, exited: make(chan struct{})}
 	return cmd, nil
 }