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

-:d80184d38152
+:08e853c0c77b
 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)
+)
+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])
+(False = local to remote, True = remote to local) (defaults to True)
-@type bool
+@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=False,
 ):
 """
 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 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
-if not venvName:
+if startRemote or venvName == self.debugServer.getEricServerEnvironmentString():
-venvName = Preferences.getDebugger("Python3VirtualEnv")
+# TODO change this once server environment definitions are supported
-if venvName == self.debugServer.getProjectEnvironmentString():
+startRemote = True
-project = ericApp().getObject("Project")
+venvName = self.debugServer.getEricServerEnvironmentString()
-venvName = project.getProjectVenv()
+interpreter = ""
-execPath = project.getProjectExecPath()
-interpreter = project.getProjectInterpreter()
 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
+self.__ericServerDebuggerInterface.stopClient()
+self.__mainDebugger = None
 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.__ericServerDebuggerInterface.stopClient()
+##self.__mainDebugger = None
+##
+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
 self.tr("""<p>No suitable Python3 environment configured.</p>"""),
 )
 return None, self.__isNetworked, ""
 self.__inShutdown = False
+self.__ericServerDebugging = False
+self.__ericServerDebuggerInterface.stopClient()
+self.__mainDebugger = None
 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, ""
+# TODO: add server debugging for projects
 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.
 """
 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):
 """
 "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
 jsonStr = data.decode("utf-8", "backslashreplace")
 logging.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
 "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:
+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