cmd/dlv: add --client-addr flag to run dap with a predefined client

Documentation/usage/dlv_dap.md

@@ -21,6 +21,11 @@ execution is resumed at the start of the debug session.
 dlv dap
 ```
 
+### Options
+
+```
+```
+
 ### Options inherited from parent commands
 
 ```

cmd/dlv/cmds/commands.go

@@ -61,6 +61,11 @@ var (
 	// disableASLR is used to disable ASLR
 	disableASLR bool
 
+	// dapConnect is dap subcommand's hidden flag that sets the rendezvous point address.
+	// If it is specified, the dap server operates in reverse mode and
+	// communicate only through the proxy dap server at the rendezvous point.
+	dapConnect string
+
 	// backend selection
 	backend string
 
@@ -188,6 +193,9 @@ While --continue is not supported, stopOnEntry launch/attach attribute can be us
 execution is resumed at the start of the debug session.`,
 		Run: dapCmd,
 	}
+	dapCommand.Flags().StringVar(&dapConnect, "connect", "", "host:port of the proxy DAP server. If set, the command starts a DAP server in reverse mode")
+	dapCommand.Flags().MarkHidden("connect")
+
 	rootCommand.AddCommand(dapCommand)
 
 	// 'debug' subcommand.
@@ -435,26 +443,47 @@ func dapCmd(cmd *cobra.Command, args []string) {
 			fmt.Fprintf(os.Stderr, "Warning: program flags ignored with dap; specify via launch/attach request instead\n")
 		}
 
-		listener, err := net.Listen("tcp", addr)
-		if err != nil {
-			fmt.Printf("couldn't start listener: %s\n", err)
-			return 1
-		}
+		var server *dap.Server
 		disconnectChan := make(chan struct{})
-		server := dap.NewServer(&service.Config{
-			Listener:       listener,
-			DisconnectChan: disconnectChan,
-			Debugger: debugger.Config{
-				Backend:              backend,
-				Foreground:           headless && tty == "",
-				DebugInfoDirectories: conf.DebugInfoDirectories,
-				CheckGoVersion:       checkGoVersion,
-				TTY:                  tty,
-			},
-			CheckLocalConnUser: checkLocalConnUser,
-		})
-		defer server.Stop()
 
+		if dapConnect == "" {
+			listener, err := net.Listen("tcp", addr)
+			if err != nil {
+				fmt.Printf("couldn't start listener: %s\n", err)
+				return 1
+			}
+			server = dap.NewServer(&service.Config{
+				Listener:       listener,
+				DisconnectChan: disconnectChan,
+				Debugger: debugger.Config{
+					Backend:              backend,
+					Foreground:           headless && tty == "",
+					DebugInfoDirectories: conf.DebugInfoDirectories,
+					CheckGoVersion:       checkGoVersion,
+					TTY:                  tty,
+				},
+				CheckLocalConnUser: checkLocalConnUser,
+			})
+		} else { // reverse mode
+			headless = true // TODO(github.com/go-delve/delve/issues/2552): consider the same for the normal mode.
+
+			conn, err := net.Dial("tcp", dapConnect)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to connect to the DAP proxy server: %v\n", err)
+				return 1
+			}
+			server = dap.NewReverseServer(&service.Config{
+				DisconnectChan: disconnectChan,
+				Debugger: debugger.Config{
+					Backend:              backend,
+					Foreground:           headless && tty == "",
+					DebugInfoDirectories: conf.DebugInfoDirectories,
+					CheckGoVersion:       checkGoVersion,
+					TTY:                  tty,
+				},
+			}, conn)
+		}
+		defer server.Stop()
 		server.Run()
 		waitForDisconnectSignal(disconnectChan)
 		return 0

cmd/dlv/dlv_test.go

@@ -10,6 +10,7 @@ import (
 	"go/types"
 	"io"
 	"io/ioutil"
+	"net"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -644,6 +645,48 @@ func TestDap(t *testing.T) {
 	cmd.Wait()
 }
 
+// TestDapReverse verifies that a dap-reverse command can be started and shut down.
+func TestDapReverse(t *testing.T) {
+	listener, err := net.Listen("tcp", ":0")
+	if err != nil {
+		t.Fatalf("cannot setup listener required for testing: %v", err)
+	}
+	defer listener.Close()
+
+	dlvbin, tmpdir := getDlvBin(t)
+	defer os.RemoveAll(tmpdir)
+
+	cmd := exec.Command(dlvbin, "dap", "--log-output=dap", "--log", "--connect", listener.Addr().String())
+	buf := &bytes.Buffer{}
+	cmd.Stdin = buf
+	cmd.Stdout = buf
+	assertNoError(cmd.Start(), t, "start reverse dap instance")
+
+	// Wait for the connection.
+	conn, err := listener.Accept()
+	if err != nil {
+		cmd.Process.Kill() // release the port
+		t.Fatalf("Failed to get connection: %v", err)
+	}
+	t.Log("dlv-reverse dialed in successfully")
+
+	client := daptest.NewClientWithConn(conn)
+	client.InitializeRequest()
+	client.ExpectInitializeResponse(t)
+
+	// Close the connection.
+	if err := conn.Close(); err != nil {
+		cmd.Process.Kill()
+		t.Fatalf("Failed to get connection: %v", err)
+	}
+
+	// Connection close should trigger dlv-reverse command's normal exit.
+	if err := cmd.Wait(); err != nil {
+		cmd.Process.Kill()
+		t.Fatalf("command failed: %v\n%s\n%v", err, buf.Bytes(), cmd.Process.Pid)
+	}
+}
+
 func TestTrace(t *testing.T) {
 	dlvbin, tmpdir := getDlvBin(t)
 	defer os.RemoveAll(tmpdir)

service/dap/daptest/client.go

@@ -37,6 +37,10 @@ func NewClient(addr string) *Client {
 	if err != nil {
 		log.Fatal("dialing:", err)
 	}
+	return NewClientWithConn(conn)
+}
+
+func NewClientWithConn(conn net.Conn) *Client {
 	c := &Client{conn: conn, reader: bufio.NewReader(conn)}
 	c.seq = 1 // match VS Code numbering
 	return c

service/dap/server.go

@@ -47,7 +47,8 @@ import (
 // program termination and failed or closed client connection
 // would also result in stopping this single-use server.
 //
-// The DAP server operates via the following goroutines:
+// The DAP server initialized with NewServer
+// operates via the following goroutines:
 //
 // (1) Main goroutine where the server is created via NewServer(),
 // started via Run() and stopped via Stop(). Once the server is
@@ -87,11 +88,20 @@ import (
 // They block on running debugger commands that are interrupted
 // when halt is issued while stopping. At that point these goroutines
 // wrap-up and exit.
+//
+// The DAP server set up using NewReverseDAPServer is a special
+// DAP server, that is bound to a single net.Conn. Once the connection
+// is closed, the server is stopped. Its Run is never called, but
+// the NewReverseDAPServer immediately starts serveDAPCodec on the
+// net.Conn.
 type Server struct {
 	// config is all the information necessary to start the debugger and server.
 	config *service.Config
 	// listener is used to accept the client connection.
 	listener net.Listener
+	// inReverseMode is true if this server operates in reverse mode
+	// where listener is nil.
+	inReverseMode bool
 	// stopTriggered is closed when the server is Stop()-ed.
 	stopTriggered chan struct{}
 	// reader is used to read requests from the connection.
@@ -197,9 +207,25 @@ const (
 // disconnects or requests shutdown. Once config.DisconnectChan is closed,
 // Server.Stop() must be called to shutdown this single-user server.
 func NewServer(config *service.Config) *Server {
+	return newServer(config, nil, false)
+}
+
+// NewReverseServer creates a special DAP server that operates in reverse mode.
+// Reverse DAP server is not actually running a TCP server listening on a port,
+// but communicates with the provided net.Conn only for a single debug session.
+func NewReverseServer(config *service.Config, conn net.Conn) *Server {
+	return newServer(config, conn, true)
+}
+
+func newServer(config *service.Config, conn net.Conn, inReverseMode bool) *Server {
 	logger := logflags.DAPLogger()
-	logflags.WriteDAPListeningMessage(config.Listener.Addr().String())
-	logger.Debug("DAP server pid = ", os.Getpid())
+	if !inReverseMode {
+		logflags.WriteDAPListeningMessage(config.Listener.Addr().String())
+		logger.Debug("DAP server pid = ", os.Getpid())
+	} else {
+		logger.Debug("Reverse DAP server pid = ", os.Getpid())
+	}
+
 	return &Server{
 		config:            config,
 		listener:          config.Listener,
@@ -209,6 +235,8 @@ func NewServer(config *service.Config) *Server {
 		variableHandles:   newVariablesHandlesMap(),
 		args:              defaultArgs,
 		exceptionErr:      nil,
+		inReverseMode:     inReverseMode,
+		conn:              conn,
 	}
 }
 
@@ -265,7 +293,10 @@ func (s *Server) setLaunchAttachArgs(request dap.LaunchAttachRequest) error {
 func (s *Server) Stop() {
 	s.log.Debug("DAP server stopping...")
 	close(s.stopTriggered)
-	_ = s.listener.Close()
+
+	if !s.inReverseMode {
+		_ = s.listener.Close()
+	}
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -326,6 +357,11 @@ func (s *Server) triggerServerStop() {
 // TODO(polina): allow new client connections for new debug sessions,
 // so the editor needs to launch delve only once?
 func (s *Server) Run() {
+	if s.inReverseMode {
+		go s.serveDAPCodec()
+		return
+	}
+
 	go func() {
 		conn, err := s.listener.Accept() // listener is closed in Stop()
 		if err != nil {