eric: comparison src/eric7/Debugger/DebuggerInterfacePython.py

-:2b015db9761a
+:ba20efe10336
 import shlex
 import struct
 import time
 import zlib
-from PyQt6.QtCore import QObject, QProcess, QProcessEnvironment, QTimer
+from PyQt6.QtCore import QObject, QProcess, QProcessEnvironment, QTimer, pyqtSlot
 from eric7 import Preferences, Utilities
 from eric7.EricWidgets import EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.Globals import getConfig
 self.__isNetworked = True
 self.__autoContinue = False
 self.__autoContinued = []
 self.__isStepCommand = False
+self.__ericServerDebugging = False  # are we debugging via the eric-ide server?
+try:
+self.__ericServerDebuggerInterface = (
+ericApp().getObject("EricServer").getServiceInterface("Debugger")
+)
+self.__ericServerDebuggerInterface.debugClientResponse.connect(
+lambda jsonStr: self.handleJsonCommand(jsonStr, None)
+)
+self.__ericServerDebuggerInterface.debugClientDisconnected.connect(
+self.__handleServerDebugClientDisconnected
+)
+self.__ericServerDebuggerInterface.lastClientExited.connect(
+self.__handleServerLastClientExited
+)
+except KeyError:
+self.__ericServerDebuggerInterface = None
 self.debugServer = debugServer
 self.passive = passive
 self.process = None
 self.__startedVenv = ""
 Private method to perform the identity path translation.
 @param fn filename to be translated
 @type str
 @param remote2local flag indicating the direction of translation
-(False = local to remote, True = remote to local [default]) (unused)
+(False = local to remote, True = remote to local) (defaults to True)
-@type bool
+(unused)
+@type bool (optional)
 @return translated filename
 @rtype str
 """
 return fn
 Private method to perform the path translation.
 @param fn filename to be translated
 @type str
 @param remote2local flag indicating the direction of translation
-(False = local to remote, True = remote to local [default])
+(False = local to remote, True = remote to local) (defaults to True)
-@type bool
+@type bool (optional)
 @return translated filename
 @rtype str
 """
 if remote2local:
 path = fn.replace(self.translateRemote, self.translateLocal)
 if not self.translateRemoteWindows:
 path = path.replace("\\", "/")
 return path
-def __startProcess(self, program, arguments, environment=None, workingDir=None):
+def __ericServerTranslation(self, fn, remote2local=True):
+"""
+Private method to perform the eric-ide server path translation.
+@param fn filename to be translated
+@type str
+@param remote2local flag indicating the direction of translation
+(False = local to remote, True = remote to local) (defaults to True)
+@type bool (optional)
+@return translated filename
+@rtype str
+"""
+if remote2local:
+return FileSystemUtilities.remoteFileName(fn)
+else:
+return FileSystemUtilities.plainFileName(fn)
+def __startProcess(self, program, arguments, environment=None, workingDir=""):
 """
 Private method to start the debugger client process.
 @param program name of the executable to start
 @type str
 self,
 port,
 runInConsole,
 venvName,
 originalPathString,
-workingDir=None,
+workingDir="",
 configOverride=None,
+startRemote=None,
 ):
 """
 Public method to start a remote Python interpreter.
 @param port port number the debug server is listening on
 @type bool
 @param venvName name of the virtual environment to be used
 @type str
 @param originalPathString original PATH environment variable
 @type str
-@param workingDir directory to start the debugger client in
+@param workingDir directory to start the debugger client in (defaults to "")
-@type str
+@type str (optional)
-@param configOverride dictionary containing the global config override
+@param configOverride dictionary containing the global config override data
-data
+(defaults to None)
-@type dict
+@type dict (optional)
+@param startRemote flag indicating to start the client via an eric-ide server
+(defaults to None)
+@type bool (optional)
 @return client process object, a flag to indicate a network connection
 and the name of the interpreter in case of a local execution
 @rtype tuple of (QProcess, bool, str)
 """
 global origPathEnv
-if not venvName:
+if (
-venvName = Preferences.getDebugger("Python3VirtualEnv")
+startRemote is True
-if venvName == self.debugServer.getProjectEnvironmentString():
+or (
-project = ericApp().getObject("Project")
+startRemote is None
-venvName = project.getProjectVenv()
+and (
-execPath = project.getProjectExecPath()
+venvName == self.debugServer.getEricServerEnvironmentString()
-interpreter = project.getProjectInterpreter()
+or self.__ericServerDebugging
+)
+)
+) and ericApp().getObject("EricServer").isServerConnected():
+# TODO change this once server environment definitions are supported
+startRemote = True
+if venvName:
+venvManager = ericApp().getObject("VirtualEnvManager")
+interpreter = venvManager.getVirtualenvInterpreter(venvName)
+else:
+venvName = self.debugServer.getEricServerEnvironmentString()
+interpreter = ""  # use the interpreter of the server
 else:
-venvManager = ericApp().getObject("VirtualEnvManager")
+if not venvName:
-interpreter = venvManager.getVirtualenvInterpreter(venvName)
+venvName = Preferences.getDebugger("Python3VirtualEnv")
-execPath = venvManager.getVirtualenvExecPath(venvName)
+if venvName == self.debugServer.getProjectEnvironmentString():
-if interpreter == "":
+project = ericApp().getObject("Project")
-# use the interpreter used to run eric for identical variants
+venvName = project.getProjectVenv()
-interpreter = PythonUtilities.getPythonExecutable()
+execPath = project.getProjectExecPath()
-if interpreter == "":
+interpreter = project.getProjectInterpreter()
-EricMessageBox.critical(
+else:
-None,
+venvManager = ericApp().getObject("VirtualEnvManager")
-self.tr("Start Debugger"),
+interpreter = venvManager.getVirtualenvInterpreter(venvName)
-self.tr("""<p>No suitable Python3 environment configured.</p>"""),
+execPath = venvManager.getVirtualenvExecPath(venvName)
-)
+if interpreter == "":
-return None, False, ""
+# use the interpreter used to run eric for identical variants
+interpreter = PythonUtilities.getPythonExecutable()
+if interpreter == "":
+EricMessageBox.critical(
+None,
+self.tr("Start Debugger"),
+self.tr("""<p>No suitable Python3 environment configured.</p>"""),
+)
+return None, False, ""
 self.__inShutdown = False
+self.__ericServerDebugging = False
 redirect = (
 str(configOverride["redirect"])
 if configOverride and configOverride["enable"]
 else str(Preferences.getDebugger("Python3Redirect"))
 " login was given.</p>"
 ),
 )
 return None, False, ""
+elif startRemote and self.__ericServerDebuggerInterface is not None:
+# debugging via an eric-ide server
+self.translate = self.__ericServerTranslation
+self.__ericServerDebugging = True
+args = []
+if noencoding:
+args.append(noencoding)
+if multiprocessEnabled:
+args.append(multiprocessEnabled)
+if callTraceOptimization:
+args.append(callTraceOptimization)
+self.__ericServerDebuggerInterface.startClient(
+interpreter,
+originalPathString,
+args,
+workingDir=workingDir,
+)
+self.__startedVenv = venvName
+return None, self.__isNetworked, ""
 else:
 # local debugging code below
 debugClient = self.__determineDebugClient()
 # set translation function
 runInConsole,
 venvName,
 originalPathString,
 workingDir=None,
 configOverride=None,
+startRemote=False,
 ):
 """
 Public method to start a remote Python interpreter for a project.
 @param port port number the debug server is listening on
 @param workingDir directory to start the debugger client in
 @type str
 @param configOverride dictionary containing the global config override
 data
 @type dict
+@param startRemote flag indicating to start the client via an eric-ide server
+(defaults to False)
+@type bool (optional)
 @return client process object, a flag to indicate a network connection
 and the name of the interpreter in case of a local execution
 @rtype tuple of (QProcess, bool, str)
 """
 global origPathEnv
 "--call-trace-optimization"
 if Preferences.getDebugger("PythonCallTraceOptimization")
 else ""
 )
-if venvName and venvName != self.debugServer.getProjectEnvironmentString():
+if (
-venvManager = ericApp().getObject("VirtualEnvManager")
+startRemote is True
-interpreter = venvManager.getVirtualenvInterpreter(venvName)
+or (
-execPath = venvManager.getVirtualenvExecPath(venvName)
+startRemote is None
+and (
+venvName == self.debugServer.getEricServerEnvironmentString()
+or self.__ericServerDebugging
+)
+)
+) and ericApp().getObject("EricServer").isServerConnected():
+# TODO change this once server environment definitions are supported
+startRemote = True
+if venvName and venvName != self.debugServer.getProjectEnvironmentString():
+venvManager = ericApp().getObject("VirtualEnvManager")
+interpreter = venvManager.getVirtualenvInterpreter(venvName)
+else:
+venvName = project.getProjectVenv()
+interpreter = project.getProjectInterpreter()
+if not venvName:
+venvName = self.debugServer.getEricServerEnvironmentString()
+interpreter = ""  # use the interpreter of the server
 else:
-venvName = project.getProjectVenv()
+if venvName and venvName != self.debugServer.getProjectEnvironmentString():
-execPath = project.getProjectExecPath()
+venvManager = ericApp().getObject("VirtualEnvManager")
-interpreter = project.getProjectInterpreter()
+interpreter = venvManager.getVirtualenvInterpreter(venvName)
-if interpreter == "":
+execPath = venvManager.getVirtualenvExecPath(venvName)
-EricMessageBox.critical(
+else:
-None,
+venvName = project.getProjectVenv()
-self.tr("Start Debugger"),
+execPath = project.getProjectExecPath()
-self.tr("""<p>No suitable Python3 environment configured.</p>"""),
+interpreter = project.getProjectInterpreter()
-)
+if interpreter == "":
-return None, self.__isNetworked, ""
+EricMessageBox.critical(
+None,
+self.tr("Start Debugger"),
+self.tr("""<p>No suitable Python3 environment configured.</p>"""),
+)
+return None, self.__isNetworked, ""
 self.__inShutdown = False
+self.__ericServerDebugging = False
 if project.getDebugProperty("REMOTEDEBUGGER"):
 # remote debugging code
 ipaddr = self.debugServer.getHostAddress(False)
 rexec = project.getDebugProperty("REMOTECOMMAND")
 return process, self.__isNetworked, ""
 else:
 # remote shell command is missing
 return None, self.__isNetworked, ""
+elif startRemote and self.__ericServerDebuggerInterface is not None:
+# debugging via an eric-ide server
+self.translate = self.__ericServerTranslation
+self.__ericServerDebugging = True
+args = []
+if noencoding:
+args.append(noencoding)
+if multiprocessEnabled:
+args.append(multiprocessEnabled)
+if callTraceOptimization:
+args.append(callTraceOptimization)
+self.__ericServerDebuggerInterface.startClient(
+interpreter,
+originalPathString,
+args,
+workingDir=workingDir,
+)
+self.__startedVenv = venvName
+return None, self.__isNetworked, ""
 else:
 # local debugging code below
 debugClient = project.getDebugProperty("DEBUGCLIENT")
 if not bool(debugClient) or not os.path.exists(debugClient):
 debugClient = self.__determineDebugClient()
 @return flag indicating success
 @rtype bool
 """
 self.__pendingConnections.append(sock)
-sock.readyRead.connect(lambda: self.__parseClientLine(sock))
+sock.readyRead.connect(lambda: self.__receiveJson(sock))
 sock.disconnected.connect(lambda: self.__socketDisconnected(sock))
 return True
 def __assignDebuggerId(self, sock, debuggerId):
 @param sock reference to the socket object
 @type QTcpSocket
 @param debuggerId id of the connected debug client
 @type str
 """
-if sock in self.__pendingConnections:
+if sock and sock in self.__pendingConnections:
 self.__connections[debuggerId] = sock
 self.__pendingConnections.remove(sock)
 if self.__mainDebugger is None:
 self.__mainDebugger = debuggerId
 # Get the remote clients capabilities
 self.remoteCapabilities(debuggerId)
 self.debugServer.signalClientDebuggerId(debuggerId)
 if debuggerId == self.__mainDebugger:
 self.__flush()
 self.debugServer.mainClientConnected()
 self.debugServer.initializeClient(debuggerId)
 # perform auto-continue except for main
 if (
 debuggerId != self.__mainDebugger
 and self.__autoContinue
 and not self.__isStepCommand
 ):
 QTimer.singleShot(0, lambda: self.remoteContinue(debuggerId))
 def __socketDisconnected(self, sock):
 """
 Private slot handling a socket disconnecting.
 @type QTcpSocket
 """
 for debuggerId in list(self.__connections):
 if self.__connections[debuggerId] is sock:
 del self.__connections[debuggerId]
-if debuggerId == self.__mainDebugger:
+self.__handleServerDebugClientDisconnected(debuggerId)
-self.__mainDebugger = None
-if debuggerId in self.__autoContinued:
-self.__autoContinued.remove(debuggerId)
-if not self.__inShutdown:
-with contextlib.suppress(RuntimeError):
-# can be ignored during a shutdown
-self.debugServer.signalClientDisconnected(debuggerId)
 break
 else:
 if sock in self.__pendingConnections:
 self.__pendingConnections.remove(sock)
 if not self.__connections:
 # no active connections anymore
+self.__handleServerLastClientExited()
+@pyqtSlot(str)
+def __handleServerDebugClientDisconnected(self, debuggerId):
+"""
+Private slot handling the disconnect of a debug client.
+@param debuggerId ID of the disconnected debugger
+@type str
+"""
+if debuggerId == self.__mainDebugger:
+self.__mainDebugger = None
+if debuggerId in self.__autoContinued:
+self.__autoContinued.remove(debuggerId)
+if not self.__inShutdown:
 with contextlib.suppress(RuntimeError):
-# debug server object might have been deleted already
+# can be ignored during a shutdown
-# ignore this
+self.debugServer.signalClientDisconnected(debuggerId)
+@pyqtSlot()
+def __handleServerLastClientExited(self):
+"""
+Private slot to handle the exit of the last debug client connected.
+"""
+with contextlib.suppress(RuntimeError):
+# debug server object might have been deleted already
+# ignore this
+self.__autoContinued.clear()
+if not self.__inShutdown:
 self.debugServer.signalLastClientExited()
-self.__autoContinued.clear()
+self.debugServer.startClient()
-if not self.__inShutdown:
-self.debugServer.startClient()
 def getDebuggerIds(self):
 """
 Public method to return the IDs of the connected debugger backends.
 """
 Private slot to flush the queue.
 """
 if self.__mainDebugger:
 # Send commands that were waiting for the connection.
-conn = self.__connections[self.__mainDebugger]
+if self.__ericServerDebugging:
 for jsonStr in self.__commandQueue:
-self.__writeJsonCommandToSocket(jsonStr, conn)
+self.__ericServerDebuggerInterface.sendClientCommand(
+self.__mainDebugger, jsonStr
+)
+else:
+conn = self.__connections[self.__mainDebugger]
+for jsonStr in self.__commandQueue:
+self.__writeJsonCommandToSocket(jsonStr, conn)
 self.__commandQueue.clear()
 def shutdown(self):
 """
 self.__shutdownSocket(sock)
 while self.__pendingConnections:
 sock = self.__pendingConnections.pop()
 self.__shutdownSocket(sock)
+self.__ericServerDebuggerInterface.stopClient()
 # reinitialize
 self.__commandQueue.clear()
 self.__mainDebugger = None
 Public method to test, if a debug client has connected.
 @return flag indicating the connection status
 @rtype bool
 """
-return bool(self.__connections)
+return bool(self.__connections) or self.__ericServerDebugging
 def remoteEnvironment(self, env):
 """
 Public method to set the environment for a program to debug, run, ...
 @type bool
 @param reportAllExceptions flag indicating to report all exceptions
 instead of unhandled exceptions only
 @type bool
 """
+if FileSystemUtilities.isPlainFileName(fn):
+fn = os.path.abspath(fn)
 self.__autoContinue = autoContinue
-self.__scriptName = os.path.abspath(fn)
+self.__scriptName = fn
 self.__isStepCommand = False
 wd = self.translate(wd, False)
-fn = self.translate(os.path.abspath(fn), False)
+fn = self.translate(fn, False)
 self.__sendJsonCommand(
 "RequestLoad",
 {
 "workdir": wd,
 "filename": fn,
 @param argv list of command line arguments to pass to the program
 @type list of str
 @param wd working directory for the program
 @type str
 """
-self.__scriptName = os.path.abspath(fn)
+if FileSystemUtilities.isPlainFileName(fn):
+fn = os.path.abspath(fn)
+self.__scriptName = fn
 wd = self.translate(wd, False)
-fn = self.translate(os.path.abspath(fn), False)
+fn = self.translate(fn, False)
 self.__sendJsonCommand(
 "RequestRun",
 {
 "workdir": wd,
 "filename": fn,
 @type str
 @param erase flag indicating that coverage info should be
 cleared first
 @type bool
 """
-self.__scriptName = os.path.abspath(fn)
+if FileSystemUtilities.isPlainFileName(fn):
+fn = os.path.abspath(fn)
+self.__scriptName = fn
 wd = self.translate(wd, False)
-fn = self.translate(os.path.abspath(fn), False)
+fn = self.translate(fn, False)
 self.__sendJsonCommand(
 "RequestCoverage",
 {
 "workdir": wd,
 "filename": fn,
 @type str
 @param erase flag indicating that timing info should be cleared
 first
 @type bool
 """
-self.__scriptName = os.path.abspath(fn)
+if FileSystemUtilities.isPlainFileName(fn):
+fn = os.path.abspath(fn)
+self.__scriptName = fn
 wd = self.translate(wd, False)
-fn = self.translate(os.path.abspath(fn), False)
+fn = self.translate(fn, False)
 self.__sendJsonCommand(
 "RequestProfile",
 {
 "workdir": wd,
 "filename": fn,
 @param cond condition of the breakpoint
 @type str
 @param temp flag indicating a temporary breakpoint
 @type bool
 """
-debuggerList = [debuggerId] if debuggerId else list(self.__connections)
+if debuggerId:
+debuggerList = [debuggerId]
+elif self.__ericServerDebugging:
+debuggerList = ["<<all>>"]
+else:
+debuggerList = list(self.__connections)
 for debuggerId in debuggerList:
 self.__sendJsonCommand(
 "RequestBreakpoint",
 {
 "filename": self.translate(fn, False),
 @param line line number of the breakpoint
 @type int
 @param enable flag indicating enabling or disabling a breakpoint
 @type bool
 """
-debuggerList = [debuggerId] if debuggerId else list(self.__connections)
+if debuggerId:
+debuggerList = [debuggerId]
+elif self.__ericServerDebugging:
+debuggerList = ["<<all>>"]
+else:
+debuggerList = list(self.__connections)
 for debuggerId in debuggerList:
 self.__sendJsonCommand(
 "RequestBreakpointEnable",
 {
 "filename": self.translate(fn, False),
 @param line line number of the breakpoint
 @type int
 @param count number of occurrences to ignore
 @type int
 """
-debuggerList = [debuggerId] if debuggerId else list(self.__connections)
+if debuggerId:
+debuggerList = [debuggerId]
+elif self.__ericServerDebugging:
+debuggerList = ["<<all>>"]
+else:
+debuggerList = list(self.__connections)
 for debuggerId in debuggerList:
 self.__sendJsonCommand(
 "RequestBreakpointIgnore",
 {
 "filename": self.translate(fn, False),
 @param setWatch flag indicating setting or resetting a watch expression
 @type bool
 @param temp flag indicating a temporary watch expression
 @type bool
 """
-debuggerList = [debuggerId] if debuggerId else list(self.__connections)
+if debuggerId:
+debuggerList = [debuggerId]
+elif self.__ericServerDebugging:
+debuggerList = ["<<all>>"]
+else:
+debuggerList = list(self.__connections)
 for debuggerId in debuggerList:
 # cond is combination of cond and special (s. watch expression
 # viewer)
 self.__sendJsonCommand(
 "RequestWatch",
 @param cond expression of the watch expression
 @type str
 @param enable flag indicating enabling or disabling a watch expression
 @type bool
 """
-debuggerList = [debuggerId] if debuggerId else list(self.__connections)
+if debuggerId:
+debuggerList = [debuggerId]
+elif self.__ericServerDebugging:
+debuggerList = ["<<all>>"]
+else:
+debuggerList = list(self.__connections)
 for debuggerId in debuggerList:
 # cond is combination of cond and special (s. watch expression
 # viewer)
 self.__sendJsonCommand(
 "RequestWatchEnable",
 @param cond expression of the watch expression
 @type str
 @param count number of occurrences to ignore
 @type int
 """
-debuggerList = [debuggerId] if debuggerId else list(self.__connections)
+if debuggerId:
+debuggerList = [debuggerId]
+elif self.__ericServerDebugging:
+debuggerList = ["<<all>>"]
+else:
+debuggerList = list(self.__connections)
 for debuggerId in debuggerList:
 # cond is combination of cond and special (s. watch expression
 # viewer)
 self.__sendJsonCommand(
 "RequestWatchIgnore",
 "text": text,
 },
 debuggerId,
 )
-def __parseClientLine(self, sock):
+def __receiveJson(self, sock):
 """
 Private method to handle data from the client.
 @param sock reference to the socket to read data from
 @type QTcpSocket
 # corrupted data -> discard and continue
 continue
 jsonStr = data.decode("utf-8", "backslashreplace")
-logging.debug("<Debug-Server> %s", jsonStr)
+logging.getLogger(__name__).debug("<Debug-Server> %s", jsonStr)
 ##print("Server: ", jsonStr)    ## debug       # __IGNORE_WARNING_M891__
-self.__handleJsonCommand(jsonStr, sock)
+self.handleJsonCommand(jsonStr, sock)
-def __handleJsonCommand(self, jsonStr, sock):
+def handleJsonCommand(self, jsonStr, sock):
 """
-Private method to handle a command or response serialized as a
+Public method to handle a command or response serialized as a
 JSON string.
 @param jsonStr string containing the command or response received
 from the debug backend
 @type str
 elif method == "RequestRaw":
 self.debugServer.signalClientRawInput(
 params["prompt"], params["echo"], params["debuggerId"]
 )
+pass
 elif method == "ResponseBPConditionError":
 fn = self.translate(params["filename"], True)
 self.debugServer.signalClientBreakConditionError(
 fn, params["line"], params["debuggerId"]
 )
 elif method == "ResponseExit":
 self.__scriptName = ""
 self.debugServer.signalClientExit(
-params["program"],
+self.translate(params["program"], True),
 params["status"],
 params["message"],
 params["debuggerId"],
 )
 if params["debuggerId"] == self.__mainDebugger:
 "method": command,
 "params": params,
 }
 jsonStr = json.dumps(commandDict)
-if debuggerId and debuggerId in self.__connections:
+if self.__ericServerDebugging:
-sock = self.__connections[debuggerId]
+# Debugging via the eric-ide server -> pass the command on to it
-elif sock is None and self.__mainDebugger is not None:
+if self.__mainDebugger is None:
-sock = self.__connections[self.__mainDebugger]
+# debugger has not connected yet -> queue the command
-if sock is not None:
+self.__commandQueue.append(jsonStr)
-self.__writeJsonCommandToSocket(jsonStr, sock)
+else:
+self.__ericServerDebuggerInterface.sendClientCommand(
+debuggerId, jsonStr
+)
 else:
-self.__commandQueue.append(jsonStr)
+# Local debugging -> send the command to the client
+if debuggerId and debuggerId in self.__connections:
+sock = self.__connections[debuggerId]
+elif sock is None and self.__mainDebugger is not None:
+with contextlib.suppress(KeyError):
+sock = self.__connections[self.__mainDebugger]
+if sock is not None:
+self.__writeJsonCommandToSocket(jsonStr, sock)
+else:
+self.__commandQueue.append(jsonStr)
 def __writeJsonCommandToSocket(self, jsonCommand, sock):
 """
 Private method to write a JSON command to the socket.

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Debugger/DebuggerInterfacePython.py

src/eric7/Debugger/DebuggerInterfacePython.py