eric: comparison src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py

-:d35d6f96c24b
+:b3672d3e7644
 import subprocess
 import sys
 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.
 """
 def __init__(self, server):
 Constructor
 @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,
 }
 f" {address[0]}, port {address[1]}"
 )
 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.
 #######################################################################
 data = types.SimpleNamespace(
 name="debug_client",
 address=address,
 handler=self.__serviceDbgClientConnection,
 )
-self.__server.getSelector().register(
+self._server.getSelector().register(connection, selectors.EVENT_READ, data=data)
-connection, selectors.EVENT_READ, data=data
-)
 def __serviceDbgClientConnection(self, key):
 """
 Private method to service the debug client connection.
 @param key reference to the SelectorKey object associated with the connection
 to be serviced
 @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
 self.__clientSocketDisconnected(sock)
 elif data:
 data["params"]["platform"] += " (eric-ide Server)"
 # 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},
 )
 # 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):
 """
 Private method handling a socket disconnecting.
 @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
 f"'Debug Client' connection from {address[0]}, port {address[1]} closed."
 )
 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},
 )
 def __mainClientExited(self):
 """
 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 ""},
 )
 return
 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
 self.__mainClientId = None
 self.__client = None
 @param debuggerId ID of the debugger the socket belongs to
 @type str
 @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},
 )
 )
 )
 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])
 workingDir = params["working_dir"] if params["working_dir"] else None
 debuggerId = self.__mainClientId
 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.")

Mercurial Repositories > eric / file comparison

comparison: src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py

src/eric7/RemoteServer/EricServerDebuggerRequestHandler.py