eric: comparison eric6/Debugger/DebuggerInterfacePython.py

-:067f717c5a80
+:021f0252afac
 self.__variant = pythonVariant
 self.__startedVenv = ""
 self.qsock = None
 self.queue = []
+self.__connections = {}
+self.__pendingConnections = []
 # set default values for capabilities of clients
 self.clientCapabilities = ClientDefaultCapabilities
 # set translation function
 Public slot to handle a new connection.
 @param sock reference to the socket object (QTcpSocket)
 @return flag indicating success (boolean)
 """
-# If we already have a connection, refuse this one.  It will be closed
-# automatically.
-if self.qsock is not None:
-return False
 sock.disconnected.connect(self.debugServer.startClient)
-sock.readyRead.connect(self.__parseClientLine)
+sock.readyRead.connect(lambda: self.__parseClientLine(sock))
-self.qsock = 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
+attempt.
+@param sock reference to the socket object
+@type QTcpSocket
+@param debuggerId id of the connected debug client
+@type str
+"""
+if sock in self.__pendingConnections:
+self.__connections[debuggerId] = sock
+self.__pendingConnections.remove(sock)
 def flush(self):
 """
 Public slot to flush the queue.
 """
-# Send commands that were waiting for the connection.
+if self.qsock:
-for cmd in self.queue:
+# Send commands that were waiting for the connection.
-self.__writeJsonCommandToSocket(cmd)
+for cmd in self.queue:
+self.__writeJsonCommandToSocket(cmd, self.qsock)
 self.queue = []
 def shutdown(self):
 """
 the debug client. (Needed on Win OS)
 """
 if self.qsock is None:
 return
-# do not want any slots called during shutdown
+for sock in (
-self.qsock.disconnected.disconnect(self.debugServer.startClient)
+list(self.__connections.values()) + self.__pendingConnections
-self.qsock.readyRead.disconnect(self.__parseClientLine)
+):
+# do not want any slots called during shutdown
-# close down socket, and shut down client as well.
+sock.disconnected.disconnect()
-self.__sendJsonCommand("RequestShutdown", {})
+sock.readyRead.disconnect()
-self.qsock.flush()
-self.qsock.close()
+# 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.__connections = {}
 def isConnected(self):
 """
 Public method to test, if a debug client has connected.
 else:
 self.__sendJsonCommand("ResponseForkTo", {
 "target": "child",
 })
-def __parseClientLine(self):
+def __parseClientLine(self, sock):
 """
 Private method to handle data from the client.
-"""
-while self.qsock and self.qsock.canReadLine():
+@param sock reference to the socket to read data from
-qs = self.qsock.readLine()
+@type QTcpSocket
+"""
+while sock and sock.canReadLine():
+qs = sock.readLine()
 if self.codec is not None:
 line = self.codec.toUnicode(qs)
 else:
 line = bytes(qs).decode()
 logging.debug("<Debug-Server> %s", line)
 ##            print("Server: ", line)          ##debug
-self.__handleJsonCommand(line)
+self.__handleJsonCommand(line, sock)
 continue
-def __handleJsonCommand(self, jsonStr):
+def __handleJsonCommand(self, jsonStr, sock):
 """
 Private 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
+@param sock reference to the socket the data was received from
+@type QTcpSocket
 """
 import json
 try:
 commandDict = json.loads(jsonStr.strip())
 return
 method = commandDict["method"]
 params = commandDict["params"]
-if method == "ClientOutput":
+if method == "DebuggerId":
+self.__assignDebuggerId(sock, params["id"])
+elif method == "ClientOutput":
 self.debugServer.signalClientOutput(params["text"])
 elif method in ["ResponseLine", "ResponseStack"]:
 # Check if obsolet thread was clicked
 if params["stack"] == []:
 params["testname"], params["id"])
 elif method == "RequestForkTo":
 self.__askForkTo()
-def __sendJsonCommand(self, command, params):
+def __sendJsonCommand(self, command, params, debuggerId="", sock=None):
 """
 Private method to send a single command to the client.
 @param command command name to be sent
 @type str
 @param params dictionary of named parameters for the command
 @type dict
+@param debuggerId id of the debug client to send the command to
+@type str
+@param sock reference to the socket object to be used (only used if
+debuggerId is not given)
+@type QTcpSocket
 """
 import json
 commandDict = {
 "jsonrpc": "2.0",
 "method": command,
 "params": params,
 }
 cmd = json.dumps(commandDict) + '\n'
-if self.qsock is not None:
-self.__writeJsonCommandToSocket(cmd)
+if debuggerId and debuggerId in self.__connections:
+sock = self.__connections[debuggerId]
+elif sock is None and self.qsock is not None:
+sock = self.qsock
+if sock is not None:
+self.__writeJsonCommandToSocket(cmd, sock)
 else:
 self.queue.append(cmd)
-def __writeJsonCommandToSocket(self, cmd):
+def __writeJsonCommandToSocket(self, cmd, sock):
 """
 Private method to write a JSON command to the socket.
 @param cmd JSON command to be sent
 @type str
+@param sock reference to the socket to write to
+@type QTcpSocket
 """
 data = cmd.encode('utf8', 'backslashreplace')
 length = "{0:09d}".format(len(data))
-self.qsock.write(length.encode() + data)
+sock.write(length.encode() + data)
-self.qsock.flush()
+sock.flush()
 def createDebuggerInterfacePython2(debugServer, passive):
 """
 Module function to create a debugger interface instance.

Mercurial Repositories > eric / file comparison

comparison: eric6/Debugger/DebuggerInterfacePython.py

eric6/Debugger/DebuggerInterfacePython.py