eric: comparison src/eric7/RemoteServerInterface/EricServerInterface.py

-:28b14d2df6a1
+:be23a662d709
 """
 Module implementing the interface to the eric remote server.
 """
+import collections
 import json
 import struct
 import uuid
 import zlib
 self.__serviceInterfaces = {}
 # no specific service interfaces have been created yet
 self.__connection = None
 self.__callbacks = {}  # callback references indexed by UUID
+self.__messageQueue = collections.deque()
 self.connectionStateChanged.connect(self.__connectionStateChanged)
 def getServiceInterface(self, name):
 """
 @param name service name
 @type str
 @return reference to the service interface
 @rtype QObject
+@exception ValueError raised to indicate an unsupported server interface
+was requested
 """
 lname = name.lower()
 try:
 return self.__serviceInterfaces[lname]
 except KeyError:
-# instantiate the service interface
+if lname not in ("debugger", "filesystem", "project"):
-if lname == "filesystem":
+raise ValueError(f"no such service supported ({name})")
-from .EricServerFileSystemInterface import EricServerFileSystemInterface
-self.__serviceInterfaces[lname] = EricServerFileSystemInterface(self)
-elif lname == "debugger":
-from .EricServerDebuggerInterface import EricServerDebuggerInterface
-self.__serviceInterfaces[lname] = EricServerDebuggerInterface(self)
-elif lname == "project":
-# TODO: 'Project Interface' not implemented yet
-pass
 else:
-raise ValueError(f"no such service supported ({name})")
+# instantiate the service interface
+if lname == "filesystem":
+from .EricServerFileSystemInterface import (  # noqa: I101
+EricServerFileSystemInterface
+)
+self.__serviceInterfaces[lname] = (
+EricServerFileSystemInterface(self)
+)
+elif lname == "debugger":
+from .EricServerDebuggerInterface import EricServerDebuggerInterface
+# noqa: I101
+self.__serviceInterfaces[lname] = EricServerDebuggerInterface(self)
+elif lname == "project":
+# TODO: 'Project Interface' not implemented yet
+pass
 return self.__serviceInterfaces[lname]
 #######################################################################
 ## Methods for handling the server connection.
 #######################################################################
 def connectToServer(self, host, port=None, timeout=None):
 """
-Public method to connect to the given host and port
+Public method to connect to the given host and port.
 @param host host name or IP address of the eric remote server
 @type str
 @param port port number to connect to (defaults to None)
 @type int (optional)
 @param timeout timeout im seconds for the connection attempt
 (defaults to None)
 @type int (optional)
+@return flag indicating success
+@rtype bool
 """
 if not bool(port):  # None or 0
 # use default port
 port = 42024
 if not bool(timeout):  # None or 0
 # use configured default timeout
 timeout = Preferences.getEricServer("ConnectionTimeout")
-timeout = timeout * 1000  # convert to milliseconds
+timeout *= 1000  # convert to milliseconds
 if self.__connection is not None:
 self.disconnectFromServer()
 self.__connection = QTcpSocket(self)
 @pyqtSlot()
 def __receiveJson(self):
 """
 Private slot handling received data from the eric remote server.
-@param idString id of the connection
-@type str
 """
 while self.__connection and self.__connection.bytesAvailable():
 header = self.__connection.read(struct.calcsize(b"!II"))
 length, datahash = struct.unpack(b"!II", header)
 data = bytearray()
 while len(data) < length:
 maxSize = length - len(data)
 if self.__connection.bytesAvailable() < maxSize:
 self.__connection.waitForReadyRead(50)
-data += self.__connection.read(maxSize)
+newData = self.__connection.read(maxSize)
+if newData:
+data += newData
 if zlib.adler32(data) & 0xFFFFFFFF != datahash:
 # corrupted data -> discard and continue
 continue
 jsonString = data.decode("utf-8", "backslashreplace")
-# - print("Remote Server Interface: {0}".format(jsonString))
+# - print("Remote Server Interface Receive: {0}".format(jsonString))
 # - this is for debugging only
 try:
 serverDataDict = json.loads(jsonString.strip())
 except (TypeError, ValueError) as err:
 EricMessageBox.Ok,
 )
 return
 reqUuid = serverDataDict["uuid"]
-try:
+if reqUuid:
+# It is a response to a synchronous request -> handle the call back
+# immediately.
 self.__callbacks[reqUuid](
 serverDataDict["reply"], serverDataDict["params"]
 )
 del self.__callbacks[reqUuid]
+else:
+self.__messageQueue.append(serverDataDict)
+while self.__messageQueue:
+serverDataDict = self.__messageQueue.popleft()  # get the first message
+try:
+self.__categorySignalMapping[serverDataDict["category"]].emit(
+serverDataDict["reply"], serverDataDict["params"]
+)
 except KeyError:
-# no callback for this UUID exists, send a signal
+if serverDataDict["category"] == EricRequestCategory.Error:
-try:
+# handle server errors in here
-self.__categorySignalMapping[serverDataDict["category"]].emit(
+self.__handleServerError(
 serverDataDict["reply"], serverDataDict["params"]
 )
-except KeyError:
+else:
-if serverDataDict["category"] == EricRequestCategory.Error:
+self.remoteReply.emit(
-# handle server errors in here
+serverDataDict["category"],
-self.__handleServerError(
+serverDataDict["reply"],
-serverDataDict["reply"], serverDataDict["params"]
+serverDataDict["params"],
 )
-else:
-self.remoteReply.emit(
-serverDataDict["category"],
-serverDataDict["reply"],
-serverDataDict["params"],
-)
 def sendJson(self, category, request, params, callback=None, flush=False):
 """
 Public method to send a single command to a client.
 @type function (optional)
 @param flush flag indicating to flush the data to the socket
 (defaults to False)
 @type bool (optional)
 """
-reqUuid = str(uuid.uuid4())
 if callback:
+reqUuid = str(uuid.uuid4())
 self.__callbacks[reqUuid] = callback
+else:
+reqUuid = ""
 serviceDict = {
 "jsonrpc": "2.0",
 "category": category,
 "request": request,
 "params": params,
 "uuid": reqUuid,
 }
 jsonString = json.dumps(serviceDict) + "\n"
+# - print("Remote Server Interface Send: {0}".format(jsonString))
+# - this is for debugging only
 if self.__connection is not None:
 data = jsonString.encode("utf8", "backslashreplace")
 header = struct.pack(b"!II", len(data), zlib.adler32(data) & 0xFFFFFFFF)
 self.__connection.write(header)
 self.__connection.write(data)
 @type str
 @param params dictionary containing the reply data
 @type dict
 @exception ValueError raised in case of an unsupported reply
 """
-if reply == "Versions":
+if reply != "Versions":
+raise ValueError(f"unsupported reply received ({reply})")
+else:
 versionText = self.tr("""<h2>Server Version Numbers</h2><table>""")
 # Python version
 versionText += (
 """<tr><td><b>Python</b></td><td>{0}, {1}</td></tr>"""
 None,
 self.tr("eric-ide Server Versions"),
 versionText,
 )
-else:
-raise ValueError(f"unsupported reply received ({reply})")
 #######################################################################
 ## Reply handler methods
 #######################################################################
 def __handleServerError(self, reply, params):
 """
-Public method handling server error replies.
+Private method handling server error replies.
 @param reply name of the error reply
 @type str
 @param params dictionary containing the specific reply data
 @type dict
 Public slot to initialize the eric-ide server menu.
 @return the menu generated
 @rtype QMenu
 """
-self.__serverProfilesMenu = QMenu(self.tr("Connect to"))##, self.__ui)
+self.__serverProfilesMenu = QMenu(self.tr("Connect to"))
 self.__serverProfilesMenu.aboutToShow.connect(self.__showServerProfilesMenu)
 self.__serverProfilesMenu.triggered.connect(self.__serverProfileTriggered)
 menu = QMenu(self.tr("eric-ide Server"), self.__ui)
 menu.setTearOffEnabled(True)
 self.__menus = {
 "Main": menu,
 ##"Recent": self.recentMenu,
 }
 return menu
 def initToolbar(self, toolbarManager):
 """
 Public slot to initialize the eric-ide server toolbar.

Mercurial Repositories > eric / file comparison

comparison: src/eric7/RemoteServerInterface/EricServerInterface.py

src/eric7/RemoteServerInterface/EricServerInterface.py