src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py

branch
server
changeset 10767
b3672d3e7644
parent 10764
5915ca2466b2
child 10953
42166c630d9b
diff -r d35d6f96c24b -r b3672d3e7644 src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py
--- a/src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py	Mon Jun 10 11:41:34 2024 +0200
+++ b/src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py	Mon Jun 10 15:42:05 2024 +0200
@@ -16,9 +16,10 @@
 import types
 
 from .EricRequestCategory import EricRequestCategory
+from .EricServerBaseRequestHandler import EricServerBaseRequestHandler
 
 
-class EricServerDebuggerRequestHandler:
+class EricServerDebuggerRequestHandler(EricServerBaseRequestHandler):
     """
     Class implementing the debugger request handler of the eric-ide server.
     """
@@ -30,9 +31,11 @@
         @param server reference to the eric-ide server object
         @type EricServer
         """
-        self.__server = server
+        super().__init__(server)
 
-        self.__requestMethodMapping = {
+        self._category = EricRequestCategory.Debugger
+
+        self._requestMethodMapping = {
             "StartClient": self.__startClient,
             "StopClient": self.__stopClient,
             "DebugClientCommand": self.__relayDebugClientCommand,
@@ -65,38 +68,10 @@
         data = types.SimpleNamespace(
             name="server", acceptHandler=self.__acceptDbgClientConnection
         )
-        self.__server.getSelector().register(
+        self._server.getSelector().register(
             self.__socket, selectors.EVENT_READ, data=data
         )
 
-    def handleRequest(self, request, params, reqestUuid):
-        """
-        Public method handling the received debugger requests.
-
-        @param request request name
-        @type str
-        @param params dictionary containing the request parameters
-        @type dict
-        @param reqestUuid UUID of the associated request as sent by the eric IDE
-        @type str
-        """
-        try:
-            result = self.__requestMethodMapping[request](params)
-            if result:
-                self.__server.sendJson(
-                    category=EricRequestCategory.Debugger,
-                    reply=request,
-                    params=result,
-                    reqestUuid=reqestUuid,
-                )
-
-        except KeyError:
-            self.__server.sendJson(
-                category=EricRequestCategory.Debugger,
-                reply="DebuggerRequestError",
-                params={"Error": f"Request type '{request}' is not supported."},
-            )
-
     #######################################################################
     ## DebugServer like methods.
     #######################################################################
@@ -119,9 +94,7 @@
             address=address,
             handler=self.__serviceDbgClientConnection,
         )
-        self.__server.getSelector().register(
-            connection, selectors.EVENT_READ, data=data
-        )
+        self._server.getSelector().register(connection, selectors.EVENT_READ, data=data)
 
     def __serviceDbgClientConnection(self, key):
         """
@@ -132,7 +105,7 @@
         @type selectors.SelectorKey
         """
         sock = key.fileobj
-        data = self.__server.receiveJsonCommand(sock)
+        data = self._server.receiveJsonCommand(sock)
 
         if data is None:
             # socket was closed by debug client
@@ -155,7 +128,7 @@
             # 2. pass on the data to the eric-ide
             jsonStr = json.dumps(data)
             # - print("Client Response:", jsonStr)
-            self.__server.sendJson(
+            self._server.sendJson(
                 category=EricRequestCategory.Debugger,
                 reply="DebugClientResponse",
                 params={"response": jsonStr},
@@ -164,7 +137,7 @@
             # 3. process debug client messages after relaying
             if method == "ResponseExit":
                 for sock in list(self.__connections.values()):
-                    if not self.__server.isSocketClosed(sock):
+                    if not self._server.isSocketClosed(sock):
                         self.__clientSocketDisconnected(sock)
 
     def __clientSocketDisconnected(self, sock):
@@ -174,7 +147,7 @@
         @param sock reference to the disconnected socket
         @type socket.socket
         """
-        self.__server.getSelector().unregister(sock)
+        self._server.getSelector().unregister(sock)
 
         address = sock.getpeername()
         print(  # noqa: M801
@@ -184,7 +157,7 @@
         for debuggerId in list(self.__connections):
             if self.__connections[debuggerId] is sock:
                 del self.__connections[debuggerId]
-                self.__server.sendJson(
+                self._server.sendJson(
                     category=EricRequestCategory.Debugger,
                     reply="DebugClientDisconnected",
                     params={"debugger_id": debuggerId},
@@ -204,7 +177,7 @@
         """
         Private method to handle exiting of the main debug client.
         """
-        self.__server.sendJson(
+        self._server.sendJson(
             category=EricRequestCategory.Debugger,
             reply="MainClientExited",
             params={"debugger_id": self.__mainClientId if self.__mainClientId else ""},
@@ -221,13 +194,13 @@
         while self.__pendingConnections:
             sock = self.__pendingConnections.pop()
             commandDict = self.__prepareClientCommand("RequestShutdown", {})
-            self.__server.sendJsonCommand(commandDict, sock)
+            self._server.sendJsonCommand(commandDict, sock)
             self.__shutdownSocket("", sock)
 
         while self.__connections:
             debuggerId, sock = self.__connections.popitem()
             commandDict = self.__prepareClientCommand("RequestShutdown", {})
-            self.__server.sendJsonCommand(commandDict, sock)
+            self._server.sendJsonCommand(commandDict, sock)
             self.__shutdownSocket(debuggerId, sock)
 
         # reinitialize
@@ -243,12 +216,12 @@
         @param sock reference to the socket
         @type socket.socket
         """
-        self.__server.getSelector().unregister(sock)
+        self._server.getSelector().unregister(sock)
         sock.shutdown(socket.SHUT_RDWR)
         sock.close()
 
         if debuggerId:
-            self.__server.sendJson(
+            self._server.sendJson(
                 category=EricRequestCategory.Debugger,
                 reply="DebugClientDisconnected",
                 params={"debugger_id": debuggerId},
@@ -297,7 +270,7 @@
         ipaddr, port = self.__socket.getsockname()
         args = [
             params["interpreter"] if params["interpreter"] else sys.executable,
-            debugClient
+            debugClient,
         ]
         args.extend(params["arguments"])
         args.extend([str(port), "True", ipaddr])
@@ -346,11 +319,11 @@
         if debuggerId == "<<all>>":
             # broadcast to all connected debug clients
             for sock in self.__connections.values():
-                self.__server.sendJsonCommand(jsonStr, sock)
+                self._server.sendJsonCommand(jsonStr, sock)
         else:
             try:  # noqa: Y105
                 sock = self.__connections[debuggerId]
-                self.__server.sendJsonCommand(jsonStr, sock)
+                self._server.sendJsonCommand(jsonStr, sock)
             except KeyError:
                 pass
                 # - print(f"Command for unknown debugger ID '{debuggerId}' received.")

eric ide

mercurial