Merge pull request #40 from int19h/client

s/IDE/client/

Author: Pavel Minaev

src/debugpy/adapter/__main__.py

@@ -22,7 +22,7 @@
 def main(args):
     from debugpy import adapter
     from debugpy.common import compat, log, sockets
-    from debugpy.adapter import ide, servers, sessions
+    from debugpy.adapter import clients, servers, sessions
 
     if args.for_server is not None:
         if os.name == "posix":
@@ -58,15 +58,13 @@ def main(args):
     else:
         endpoints = {"server": {"host": server_host, "port": server_port}}
         try:
-            ide_host, ide_port = ide.serve(args.host, args.port)
+            client_host, client_port = clients.serve(args.host, args.port)
         except Exception as exc:
             if args.for_server is None:
                 raise
-            endpoints = {
-                "error": "Can't listen for IDE connections: " + str(exc)
-            }
+            endpoints = {"error": "Can't listen for client connections: " + str(exc)}
         else:
-            endpoints["client"] = {"host": ide_host, "port": ide_port}
+            endpoints["client"] = {"host": client_host, "port": client_port}
 
     if args.for_server is not None:
         log.info(
@@ -96,9 +94,7 @@ def main(args):
 
     listener_file = os.getenv("DEBUGPY_ADAPTER_ENDPOINTS")
     if listener_file is not None:
-        log.info(
-            "Writing endpoints info to {0!r}:\n{1!j}", listener_file, endpoints
-        )
+        log.info("Writing endpoints info to {0!r}:\n{1!j}", listener_file, endpoints)
 
         def delete_listener_file():
             log.info("Listener ports closed; deleting {0!r}", listener_file)
@@ -115,13 +111,13 @@ def delete_listener_file():
             raise log.exception("Error writing endpoints info to file:")
 
     if args.port is None:
-        ide.IDE("stdio")
+        clients.Client("stdio")
 
     # These must be registered after the one above, to ensure that the listener sockets
     # are closed before the endpoint info file is deleted - this way, another process
     # can wait for the file to go away as a signal that the ports are no longer in use.
     atexit.register(servers.stop_serving)
-    atexit.register(ide.stop_serving)
+    atexit.register(clients.stop_serving)
 
     servers.wait_until_disconnected()
     log.info("All debug servers disconnected; waiting for remaining sessions...")

src/debugpy/adapter/ide.py src/debugpy/adapter/clients.pysrc/debugpy/adapter/ide.py renamed to src/debugpy/adapter/clients.py

@@ -13,8 +13,8 @@
 from debugpy.adapter import components, servers, sessions
 
 
-class IDE(components.Component):
-    """Handles the IDE side of a debug session."""
+class Client(components.Component):
+    """Handles the client side of a debug session."""
 
     message_handler = components.Component.message_handler
 
@@ -36,7 +36,7 @@ class Expectations(components.Capabilities):
 
     def __init__(self, sock):
         if sock == "stdio":
-            log.info("Connecting to IDE over stdio...", self)
+            log.info("Connecting to client over stdio...", self)
             stream = messaging.JsonIOStream.from_stdio()
             # Make sure that nothing else tries to interfere with the stdio streams
             # that are going to be used for DAP communication from now on.
@@ -46,22 +46,22 @@ def __init__(self, sock):
             stream = messaging.JsonIOStream.from_socket(sock)
 
         with sessions.Session() as session:
-            super(IDE, self).__init__(session, stream)
+            super(Client, self).__init__(session, stream)
 
             self.client_id = None
             """ID of the connecting client. This can be 'test' while running tests."""
 
             self.has_started = False
-            """Whether the "launch" or "attach" request was received from the IDE, and
+            """Whether the "launch" or "attach" request was received from the client, and
             fully handled.
             """
 
             self.start_request = None
-            """The "launch" or "attach" request as received from the IDE.
+            """The "launch" or "attach" request as received from the client.
             """
 
             self._initialize_request = None
-            """The "initialize" request as received from the IDE, to propagate to the
+            """The "initialize" request as received from the client, to propagate to the
             server later."""
 
             self._deferred_events = []
@@ -70,11 +70,11 @@ def __init__(self, sock):
             """
 
             self._known_subprocesses = set()
-            """servers.Connection instances for subprocesses that this IDE has been
+            """servers.Connection instances for subprocesses that this client has been
             made aware of.
             """
 
-            session.ide = self
+            session.client = self
             session.register()
 
         # For the transition period, send the telemetry events with both old and new
@@ -97,26 +97,26 @@ def __init__(self, sock):
         )
 
     def propagate_after_start(self, event):
-        # pydevd starts sending events as soon as we connect, but the IDE doesn't
+        # pydevd starts sending events as soon as we connect, but the client doesn't
         # expect to see any until it receives the response to "launch" or "attach"
-        # request. If IDE is not ready yet, save the event instead of propagating
+        # request. If client is not ready yet, save the event instead of propagating
         # it immediately.
         if self._deferred_events is not None:
             self._deferred_events.append(event)
             log.debug("Propagation deferred.")
         else:
-            self.ide.channel.propagate(event)
+            self.client.channel.propagate(event)
 
     def _propagate_deferred_events(self):
-        log.debug("Propagating deferred events to {0}...", self.ide)
+        log.debug("Propagating deferred events to {0}...", self.client)
         for event in self._deferred_events:
             log.debug("Propagating deferred {0}", event.describe())
-            self.ide.channel.propagate(event)
-        log.info("All deferred events propagated to {0}.", self.ide)
+            self.client.channel.propagate(event)
+        log.info("All deferred events propagated to {0}.", self.client)
         self._deferred_events = None
 
-    # Generic event handler. There are no specific handlers for IDE events, because
-    # there are no events from the IDE in DAP - but we propagate them if we can, in
+    # Generic event handler. There are no specific handlers for client events, because
+    # there are no events from the client in DAP - but we propagate them if we can, in
     # case some events appear in future protocol versions.
     @message_handler
     def event(self, event):
@@ -166,7 +166,6 @@ def initialize_request(self, request):
     # See https://github.com/microsoft/vscode/issues/4902#issuecomment-368583522
     # for the sequence of request and events necessary to orchestrate the start.
     def _start_message_handler(f):
-
         @components.Component.message_handler
         def handle(self, request):
             assert request.is_request("launch", "attach")
@@ -195,7 +194,9 @@ def handle(self, request):
                         # The launcher is doing output redirection, so we don't need the
                         # server to do it, as well.
                         arguments = dict(arguments)
-                        arguments["debugOptions"] = list(debug_options - {"RedirectOutput"})
+                        arguments["debugOptions"] = list(
+                            debug_options - {"RedirectOutput"}
+                        )
 
                     if arguments.get("redirectOutput"):
                         arguments = dict(arguments)
@@ -232,7 +233,7 @@ def handle(self, request):
                 },
             )
 
-            # Let the IDE know that it can begin configuring the adapter.
+            # Let the client know that it can begin configuring the adapter.
             self.channel.send_event("initialized")
 
             self.start_request = request
@@ -310,12 +311,12 @@ def attach_request(self, request):
         #
         # If neither is specified, and "waitForAttach" is false, this is attach-by-socket
         # in which the server has spawned the adapter via debugpy.listen(). There
-        # is no PID known to the IDE in advance, but the server connection should be
+        # is no PID known to the client in advance, but the server connection should be
         # either be there already, or the server should be connecting shortly, so there
         # must be a timeout.
         #
         # In the last two cases, if there's more than one server connection already,
-        # this is a multiprocess re-attach. The IDE doesn't know the PID, so we just
+        # this is a multiprocess re-attach. The client doesn't know the PID, so we just
         # connect it to the oldest server connection that we have - in most cases, it
         # will be the one for the root debuggee process, but if it has exited already,
         # it will be some subprocess.
@@ -379,7 +380,7 @@ def configurationDone_request(self, request):
             self.start_request.respond({})
             self._propagate_deferred_events()
 
-        # Notify the IDE of any child processes of the debuggee that aren't already
+        # Notify the client of any child processes of the debuggee that aren't already
         # being debugged.
         for conn in servers.connections():
             if conn.server is None and conn.ppid == self.session.pid:
@@ -418,15 +419,15 @@ def debugpySystemInfo_request(self, request):
 
     @message_handler
     def terminate_request(self, request):
-        self.session.finalize('IDE requested "terminate"', terminate_debuggee=True)
+        self.session.finalize('client requested "terminate"', terminate_debuggee=True)
         return {}
 
     @message_handler
     def disconnect_request(self, request):
         terminate_debuggee = request("terminateDebuggee", bool, optional=True)
         if terminate_debuggee == ():
             terminate_debuggee = None
-        self.session.finalize('IDE requested "disconnect"', terminate_debuggee)
+        self.session.finalize('client requested "disconnect"', terminate_debuggee)
         return {}
 
     def notify_of_subprocess(self, conn):
@@ -460,7 +461,7 @@ def notify_of_subprocess(self, conn):
 
 def serve(host, port):
     global listener
-    listener = sockets.serve("IDE", IDE, host, port)
+    listener = sockets.serve("Client", Client, host, port)
     return listener.getsockname()
 
 

src/debugpy/adapter/components.py

@@ -20,7 +20,7 @@ def __init__(self, type):
 
 
 class Component(util.Observable):
-    """A component managed by a debug adapter: IDE, launcher, or debug server.
+    """A component managed by a debug adapter: client, launcher, or debug server.
 
     Every component belongs to a Session, which is used for synchronization and
     shared data.
@@ -65,8 +65,8 @@ def __str__(self):
         return fmt("{0}[{1}]", type(self).__name__, self.session.id)
 
     @property
-    def ide(self):
-        return self.session.ide
+    def client(self):
+        return self.session.client
 
     @property
     def launcher(self):

src/debugpy/adapter/launchers.py

@@ -34,24 +34,24 @@ def __init__(self, session, stream):
     @message_handler
     def process_event(self, event):
         self.pid = event("systemProcessId", int)
-        self.ide.propagate_after_start(event)
+        self.client.propagate_after_start(event)
 
     @message_handler
     def output_event(self, event):
-        self.ide.propagate_after_start(event)
+        self.client.propagate_after_start(event)
 
     @message_handler
     def exited_event(self, event):
         self.exit_code = event("exitCode", int)
-        # We don't want to tell the IDE about this just yet, because it will then
+        # We don't want to tell the client about this just yet, because it will then
         # want to disconnect, and the launcher might still be waiting for keypress
         # (if wait-on-exit was enabled). Instead, we'll report the event when we
         # receive "terminated" from the launcher, right before it exits.
 
     @message_handler
     def terminated_event(self, event):
         try:
-            self.ide.channel.send_event("exited", {"exitCode": self.exit_code})
+            self.client.channel.send_event("exited", {"exitCode": self.exit_code})
         except Exception:
             pass
         self.channel.close()
@@ -94,7 +94,7 @@ def on_launcher_connected(sock):
         if console == "internalConsole":
             log.info("{0} spawning launcher: {1!r}", session, cmdline)
 
-            # If we are talking to the IDE over stdio, sys.stdin and sys.stdout are
+            # If we are talking to the client over stdio, sys.stdin and sys.stdout are
             # redirected to avoid mangling the DAP message stream. Make sure the
             # launcher also respects that.
             subprocess.Popen(
@@ -107,12 +107,9 @@ def on_launcher_connected(sock):
 
         else:
             log.info('{0} spawning launcher via "runInTerminal" request.', session)
-            session.ide.capabilities.require("supportsRunInTerminalRequest")
-            kinds = {
-                "integratedTerminal": "integrated",
-                "externalTerminal": "external",
-            }
-            session.ide.channel.request(
+            session.client.capabilities.require("supportsRunInTerminalRequest")
+            kinds = {"integratedTerminal": "integrated", "externalTerminal": "external"}
+            session.client.channel.request(
                 "runInTerminal",
                 {
                     "kind": kinds[console],
@@ -124,9 +121,7 @@ def on_launcher_connected(sock):
 
         if not session.wait_for(lambda: session.launcher, timeout=10):
             raise start_request.cant_handle(
-                '{0} timed out waiting for {1} to connect',
-                session,
-                session.launcher,
+                "{0} timed out waiting for {1} to connect", session, session.launcher
             )
 
         try:

src/debugpy/adapter/servers.py

@@ -136,11 +136,11 @@ def __init__(self, sock):
             log.info("No active debug session for parent process of {0}.", self)
         else:
             try:
-                parent_session.ide.notify_of_subprocess(self)
+                parent_session.client.notify_of_subprocess(self)
             except Exception:
-                # This might fail if the IDE concurrently disconnects from the parent
+                # This might fail if the client concurrently disconnects from the parent
                 # session. We still want to keep the connection around, in case the
-                # IDE reconnects later. If the parent session was "launch", it'll take
+                # client reconnects later. If the parent session was "launch", it'll take
                 # care of closing the remaining server connections.
                 log.exception("Failed to notify parent session about {0}:", self)
 
@@ -159,7 +159,7 @@ def authenticate(self):
 
     def request(self, request):
         raise request.isnt_valid(
-            "Requests from the debug server to the IDE are not allowed."
+            "Requests from the debug server to the client are not allowed."
         )
 
     def event(self, event):
@@ -273,16 +273,16 @@ def request(self, request):
         # Do not delegate requests from the server by default. There is a security
         # boundary between the server and the adapter, and we cannot trust arbitrary
         # requests sent over that boundary, since they may contain arbitrary code
-        # that the IDE will execute - e.g. "runInTerminal". The adapter must only
+        # that the client will execute - e.g. "runInTerminal". The adapter must only
         # propagate requests that it knows are safe.
         raise request.isnt_valid(
-            "Requests from the debug server to the IDE are not allowed."
+            "Requests from the debug server to the client are not allowed."
         )
 
     # Generic event handler, used if there's no specific handler below.
     @message_handler
     def event(self, event):
-        self.ide.propagate_after_start(event)
+        self.client.propagate_after_start(event)
 
     @message_handler
     def initialized_event(self, event):
@@ -293,7 +293,7 @@ def initialized_event(self, event):
     def process_event(self, event):
         # If there is a launcher, it's handling the process event.
         if not self.launcher:
-            self.ide.propagate_after_start(event)
+            self.client.propagate_after_start(event)
 
     @message_handler
     def continued_event(self, event):
@@ -306,7 +306,7 @@ def continued_event(self, event):
         # in "launch" or "attach" request, which defaults to true. If explicitly set
         # to false, pydevd will only resume the thread that was stepping.
         #
-        # To ensure that the IDE is aware that other threads are getting resumed in
+        # To ensure that the client is aware that other threads are getting resumed in
         # that mode, pydevd sends a "continued" event with "allThreadsResumed": true.
         # when responding to a step request. This ensures correct behavior in VSCode
         # and other DAP-conformant clients.
@@ -316,14 +316,14 @@ def continued_event(self, event):
         # does not expect to see "continued" events explicitly reflecting that fact.
         # If such events are sent regardless, VS behaves erratically. Thus, we have
         # to suppress them specifically for VS.
-        if self.ide.client_id not in ("visualstudio", "vsformac"):
-            self.ide.propagate_after_start(event)
+        if self.client.client_id not in ("visualstudio", "vsformac"):
+            self.client.propagate_after_start(event)
 
     @message_handler
     def exited_event(self, event):
         # If there is a launcher, it's handling the exit code.
         if not self.launcher:
-            self.ide.propagate_after_start(event)
+            self.client.propagate_after_start(event)
 
     @message_handler
     def terminated_event(self, event):