eric: comparison src/eric7/RemoteServer/EricServer.py

-:28b14d2df6a1
+:be23a662d709
 import traceback
 import types
 import zlib
 from eric7.UI.Info import Version
-# TODO: remove dependency on 'eric7.UI.Info'
 from .EricRequestCategory import EricRequestCategory
 from .EricServerDebuggerRequestHandler import EricServerDebuggerRequestHandler
 from .EricServerFileSystemRequestHandler import EricServerFileSystemRequestHandler
+# TODO: remove dependency on 'eric7.UI.Info'
 class EricServer:
 """
 Class implementing the eric remote server.
 self.__socket = socket.create_server(address, family=socket.AF_INET)
 def getSelector(self):
 """
 Public method to get a reference to the selector object.
+@return reference to the selector object
+@rtype selectors.BaseSelector
 """
 return self.__selector
 #######################################################################
 ## Methods for receiving requests and sending the results.
 @param jsonCommand dictionary containing the command data or a JSON encoded
 command string
 @type dict or str
 @param sock reference to the socket to send the data to
 @type socket.socket
+@return flag indicating a successful transmission
+@rtype bool
 """
 if isinstance(jsonCommand, dict):
 jsonCommand = json.dumps(jsonCommand)
+print("Eric Server Send:", jsonCommand)
 data = jsonCommand.encode("utf8", "backslashreplace")
 header = struct.pack(b"!II", len(data), zlib.adler32(data) & 0xFFFFFFFF)
-sock.sendall(header)
+try:
-sock.sendall(data)
+sock.sendall(header)
+sock.sendall(data)
+return True
+except BrokenPipeError:
+return False
 def __receiveBytes(self, length, sock):
 """
 Private method to receive the given length of bytes.
 },
 )
 return {}
 jsonStr = data.decode("utf8", "backslashreplace")
+print("Eric Server Receive:", jsonStr)
 try:
 return json.loads(jsonStr.strip())
 except (TypeError, ValueError) as err:
 self.sendJson(
 category=EricRequestCategory.Error,
 def __closeIdeConnection(self):
 """
 Private method to close the connection to an eric-ide.
 """
 if self.__connection is not None:
-print(
-f"Closing 'eric-ide' connection to {self.__connection.getpeername()}."
-)
 self.__selector.unregister(self.__connection)
-self.__connection.shutdown(socket.SHUT_RDWR)
+try:
-self.__connection.close()
+print(
+f"Closing 'eric-ide' connection to"
+f" {self.__connection.getpeername()}."
+)
+self.__connection.shutdown(socket.SHUT_RDWR)
+self.__connection.close()
+except OSError:
+print("'eric-ide' connection gone.")
 self.__connection = None
 self.__debuggerRequestHandler.shutdownClients()
 def __serviceIdeConnection(self, key):
 category, request, params, reqestUuid = self.__receiveJson()
 if category == EricRequestCategory.Error or request is None:
 self.__closeIdeConnection()
 return
-if category == EricRequestCategory.Server:
+if category == EricRequestCategory.Server and request.lower() == "shutdown":
-if request.lower() == "shutdown":
+self.__shouldStop = True
-self.__shouldStop = True
+return
-return
 self.__handleRequest(category, request, params, reqestUuid)
 def run(self):
 """
 self.__debuggerRequestHandler.initServerSocket()
 while True:
 try:
 events = self.__selector.select(timeout=None)
-for key, mask in events:
+for key, _mask in events:
 if key.data.name == "server":
 # it is an event for a server socket
 key.data.acceptHandler(key.fileobj)
 else:
 key.data.handler(key)
 """
 Private method to register request handler categories of this class.
 """
 self.registerRequestHandler(EricRequestCategory.Echo, self.__handleEchoRequest)
 self.registerRequestHandler(
-EricRequestCategory.Server,  self.__handleServerRequest
+EricRequestCategory.Server, self.__handleServerRequest
 )
 self.registerRequestHandler(EricRequestCategory.Error, None)
 # Register a None handler to indicate we are not expecting a request of the
 # 'Error' category.
 @type str
 @param params request parameters
 @type dict
 @param reqestUuid UUID of the associated request as sent by the eric IDE
 @type str
-@exception ValueError raised to indicate an invalid or unsupported request
-handler catehory
 """
 try:
 handler = self.__requestCategoryHandlerRegistry[category]
 handler(request=request, params=params, reqestUuid=reqestUuid)
 except KeyError:
 category=EricRequestCategory.Error,
 reply="UnsupportedServiceCategory",
 params={"Category": category},
 )
-def __handleEchoRequest(self, request, params, reqestUuid):
+def __handleEchoRequest(self, request, params, reqestUuid):  # noqa: U100
 """
 Private method to handle an 'Echo' request.
 @param request request name
 @type str
 reply="Echo",
 params=params,
 reqestUuid=reqestUuid,
 )
-def __handleServerRequest(self, request, params, reqestUuid):
+def __handleServerRequest(self, request, params, reqestUuid):  # noqa: U100
 """
 Private method to handle a 'Server' request.
 @param request request name
 @type str

Mercurial Repositories > eric / file comparison

comparison: src/eric7/RemoteServer/EricServer.py

src/eric7/RemoteServer/EricServer.py