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

-:28b14d2df6a1
+:be23a662d709
 import os
 import shlex
 import struct
 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.__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
 runInConsole,
 venvName,
 originalPathString,
 workingDir="",
 configOverride=None,
-startRemote=False,
+startRemote=None,
 ):
 """
 Public method to start a remote Python interpreter.
 @param port port number the debug server is listening on
 @type str (optional)
 @param configOverride dictionary containing the global config override data
 (defaults to None)
 @type dict (optional)
 @param startRemote flag indicating to start the client via an eric-ide server
-(defaults to False)
+(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 startRemote or venvName == self.debugServer.getEricServerEnvironmentString():
+if (
+(
+startRemote is True
+or (
+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
 venvName = self.debugServer.getEricServerEnvironmentString()
 interpreter = ""
 else:
 )
 return None, False, ""
 self.__inShutdown = False
+self.__ericServerDebuggerInterface.stopClient()
 self.__ericServerDebugging = False
-self.__ericServerDebuggerInterface.stopClient()
 self.__mainDebugger = None
 redirect = (
 str(configOverride["redirect"])
 if configOverride and configOverride["enable"]
 )
 return None, False, ""
 elif startRemote and self.__ericServerDebuggerInterface is not None:
 # debugging via an eric-ide server
-##self.__ericServerDebuggerInterface.stopClient()
-##self.__mainDebugger = None
-##
 self.translate = self.__ericServerTranslation
 self.__ericServerDebugging = True
 args = []
 if noencoding:
 @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)
 """
+# TODO: 'startRemoteForProject()' - implement the 'startRemote' logic like
+#       for 'startRemote'.
 global origPathEnv
 project = ericApp().getObject("Project")
 if not project.isDebugPropertiesLoaded():
 return None, self.__isNetworked, ""
 )
 return None, self.__isNetworked, ""
 self.__inShutdown = False
+self.__ericServerDebuggerInterface.stopClient()
 self.__ericServerDebugging = False
-self.__ericServerDebuggerInterface.stopClient()
 self.__mainDebugger = None
 if project.getDebugProperty("REMOTEDEBUGGER"):
 # remote debugging code
 ipaddr = self.debugServer.getHostAddress(False)
 @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)
-self.debugServer.signalLastClientExited()
-self.__autoContinued.clear()
+@pyqtSlot()
-if not self.__inShutdown:
+def __handleServerLastClientExited(self):
-self.debugServer.startClient()
+"""
+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.debugServer.signalLastClientExited()
+self.__autoContinued.clear()
+if not self.__inShutdown:
+self.debugServer.startClient()
 def getDebuggerIds(self):
 """
 Public method to return the IDs of the connected debugger backends.
 @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 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",
 )
 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:

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Debugger/DebuggerInterfacePython.py

src/eric7/Debugger/DebuggerInterfacePython.py