eric: comparison eric6/Debugger/DebuggerInterfacePython.py

-:cc920e534ac0
+:72a72fd56494
 self.passive = passive
 self.process = None
 self.__variant = pythonVariant
 self.__startedVenv = ""
-self.qsock = None
 self.queue = []
+self.__master = None
 self.__connections = {}
 self.__pendingConnections = []
 # set default values for capabilities of clients
 self.clientCapabilities = ClientDefaultCapabilities
 """<p>The debugger backend could not be started.</p>"""))
 else:
 self.__startedVenv = venvName
 return process, self.__isNetworked, interpreter
 def getClientCapabilities(self):
 """
 Public method to retrieve the debug clients capabilities.
 @return debug client capabilities (integer)
 def newConnection(self, sock):
 """
 Public slot to handle a new connection.
-@param sock reference to the socket object (QTcpSocket)
+@param sock reference to the socket object
-@return flag indicating success (boolean)
+@type QTcpSocket
-"""
+@return flag indicating success
-sock.disconnected.connect(self.debugServer.startClient)
+@rtype bool
+"""
+self.__pendingConnections.append(sock)
 sock.readyRead.connect(lambda: self.__parseClientLine(sock))
+sock.disconnected.connect(lambda: self.__socketDisconnected(sock))
-if self.qsock is None:
-# first connection is the main one
-self.qsock = sock
-self.__pendingConnections.append(sock)
-# Get the remote clients capabilities
-self.remoteCapabilities()
 return True
 def __assignDebuggerId(self, sock, debuggerId):
 """
 Private method to set the debugger id for a recent debugger connection
 """
 if sock in self.__pendingConnections:
 self.__connections[debuggerId] = sock
 self.__pendingConnections.remove(sock)
+if self.__master is None:
+self.__master = debuggerId
+# Get the remote clients capabilities
+self.remoteCapabilities()
 self.debugServer.signalClientDebuggerIds(
 sorted(self.__connections.keys()))
+if debuggerId == self.__master:
+self.__flush()
+self.debugServer.masterClientConnected()
+self.debugServer.initializeClient(debuggerId)
+def __socketDisconnected(self, sock):
+"""
+Private slot handling a socket disconnecting.
+@param sock reference to the disconnected socket
+@type QTcpSocket
+"""
+for debuggerId in self.__connections:
+if self.__connections[debuggerId] is sock:
+del self.__connections[debuggerId]
+break
+else:
+if sock in self.__pendingConnections:
+self.__pendingConnections.remove(sock)
+if not self.__connections:
+# no active connections anymore => restart the backend
+self.debugServer.startClient()
 def getDebuggerIds(self):
 """
 Public method to return the IDs of the connected debugger backends.
 @return list of connected debugger backend IDs
 @rtype list of str
 """
 return sorted(self.__connections.keys())
-def flush(self):
+def __flush(self):
 """
-Public slot to flush the queue.
+Private slot to flush the queue.
 """
-if self.qsock:
+if self.__master:
 # Send commands that were waiting for the connection.
 for cmd in self.queue:
-self.__writeJsonCommandToSocket(cmd, self.qsock)
+self.__writeJsonCommandToSocket(
+cmd, self.__connections[self.__master])
 self.queue = []
 def shutdown(self):
 """
 Public method to cleanly shut down.
-It closes our socket and shuts down
+It closes our sockets and shuts down the debug clients.
-the debug client. (Needed on Win OS)
+(Needed on Win OS)
 """
-if self.qsock is None:
+if not self.__master:
 return
-for sock in (
+while self.__connections:
-list(self.__connections.values()) + self.__pendingConnections
+debuggerId, sock = self.__connections.popitem()
-):
+self.__shutdownSocket(sock)
-# do not want any slots called during shutdown
-sock.disconnected.disconnect()
+while self.__pendingConnections:
-sock.readyRead.disconnect()
+sock = self.__pendingConnections.pop()
+self.__shutdownSocket(sock)
-# close down socket, and shut down client as well.
-self.__sendJsonCommand("RequestShutdown", {}, sock=sock)
-sock.flush()
-sock.close()
 # reinitialize
-self.qsock = None
 self.queue = []
-self.__pendingConnections = []
+self.__master = None
-self.__connections = {}
+def __shutdownSocket(self, sock):
+"""
+Private slot to shut down a socket.
+@param sock reference to the socket
+@type QTcpSocket
+"""
+# do not want any slots called during shutdown
+sock.readyRead.disconnect()
+sock.disconnected.disconnect()
+# close down socket, and shut down client as well.
+self.__sendJsonCommand("RequestShutdown", {}, sock=sock)
+sock.flush()
+sock.close()
+sock.setParent(None)
+sock.deleteLater()
+del sock
 def isConnected(self):
 """
 Public method to test, if a debug client has connected.
-@return flag indicating the connection status (boolean)
+@return flag indicating the connection status
-"""
+@rtype bool
-return self.qsock is not None
+"""
+return bool(self.__connections)
 def remoteEnvironment(self, env):
 """
 Public method to set the environment for a program to debug, run, ...
 @param env environment settings (dictionary)
 """
-self.__sendJsonCommand("RequestEnvironment", {"environment": env})
+if self.__master:
+self.__sendJsonCommand("RequestEnvironment", {"environment": env},
+self.__master)
 def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
 autoContinue=True, autoFork=False, forkChild=False):
 """
 Public method to load a new program to debug.
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "traceInterpreter": traceInterpreter,
 "autofork": autoFork,
 "forkChild": forkChild,
-})
+}, self.__master)
 def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
 """
 Public method to load a new program to run.
 "workdir": wd,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "autofork": autoFork,
 "forkChild": forkChild,
-})
+}, self.__master)
 def remoteCoverage(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect coverage data.
 self.__sendJsonCommand("RequestCoverage", {
 "workdir": wd,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "erase": erase,
-})
+}, self.__master)
 def remoteProfile(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect profiling data.
 self.__sendJsonCommand("RequestProfile", {
 "workdir": wd,
 "filename": fn,
 "argv": Utilities.parseOptionString(argv),
 "erase": erase,
-})
+}, self.__master)
-def remoteStatement(self, stmt):
+def remoteStatement(self, debuggerId, stmt):
 """
 Public method to execute a Python statement.
-@param stmt the Python statement to execute (string). It
+@param debuggerId ID of the debugger backend
-should not have a trailing newline.
+@type str
+@param stmt the Python statement to execute.
+@type str
 """
 self.__sendJsonCommand("ExecuteStatement", {
 "statement": stmt,
-})
+}, debuggerId)
-def remoteStep(self):
+def remoteStep(self, debuggerId):
 """
 Public method to single step the debugged program.
-"""
-self.__sendJsonCommand("RequestStep", {})
+@param debuggerId ID of the debugger backend
+@type str
-def remoteStepOver(self):
+"""
+self.__sendJsonCommand("RequestStep", {}, debuggerId)
+def remoteStepOver(self, debuggerId):
 """
 Public method to step over the debugged program.
-"""
-self.__sendJsonCommand("RequestStepOver", {})
+@param debuggerId ID of the debugger backend
+@type str
-def remoteStepOut(self):
+"""
+self.__sendJsonCommand("RequestStepOver", {}, debuggerId)
+def remoteStepOut(self, debuggerId):
 """
 Public method to step out the debugged program.
-"""
-self.__sendJsonCommand("RequestStepOut", {})
+@param debuggerId ID of the debugger backend
+@type str
-def remoteStepQuit(self):
+"""
+self.__sendJsonCommand("RequestStepOut", {}, debuggerId)
+def remoteStepQuit(self, debuggerId):
 """
 Public method to stop the debugged program.
-"""
-self.__sendJsonCommand("RequestStepQuit", {})
+@param debuggerId ID of the debugger backend
+@type str
-def remoteContinue(self, special=False):
+"""
+self.__sendJsonCommand("RequestStepQuit", {}, debuggerId)
+def remoteContinue(self, debuggerId, special=False):
 """
 Public method to continue the debugged program.
+@param debuggerId ID of the debugger backend
+@type str
 @param special flag indicating a special continue operation
+@type bool
 """
 self.__sendJsonCommand("RequestContinue", {
 "special": special,
-})
+}, debuggerId)
-def remoteMoveIP(self, line):
+def remoteMoveIP(self, debuggerId, line):
 """
 Public method to move the instruction pointer to a different line.
+@param debuggerId ID of the debugger backend
+@type str
 @param line the new line, where execution should be continued
+@type int
 """
 self.__sendJsonCommand("RequestMoveIP", {
 "newLine": line,
-})
+}, debuggerId)
-def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
+def remoteBreakpoint(self, debuggerId, fn, line, setBreakpoint, cond=None,
+temp=False):
 """
 Public method to set or clear a breakpoint.
-@param fn filename the breakpoint belongs to (string)
+@param debuggerId ID of the debugger backend
-@param line linenumber of the breakpoint (int)
+@type str
-@param setBreakpoint flag indicating setting or resetting a
+@param fn filename the breakpoint belongs to
-breakpoint (boolean)
+@type str
-@param cond condition of the breakpoint (string)
+@param line linenumber of the breakpoint
-@param temp flag indicating a temporary breakpoint (boolean)
+@type int
-"""
+@param setBreakpoint flag indicating setting or resetting a breakpoint
-self.__sendJsonCommand("RequestBreakpoint", {
+@type bool
-"filename": self.translate(fn, False),
+@param cond condition of the breakpoint
-"line": line,
+@type str
-"temporary": temp,
+@param temp flag indicating a temporary breakpoint
-"setBreakpoint": setBreakpoint,
+@type bool
-"condition": cond,
+"""
-})
+if debuggerId:
+debuggerList = [debuggerId]
-def remoteBreakpointEnable(self, fn, line, enable):
+else:
+debuggerList = list(self.__connections.keys())
+for debuggerId in debuggerList:
+self.__sendJsonCommand("RequestBreakpoint", {
+"filename": self.translate(fn, False),
+"line": line,
+"temporary": temp,
+"setBreakpoint": setBreakpoint,
+"condition": cond,
+}, debuggerId)
+def remoteBreakpointEnable(self, debuggerId, fn, line, enable):
 """
 Public method to enable or disable a breakpoint.
-@param fn filename the breakpoint belongs to (string)
+@param debuggerId ID of the debugger backend
-@param line linenumber of the breakpoint (int)
+@type str
+@param fn filename the breakpoint belongs to
+@type str
+@param line linenumber of the breakpoint
+@type int
 @param enable flag indicating enabling or disabling a breakpoint
-(boolean)
+@type bool
 """
-self.__sendJsonCommand("RequestBreakpointEnable", {
+if debuggerId:
-"filename": self.translate(fn, False),
+debuggerList = [debuggerId]
-"line": line,
+else:
-"enable": enable,
+debuggerList = list(self.__connections.keys())
-})
+for debuggerId in debuggerList:
+self.__sendJsonCommand("RequestBreakpointEnable", {
-def remoteBreakpointIgnore(self, fn, line, count):
+"filename": self.translate(fn, False),
+"line": line,
+"enable": enable,
+}, debuggerId)
+def remoteBreakpointIgnore(self, debuggerId, fn, line, count):
 """
 Public method to ignore a breakpoint the next couple of occurrences.
-@param fn filename the breakpoint belongs to (string)
+@param debuggerId ID of the debugger backend
-@param line linenumber of the breakpoint (int)
+@type str
-@param count number of occurrences to ignore (int)
+@param fn filename the breakpoint belongs to
-"""
+@type str
-self.__sendJsonCommand("RequestBreakpointIgnore", {
+@param line linenumber of the breakpoint
-"filename": self.translate(fn, False),
+@type int
-"line": line,
+@param count number of occurrences to ignore
-"count": count,
+@type int
-})
+"""
+if debuggerId:
-def remoteWatchpoint(self, cond, setWatch, temp=False):
+debuggerList = [debuggerId]
+else:
+debuggerList = list(self.__connections.keys())
+for debuggerId in debuggerList:
+self.__sendJsonCommand("RequestBreakpointIgnore", {
+"filename": self.translate(fn, False),
+"line": line,
+"count": count,
+}, debuggerId)
+def remoteWatchpoint(self, debuggerId, cond, setWatch, temp=False):
 """
 Public method to set or clear a watch expression.
-@param cond expression of the watch expression (string)
+@param debuggerId ID of the debugger backend
+@type str
+@param cond expression of the watch expression
+@type str
 @param setWatch flag indicating setting or resetting a watch expression
-(boolean)
+@type bool
-@param temp flag indicating a temporary watch expression (boolean)
+@param temp flag indicating a temporary watch expression
-"""
+@type bool
-# cond is combination of cond and special (s. watch expression viewer)
+"""
-self.__sendJsonCommand("RequestWatch", {
+if debuggerId:
-"temporary": temp,
+debuggerList = [debuggerId]
-"setWatch": setWatch,
+else:
-"condition": cond,
+debuggerList = list(self.__connections.keys())
-})
+for debuggerId in debuggerList:
+# cond is combination of cond and special (s. watch expression
-def remoteWatchpointEnable(self, cond, enable):
+# viewer)
+self.__sendJsonCommand("RequestWatch", {
+"temporary": temp,
+"setWatch": setWatch,
+"condition": cond,
+}, debuggerId)
+def remoteWatchpointEnable(self, debuggerId, cond, enable):
 """
 Public method to enable or disable a watch expression.
-@param cond expression of the watch expression (string)
+@param debuggerId ID of the debugger backend
+@type str
+@param cond expression of the watch expression
+@type str
 @param enable flag indicating enabling or disabling a watch expression
-(boolean)
+@type bool
 """
-# cond is combination of cond and special (s. watch expression viewer)
+if debuggerId:
-self.__sendJsonCommand("RequestWatchEnable", {
+debuggerList = [debuggerId]
-"condition": cond,
+else:
-"enable": enable,
+debuggerList = list(self.__connections.keys())
-})
+for debuggerId in debuggerList:
+# cond is combination of cond and special (s. watch expression
-def remoteWatchpointIgnore(self, cond, count):
+# viewer)
+self.__sendJsonCommand("RequestWatchEnable", {
+"condition": cond,
+"enable": enable,
+}, debuggerId)
+def remoteWatchpointIgnore(self, debuggerId, cond, count):
 """
 Public method to ignore a watch expression the next couple of
 occurrences.
-@param cond expression of the watch expression (string)
+@param debuggerId ID of the debugger backend
-@param count number of occurrences to ignore (int)
+@type str
-"""
+@param cond expression of the watch expression
-# cond is combination of cond and special (s. watch expression viewer)
+@type str
-self.__sendJsonCommand("RequestWatchIgnore", {
+@param count number of occurrences to ignore
-"condition": cond,
+@type int
-"count": count,
+"""
-})
+if debuggerId:
+debuggerList = [debuggerId]
+else:
+debuggerList = list(self.__connections.keys())
+for debuggerId in debuggerList:
+# cond is combination of cond and special (s. watch expression
+# viewer)
+self.__sendJsonCommand("RequestWatchIgnore", {
+"condition": cond,
+"count": count,
+}, debuggerId)
+# TODO: add debuggerId
 def remoteRawInput(self, s):
 """
 Public method to send the raw input to the debugged program.
 @param s the raw input (string)
 """
 self.__sendJsonCommand("RawInput", {
 "input": s,
 })
-def remoteThreadList(self, debuggerId=""):
+def remoteThreadList(self, debuggerId):
 """
 Public method to request the list of threads from the client.
 @param debuggerId ID of the debugger backend
 @type str
 """
-self.__sendJsonCommand("RequestThreadList", {}, debuggerId=debuggerId)
+self.__sendJsonCommand("RequestThreadList", {}, debuggerId)
-def remoteSetThread(self, tid, debuggerId=""):
+def remoteSetThread(self, debuggerId, tid):
 """
 Public method to request to set the given thread as current thread.
+@param debuggerId ID of the debugger backend
+@type str
 @param tid id of the thread
 @type int
-@param debuggerId ID of the debugger backend
-@type str
 """
 self.__sendJsonCommand("RequestThreadSet", {
 "threadID": tid,
-}, debuggerId=debuggerId)
+}, debuggerId)
-def remoteClientStack(self, debuggerId=""):
+def remoteClientStack(self, debuggerId):
 """
 Public method to request the stack of the main thread.
 @param debuggerId ID of the debugger backend
 @type str
 """
-self.__sendJsonCommand("RequestStack", {}, debuggerId=debuggerId)
+self.__sendJsonCommand("RequestStack", {}, debuggerId)
-def remoteClientVariables(self, scope, filterList, framenr=0, maxSize=0,
+def remoteClientVariables(self, debuggerId, scope, filterList, framenr=0,
-debuggerId=""):
+maxSize=0):
 """
 Public method to request the variables of the debugged program.
+@param debuggerId ID of the debugger backend
+@type str
 @param scope the scope of the variables (0 = local, 1 = global)
 @type int
 @param filterList list of variable types to filter out
 @type list of int
 @param framenr framenumber of the variables to retrieve
 @type int
 @param maxSize maximum size the formatted value of a variable will
 be shown. If it is bigger than that, a 'too big' indication will
 be given (@@TOO_BIG_TO_SHOW@@).
 @type int
-@param debuggerId ID of the debugger backend
-@type str
 """
 self.__sendJsonCommand("RequestVariables", {
 "frameNumber": framenr,
 "scope": scope,
 "filters": filterList,
 "maxSize": maxSize,
-}, debuggerId=debuggerId)
+}, debuggerId)
-def remoteClientVariable(self, scope, filterList, var, framenr=0,
+def remoteClientVariable(self, debuggerId, scope, filterList, var,
-maxSize=0):
+framenr=0, maxSize=0):
 """
 Public method to request the variables of the debugged program.
+@param debuggerId ID of the debugger backend
+@type str
 @param scope the scope of the variables (0 = local, 1 = global)
 @type int
 @param filterList list of variable types to filter out
 @type list of int
 @param var list encoded name of variable to retrieve
 "variable": var,
 "frameNumber": framenr,
 "scope": scope,
 "filters": filterList,
 "maxSize": maxSize,
-})
+}, debuggerId)
+# TODO: add debuggerId
 def remoteClientSetFilter(self, scope, filterStr):
 """
 Public method to set a variables filter list.
 @param scope the scope of the variables (0 = local, 1 = global)
 self.__sendJsonCommand("RequestSetFilter", {
 "scope": scope,
 "filter": filterStr,
 })
-def setCallTraceEnabled(self, on):
+def setCallTraceEnabled(self, debuggerId, on):
 """
 Public method to set the call trace state.
-@param on flag indicating to enable the call trace function (boolean)
+@param debuggerId ID of the debugger backend
+@type str
+@param on flag indicating to enable the call trace function
+@type bool
 """
 self.__sendJsonCommand("RequestCallTrace", {
 "enable": on,
-})
+}, debuggerId)
 def remoteBanner(self):
 """
 Public slot to get the banner info of the remote client.
 """
 self.__sendJsonCommand("RequestBanner", {})
-def remoteCapabilities(self):
+def remoteCapabilities(self, debuggerId):
 """
 Public slot to get the debug clients capabilities.
-"""
-self.__sendJsonCommand("RequestCapabilities", {})
+@param debuggerId ID of the debugger backend
+@type str
+"""
+self.__sendJsonCommand("RequestCapabilities", {}, debuggerId)
 def remoteCompletion(self, text):
 """
 Public slot to get the a list of possible commandline completions
 from the remote client.
 elif method in ["ResponseLine", "ResponseStack"]:
 # Check if obsolet thread was clicked
 if params["stack"] == []:
 # Request updated list
-self.remoteThreadList()
+self.remoteThreadList(params["debuggerId"])
 return
 for s in params["stack"]:
 s[0] = self.translate(s[0], True)
 cf = params["stack"][0]
 if self.__autoContinue:
 self.__autoContinue = False
-QTimer.singleShot(0, self.remoteContinue)
+QTimer.singleShot(
+0, lambda: self.remoteContinue(params["debuggerId"]))
 else:
 self.debugServer.signalClientLine(
 cf[0], int(cf[1]), params["debuggerId"],
 method == "ResponseStack")
 self.debugServer.signalClientStack(
 self.debugServer.signalClientCallTrace(
 isCall,
 fromInfo["filename"], str(fromInfo["linenumber"]),
 fromInfo["codename"],
 toInfo["filename"], str(toInfo["linenumber"]),
-toInfo["codename"])
+toInfo["codename"],
+params["debuggerId"])
 elif method == "ResponseVariables":
 self.debugServer.signalClientVariables(
-params["scope"], params["variables"])
+params["scope"], params["variables"], params["debuggerId"])
 elif method == "ResponseVariable":
 self.debugServer.signalClientVariable(
-params["scope"], [params["variable"]] + params["variables"])
+params["scope"], [params["variable"]] + params["variables"],
+params["debuggerId"])
 elif method == "ResponseThreadList":
 self.debugServer.signalClientThreadList(
 params["currentID"], params["threadList"],
 params["debuggerId"])
 elif method == "ResponseThreadSet":
-self.debugServer.signalClientThreadSet()
+self.debugServer.signalClientThreadSet(params["debuggerId"])
 elif method == "ResponseCapabilities":
 self.clientCapabilities = params["capabilities"]
-self.debugServer.signalClientCapabilities(
+if params["debuggerId"] == self.__master:
-params["capabilities"],
+# signal only for the master connection
-params["clientType"],
+self.debugServer.signalClientCapabilities(
-self.__startedVenv,
+params["capabilities"],
-)
+params["clientType"],
+self.__startedVenv,
+)
 elif method == "ResponseBanner":
-self.debugServer.signalClientBanner(
+if params["debuggerId"] == self.__master:
-params["version"],
+# signal only for the master connection
-params["platform"],
+self.debugServer.signalClientBanner(
-params["dbgclient"],
+params["version"],
-self.__startedVenv,
+params["platform"],
-)
+params["dbgclient"],
+self.__startedVenv,
+)
 elif method == "ResponseOK":
-self.debugServer.signalClientStatement(False)
+self.debugServer.signalClientStatement(False, params["debuggerId"])
 elif method == "ResponseContinue":
-self.debugServer.signalClientStatement(True)
+self.debugServer.signalClientStatement(True, params["debuggerId"])
+# TODO: add debuggerId
 elif method == "RequestRaw":
 self.debugServer.signalClientRawInput(
 params["prompt"], params["echo"])
+# TODO: add debuggerId
 elif method == "ResponseBPConditionError":
 fn = self.translate(params["filename"], True)
 self.debugServer.signalClientBreakConditionError(
 fn, params["line"])
+# TODO: add debuggerId
 elif method == "ResponseClearBreakpoint":
 fn = self.translate(params["filename"], True)
 self.debugServer.signalClientClearBreak(fn, params["line"])
+# TODO: add debuggerId
 elif method == "ResponseWatchConditionError":
 self.debugServer.signalClientWatchConditionError(
 params["condition"])
+# TODO: add debuggerId
 elif method == "ResponseClearWatch":
 self.debugServer.signalClientClearWatch(params["condition"])
 elif method == "ResponseException":
-if params:
+exctype = params["type"]
-exctype = params["type"]
+excmessage = params["message"]
-excmessage = params["message"]
+stack = params["stack"]
-stack = params["stack"]
+if stack:
-if stack:
+for stackEntry in stack:
+stackEntry[0] = self.translate(stackEntry[0], True)
+if stack[0] and stack[0][0] == "<string>":
 for stackEntry in stack:
-stackEntry[0] = self.translate(stackEntry[0], True)
+if stackEntry[0] == "<string>":
-if stack[0] and stack[0][0] == "<string>":
+stackEntry[0] = self.__scriptName
-for stackEntry in stack:
+else:
-if stackEntry[0] == "<string>":
+break
-stackEntry[0] = self.__scriptName
-else:
-break
-else:
-exctype = ''
-excmessage = ''
-stack = []
 self.debugServer.signalClientException(
-exctype, excmessage, stack)
+exctype, excmessage, stack, params["debuggerId"])
 elif method == "ResponseSyntax":
 self.debugServer.signalClientSyntaxError(
 params["message"], self.translate(params["filename"], True),
-params["linenumber"], params["characternumber"])
+params["linenumber"], params["characternumber"],
+params["debuggerId"])
 elif method == "ResponseSignal":
 self.debugServer.signalClientSignal(
 params["message"], self.translate(params["filename"], True),
-params["linenumber"], params["function"], params["arguments"])
+params["linenumber"], params["function"], params["arguments"],
+params["debuggerId"])
 elif method == "ResponseExit":
 self.__scriptName = ""
 self.debugServer.signalClientExit(
-params["status"], params["message"])
+params["status"], params["message"], params["debuggerId"])
 elif method == "PassiveStartup":
 self.debugServer.passiveStartUp(
 self.translate(params["filename"], True), params["exceptions"])
 elif method == "ResponseCompletion":
-self.debugServer.signalClientCompletionList(
+if params["debuggerId"] == self.__master:
-params["completions"], params["text"])
+# signal only for the master connection
+self.debugServer.signalClientCompletionList(
+params["completions"], params["text"])
+###################################################################
+## Unit test related stuff is not done with multi processing
+###################################################################
 elif method == "ResponseUTDiscover":
 self.debugServer.clientUtDiscovered(
 params["testCasesList"], params["exception"],
 params["message"])
 elif method == "ResponseUTTestSucceededUnexpected":
 self.debugServer.clientUtTestSucceededUnexpected(
 params["testname"], params["id"])
+# TODO: add debuggerId
 elif method == "RequestForkTo":
 self.__askForkTo()
 def __sendJsonCommand(self, command, params, debuggerId="", sock=None):
 """
 }
 cmd = json.dumps(commandDict) + '\n'
 if debuggerId and debuggerId in self.__connections:
 sock = self.__connections[debuggerId]
-elif sock is None and self.qsock is not None:
+elif sock is None and self.__master is not None:
-sock = self.qsock
+sock = self.__connections[self.__master]
 if sock is not None:
 self.__writeJsonCommandToSocket(cmd, sock)
 else:
 self.queue.append(cmd)

Mercurial Repositories > eric / file comparison

comparison: eric6/Debugger/DebuggerInterfacePython.py

eric6/Debugger/DebuggerInterfacePython.py