Working to address some of the basic architectural issues with the socket listeners.

* Moved the socket handling logic into lldb/tools/lldb-dap/Socket.{h,cpp}
* Reworked the unit tests to read the socket information from the DAP process, this allows for lldb-dap to start with a connection like 'tcp://localhost:0' and pick a random port for the test. The output will be printed to stdout, listing all the addresses that were resolved from the connection parameter.

Author: ashgti

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py

@@ -9,6 +9,7 @@
 import string
 import subprocess
 import sys
+import selectors
 import threading
 import time
 
@@ -1150,36 +1151,37 @@ def request_setInstructionBreakpoints(self, memory_reference=[]):
         }
         return self.send_recv(command_dict)
 
+
 class DebugAdaptorServer(DebugCommunication):
     def __init__(
         self,
         executable=None,
         launch=True,
-        port=None,
-        unix_socket=None,
+        connection=None,
         init_commands=[],
         log_file=None,
         env=None,
     ):
         self.process = None
         if launch:
-            self.process = DebugAdaptorServer.launch(
+            self.process, connection = DebugAdaptorServer.launch(
                 executable,
-                port=port,
-                unix_socket=unix_socket,
+                connection=connection,
                 log_file=log_file,
                 env=env,
             )
 
-        if port:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.connect(("127.0.0.1", port))
-            DebugCommunication.__init__(
-                self, s.makefile("rb"), s.makefile("wb"), init_commands, log_file
-            )
-        elif unix_socket:
-            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            s.connect(unix_socket)
+        if connection:
+            print("attempting connection", connection)
+            if connection.startswith("unix://"):  # unix:///path
+                s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+                s.connect(connection.removeprefix("unix://"))
+            elif connection.startswith("tcp://"):  # tcp://host:port
+                host, port = connection.removeprefix("tcp://").split(":", 1)
+                # create_connection with try both ipv4 and ipv6.
+                s = socket.create_connection((host, int(port)))
+            else:
+                raise ValueError("invalid connection: {}".format(connection))
             DebugCommunication.__init__(
                 self, s.makefile("rb"), s.makefile("wb"), init_commands, log_file
             )
@@ -1202,22 +1204,22 @@ def terminate(self):
 
     @classmethod
     def launch(
-        cls, executable: str, /, port=None, unix_socket=None, log_file=None, env=None
-    ) -> subprocess.Popen:
+        cls, executable: str, /, connection=None, log_file=None, env=None
+    ) -> tuple[subprocess.Popen, str]:
         adaptor_env = os.environ.copy()
         if env:
             adaptor_env.update(env)
 
         if log_file:
             adaptor_env["LLDBDAP_LOG"] = log_file
 
+        if os.uname().sysname == "Darwin":
+            adaptor_env["NSUnbufferedIO"] = "YES"
+
         args = [executable]
-        if port:
-            args.append("--port")
-            args.append(str(port))
-        elif unix_socket:
-            args.append("--unix-socket")
-            args.append(unix_socket)
+        if connection:
+            args.append("--connection")
+            args.append(connection)
 
         proc = subprocess.Popen(
             args,
@@ -1227,11 +1229,34 @@ def launch(
             env=adaptor_env,
         )
 
-        if port or unix_socket:
-            # Wait for the server to startup.
-            time.sleep(0.1)
-
-        return proc
+        if connection:
+            # If a conneciton is specified, lldb-dap will print the listening
+            # address once the listener is made to stdout. The listener is
+            # formatted like `tcp://host:port` or `unix:///path`.
+            with selectors.DefaultSelector() as sel:
+                print("Reading stdout for the listening connection")
+                os.set_blocking(proc.stdout.fileno(), False)
+                stdout_key = sel.register(proc.stdout, selectors.EVENT_READ)
+                rdy_fds = sel.select(timeout=10.0)
+                for key, _ in rdy_fds:
+                    if key != stdout_key:
+                        continue
+
+                    outs = proc.stdout.read(1024).decode()
+                    os.set_blocking(proc.stdout.fileno(), True)
+                    for line in outs.split("\n"):
+                        if not line.startswith("Listening for: "):
+                            continue
+                        # If the listener expanded into multiple addresses, use the first.
+                        connection = line.removeprefix("Listening for: ").split(",")[0]
+                        print("")
+                        return proc, connection
+                proc.kill()
+                raise ValueError(
+                    "lldb-dap started with a connection but failed to write the listening address to stdout."
+                )
+
+        return proc, None
 
 
 def attach_options_specified(options):

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py

@@ -10,10 +10,10 @@
 class DAPTestCaseBase(TestBase):
     # set timeout based on whether ASAN was enabled or not. Increase
     # timeout by a factor of 10 if ASAN is enabled.
-    timeoutval = 10 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
+    timeoutval = 10 * (10 if ("ASAN_OPTIONS" in os.environ) else 1)
     NO_DEBUG_INFO_TESTCASE = True
 
-    def create_debug_adaptor(self, env=None, launch=True, port=None, unix_socket=None):
+    def create_debug_adaptor(self, env=None, launch=True, connection=None):
         """Create the Visual Studio Code debug adaptor"""
         self.assertTrue(
             is_exe(self.lldbDAPExec), "lldb-dap must exist and be executable"
@@ -22,8 +22,7 @@ def create_debug_adaptor(self, env=None, launch=True, port=None, unix_socket=Non
         self.dap_server = dap_server.DebugAdaptorServer(
             executable=self.lldbDAPExec,
             launch=launch,
-            port=port,
-            unix_socket=unix_socket,
+            connection=connection,
             init_commands=self.setUpCommands(),
             log_file=log_file_path,
             env=env,
@@ -33,15 +32,13 @@ def build_and_create_debug_adaptor(
         self,
         lldbDAPEnv=None,
         lldbDAPLaunch=True,
-        lldbDAPPort=None,
-        lldbDAPUnixSocket=None,
+        lldbDAPConnection=None,
     ):
         self.build()
         self.create_debug_adaptor(
             env=lldbDAPEnv,
             launch=lldbDAPLaunch,
-            port=lldbDAPPort,
-            unix_socket=lldbDAPUnixSocket,
+            connection=lldbDAPConnection,
         )
 
     def set_source_breakpoints(self, source_path, lines, data=None):
@@ -489,18 +486,16 @@ def build_and_launch(
         customThreadFormat=None,
         launchCommands=None,
         expectFailure=False,
-        lldbDAPPort=None,
-        lldbDAPUnixSocket=None,
         lldbDAPLaunch=True,
+        lldbDAPConnection=None,
     ):
         """Build the default Makefile target, create the DAP debug adaptor,
         and launch the process.
         """
         self.build_and_create_debug_adaptor(
             lldbDAPEnv=lldbDAPEnv,
             lldbDAPLaunch=lldbDAPLaunch,
-            lldbDAPPort=lldbDAPPort,
-            lldbDAPUnixSocket=lldbDAPUnixSocket,
+            lldbDAPConnection=lldbDAPConnection,
         )
         self.assertTrue(os.path.exists(program), "executable must exist")
 

lldb/test/API/tools/lldb-dap/server/TestDAP_server.py

@@ -12,10 +12,10 @@
 
 
 class TestDAP_server(lldbdap_testcase.DAPTestCaseBase):
-    def do_test_server(self, port=None, unix_socket=None):
+    def do_test_server(self, connection):
         log_file_path = self.getBuildArtifact("dap.txt")
-        server = dap_server.DebugAdaptorServer.launch(
-            self.lldbDAPExec, port=port, unix_socket=unix_socket, log_file=log_file_path
+        server, connection = dap_server.DebugAdaptorServer.launch(
+            self.lldbDAPExec, connection, log_file=log_file_path
         )
 
         def cleanup():
@@ -30,7 +30,7 @@ def cleanup():
         breakpoint_line = line_number(source, "// breakpoint")
 
         # Initial connection over the port.
-        self.create_debug_adaptor(launch=False, port=port, unix_socket=unix_socket)
+        self.create_debug_adaptor(launch=False, connection=connection)
         self.launch(
             program,
             disconnectAutomatically=False,
@@ -43,7 +43,7 @@ def cleanup():
         self.dap_server.request_disconnect()
 
         # Second connection over the port.
-        self.create_debug_adaptor(launch=False, port=port, unix_socket=unix_socket)
+        self.create_debug_adaptor(launch=False, connection=connection)
         self.launch(program)
         self.set_source_breakpoints(source, [breakpoint_line])
         self.continue_to_next_stop()
@@ -55,12 +55,13 @@ def test_server_port(self):
         """
         Test launching a binary with a lldb-dap in server mode on a specific port.
         """
-        port = pickrandomport()
-        self.do_test_server(port=port)
+        self.do_test_server(connection="tcp://localhost:0")
 
     def test_server_unix_socket(self):
         """
         Test launching a binary with a lldb-dap in server mode on a unix socket.
         """
         dir = tempfile.gettempdir()
-        self.do_test_server(unix_socket=dir + "/dap-connection-" + str(os.getpid()))
+        self.do_test_server(
+            connection="unix://" + dir + "/dap-connection-" + str(os.getpid())
+        )

lldb/tools/lldb-dap/CMakeLists.txt

@@ -26,19 +26,20 @@ add_lldb_tool(lldb-dap
   lldb-dap.cpp
   Breakpoint.cpp
   BreakpointBase.cpp
+  DAP.cpp
   ExceptionBreakpoint.cpp
   FifoFiles.cpp
   FunctionBreakpoint.cpp
+  InstructionBreakpoint.cpp
   IOStream.cpp
   JSONUtils.cpp
   LLDBUtils.cpp
   OutputRedirector.cpp
   ProgressEvent.cpp
   RunInTerminal.cpp
+  Socket.cpp
   SourceBreakpoint.cpp
-  DAP.cpp
   Watchpoint.cpp
-  InstructionBreakpoint.cpp
 
   LINK_LIBS
     liblldb

lldb/tools/lldb-dap/DAP.cpp

@@ -14,11 +14,14 @@
 #include "DAP.h"
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
+#include "OutputRedirector.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBStream.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #if defined(_WIN32)
@@ -32,10 +35,10 @@ using namespace lldb_dap;
 
 namespace lldb_dap {
 
-DAP::DAP(llvm::StringRef path, std::shared_ptr<std::ofstream> log,
+DAP::DAP(llvm::StringRef path, std::shared_ptr<llvm::raw_ostream> log,
          ReplMode repl_mode, std::vector<std::string> pre_init_commands)
-    : debug_adaptor_path(path), broadcaster("lldb-dap"),
-      log(log), exception_breakpoints(), pre_init_commands(pre_init_commands),
+    : debug_adaptor_path(path), broadcaster("lldb-dap"), log(log),
+      exception_breakpoints(), pre_init_commands(pre_init_commands),
       focus_tid(LLDB_INVALID_THREAD_ID), stop_at_entry(false), is_attach(false),
       enable_auto_variable_summaries(false),
       enable_synthetic_child_debugging(false),
@@ -48,6 +51,28 @@ DAP::DAP(llvm::StringRef path, std::shared_ptr<std::ofstream> log,
 
 DAP::~DAP() = default;
 
+llvm::Error DAP::ConfigureIO(int out_fd, int err_fd) {
+  llvm::Expected<int> new_stdout_fd =
+      RedirectFd(out_fd, [this](llvm::StringRef data) {
+        SendOutput(OutputType::Stdout, data);
+      });
+  if (auto Err = new_stdout_fd.takeError()) {
+    return Err;
+  }
+  llvm::Expected<int> new_stderr_fd =
+      RedirectFd(err_fd, [this](llvm::StringRef data) {
+        SendOutput(OutputType::Stderr, data);
+      });
+  if (auto Err = new_stderr_fd.takeError()) {
+    return Err;
+  }
+
+  out = lldb::SBFile(new_stdout_fd.get(), "w", false);
+  err = lldb::SBFile(new_stderr_fd.get(), "w", false);
+
+  return llvm::Error::success();
+}
+
 /// Return string with first character capitalized.
 static std::string capitalize(llvm::StringRef str) {
   if (str.empty())
@@ -183,9 +208,9 @@ void DAP::SendJSON(const llvm::json::Value &json) {
   if (log) {
     auto now = std::chrono::duration<double>(
         std::chrono::system_clock::now().time_since_epoch());
-    *log << llvm::formatv("{0:f9} <-- ", now.count()).str() << std::endl
+    *log << llvm::formatv("{0:f9} <-- ", now.count()).str() << "\n"
          << "Content-Length: " << json_str.size() << "\r\n\r\n"
-         << llvm::formatv("{0:2}", json).str() << std::endl;
+         << llvm::formatv("{0:2}", json).str() << "\n";
   }
 }
 
@@ -213,8 +238,8 @@ std::string DAP::ReadJSON() {
   if (log) {
     auto now = std::chrono::duration<double>(
         std::chrono::system_clock::now().time_since_epoch());
-    *log << llvm::formatv("{0:f9} --> ", now.count()).str() << std::endl
-         << "Content-Length: " << length << "\r\n\r\n";
+    *log << llvm::formatv("{0:f9} --> ", now.count()).str()
+         << "\nContent-Length: " << length << "\r\n\r\n";
   }
   return json_str;
 }
@@ -654,20 +679,20 @@ PacketStatus DAP::GetNextObject(llvm::json::Object &object) {
       std::string error_str;
       llvm::raw_string_ostream strm(error_str);
       strm << error;
-      *log << "error: failed to parse JSON: " << error_str << std::endl
-           << json << std::endl;
+      *log << "error: failed to parse JSON: " << error_str << "\n"
+           << json << "\n";
     }
     return PacketStatus::JSONMalformed;
   }
 
   if (log) {
-    *log << llvm::formatv("{0:2}", *json_value).str() << std::endl;
+    *log << llvm::formatv("{0:2}", *json_value).str() << "\n";
   }
 
   llvm::json::Object *object_ptr = json_value->getAsObject();
   if (!object_ptr) {
     if (log)
-      *log << "error: json packet isn't a object" << std::endl;
+      *log << "error: json packet isn't a object\n";
     return PacketStatus::JSONNotObject;
   }
   object = *object_ptr;
@@ -681,8 +706,7 @@ bool DAP::HandleObject(const llvm::json::Object &object) {
     auto handler_pos = request_handlers.find(command);
     if (handler_pos == request_handlers.end()) {
       if (log)
-        *log << "error: unhandled command \"" << command.data() << "\""
-             << std::endl;
+        *log << "error: unhandled command \"" << command.data() << "\"\n";
       return false; // Fail
     }