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

-:d80184d38152
+:08e853c0c77b
 Module implementing the eric remote server.
 """
 import io
 import json
-import select
+import selectors
 import socket
 import struct
 import sys
 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
 class EricServer:
 """
 Class implementing the eric remote server.
 #     handler(request:str, params:dict, reqestUuid:str) -> None
 self.__registerInternalHandlers()
 self.__connection = None
+self.__selector = selectors.DefaultSelector()
+# create and register the 'Debugger' request handler
+self.__debuggerRequestHandler = EricServerDebuggerRequestHandler(self)
+self.registerRequestHandler(
+EricRequestCategory.Debugger,
+self.__debuggerRequestHandler.handleRequest,
+)
+# create and register the 'File System' request handler
+self.__fileSystemRequestHandler = EricServerFileSystemRequestHandler(self)
+self.registerRequestHandler(
+EricRequestCategory.FileSystem,
+self.__fileSystemRequestHandler.handleRequest,
+)
+# TODO: 'Project' handler not implemented yet
+# TODO: implement an 'EditorConfig' handler (?)
 address = ("", port)
 if socket.has_dualstack_ipv6() and useIPv6:
 self.__socket = socket.create_server(
 address, family=socket.AF_INET6, dualstack_ipv6=True
 )
 else:
-self.__socket = socket.create_server(
+self.__socket = socket.create_server(address, family=socket.AF_INET)
-address, family=socket.AF_INET
-)
+def getSelector(self):
+"""
+Public method to get a reference to the selector object.
+"""
+return self.__selector
 #######################################################################
 ## Methods for receiving requests and sending the results.
 #######################################################################
 @type dict
 @param reqestUuid UUID of the associated request as sent by the eric IDE
 (defaults to "", i.e. no UUID received)
 @type str
 """
-commandDict = {
+if self.__connection is not None:
-"jsonrpc": "2.0",
+commandDict = {
-"category": category,
+"jsonrpc": "2.0",
-"reply": reply,
+"category": category,
-"params": params,
+"reply": reply,
-"uuid": reqestUuid,
+"params": params,
-}
+"uuid": reqestUuid,
-data = json.dumps(commandDict).encode("utf8", "backslashreplace")
+}
+self.sendJsonCommand(commandDict, self.__connection)
+def sendJsonCommand(self, jsonCommand, sock):
+"""
+Public method to send a JSON encoded command/response via a given socket.
+@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
+"""
+if isinstance(jsonCommand, dict):
+jsonCommand = json.dumps(jsonCommand)
+data = jsonCommand.encode("utf8", "backslashreplace")
 header = struct.pack(b"!II", len(data), zlib.adler32(data) & 0xFFFFFFFF)
-self.__connection.sendall(header)
+sock.sendall(header)
-self.__connection.sendall(data)
+sock.sendall(data)
-def __receiveBytes(self, length):
+def __receiveBytes(self, length, sock):
 """
 Private method to receive the given length of bytes.
 @param length bytes to receive
 @type int
+@param sock reference to the socket to receive the data from
+@type socket.socket
 @return received bytes or None if connection closed
 @rtype bytes
 """
 data = bytearray()
 while len(data) < length:
-newData = self.__connection.recv(length - len(data))
+try:
-if not newData:
+newData = sock.recv(length - len(data))
-return None
+if not newData:
+print(str(newData))
-data += newData
+return None
+data += newData
+except OSError as err:
+if err.errno != 11:
+data = None  # in case some data was received already
+break
 return data
-def __receiveJson(self):
+def receiveJsonCommand(self, sock):
 """
-Private method to receive a JSON encoded command and data from the
+Public method to receive a JSON encoded command and data.
-server.
+@param sock reference to the socket to receive the data from
-@return tuple containing the received service category, the command,
+@type socket.socket
-a dictionary containing the associated data and the UUID of the
+@return dictionary containing the JSON command data or None to signal
-request
+an issue while receiving data
-@rtype tuple of (int, str, dict, str)
+@rtype dict
 """
-# step 1: receive the data
+if self.isSocketClosed(sock):
-header = self.__receiveBytes(struct.calcsize(b"!II"))
+return None
+header = self.__receiveBytes(struct.calcsize(b"!II"), sock)
 if not header:
-return EricRequestCategory.Error, None, None, None
+return {}
 length, datahash = struct.unpack(b"!II", header)
 length = int(length)
-data = self.__receiveBytes(length)
+data = self.__receiveBytes(length, sock)
+if data is None:
+return None
 if not data or zlib.adler32(data) & 0xFFFFFFFF != datahash:
 self.sendJson(
 category=EricRequestCategory.Error,
-reply="ClientChecksumException",
+reply="EricServerChecksumException",
 params={
 "ExceptionType": "ProtocolChecksumError",
 "ExceptionValue": "The checksum of the data does not match.",
 "ProtocolData": data.decode("utf8", "backslashreplace"),
 },
 )
-return EricRequestCategory.Error, None, None, None
+return {}
-# step 2: decode and convert the data
+jsonStr = data.decode("utf8", "backslashreplace")
-jsonString = data.decode("utf8", "backslashreplace")
 try:
-requestDict = json.loads(jsonString.strip())
+return json.loads(jsonStr.strip())
 except (TypeError, ValueError) as err:
 self.sendJson(
 category=EricRequestCategory.Error,
-reply="ClientException",
+reply="EricServerException",
 params={
 "ExceptionType": "ProtocolError",
 "ExceptionValue": str(err),
-"ProtocolData": jsonString.strip(),
+"ProtocolData": jsonStr.strip(),
 },
 )
+return {}
+def __receiveJson(self):
+"""
+Private method to receive a JSON encoded command and data from the
+server.
+@return tuple containing the received service category, the command,
+a dictionary containing the associated data and the UUID of the
+request
+@rtype tuple of (int, str, dict, str)
+"""
+requestDict = self.receiveJsonCommand(self.__connection)
+if not requestDict:
 return EricRequestCategory.Error, None, None, None
 category = requestDict["category"]
 request = requestDict["request"]
 params = requestDict["params"]
 reqestUuid = requestDict["uuid"]
 return category, request, params, reqestUuid
+def isSocketClosed(self, sock):
+"""
+Public method to check, if a given socket is closed.
+@param sock reference to the socket to be checked
+@type socket.socket
+@return flag indicating a closed state
+@rtype bool
+"""
+try:
+# this will try to read bytes without removing them from buffer (peek only)
+data = sock.recv(16, socket.MSG_PEEK)
+if len(data) == 0:
+return True
+except BlockingIOError:
+return False  # socket is open and reading from it would block
+except ConnectionError:
+return True  # socket was closed for some other reason
+except Exception:
+return False
+return False
 #######################################################################
 ## Methods for the server main loop.
 #######################################################################
 def __shutdown(self):
 """
 Private method to shut down the server.
 """
+self.__closeIdeConnection()
+print("Stop listening for 'eric-ide' connections.")
 self.__socket.shutdown(socket.SHUT_RDWR)
 self.__socket.close()
+self.__selector.close()
+def __acceptIdeConnection(self, sock):
+"""
+Private method to accept the connection on the listening IDE server socket.
+@param sock reference to the listening socket
+@type socket.socket
+"""
+self.__connection, address = sock.accept()  # Should be ready to read
+print(f"'eric-ide' connection from {address[0]},  port {address[1]}")
+self.__connection.setblocking(False)
+data = types.SimpleNamespace(
+name="eric-ide", address=address, handler=self.__serviceIdeConnection
+)
+events = selectors.EVENT_READ
+self.__selector.register(self.__connection, events, data=data)
+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)
+self.__connection.close()
+self.__connection = None
+self.__debuggerRequestHandler.shutdownClients()
+def __serviceIdeConnection(self, key):
+"""
+Private method to service the eric-ide connection.
+@param key reference to the SelectorKey object associated with the connection
+to be serviced
+@type selectors.SelectorKey
+"""
+if key.data.name == "eric-ide":
+category, request, params, reqestUuid = self.__receiveJson()
+if category == EricRequestCategory.Error or request is None:
+self.__closeIdeConnection()
+return
+if category == EricRequestCategory.Server:
+if request.lower() == "shutdown":
+self.__shouldStop = True
+return
+self.__handleRequest(category, request, params, reqestUuid)
 def run(self):
 """
 Public method implementing the remote server main loop.
 </ul>
 @return flag indicating a clean shutdown
 @rtype bool
 """
-shutdown = False
 cleanExit = True
+self.__shouldStop = False
 # listen on the server socket for new connections
 self.__socket.listen(1)
+self.__socket.setblocking(False)
+print(f"Listening for 'eric-ide' connections on {self.__socket.getsockname()}")
+data = types.SimpleNamespace(
+name="server", acceptHandler=self.__acceptIdeConnection
+)
+self.__selector.register(self.__socket, selectors.EVENT_READ, data=data)
+self.__debuggerRequestHandler.initServerSocket()
 while True:
 try:
-# accept the next pending connection
+events = self.__selector.select(timeout=None)
-print("Waiting for connection...")
+for key, mask in events:
-self.__connection, address = self.__socket.accept()
+if key.data.name == "server":
-print(f"Connection from {address[0]},  port {address[1]}")
+# it is an event for a server socket
+key.data.acceptHandler(key.fileobj)
-selectErrors = 0
+else:
-while selectErrors <= 10:  # selected arbitrarily
+key.data.handler(key)
-try:
-rrdy, wrdy, xrdy = select.select([self.__connection], [], [])
-# Just waiting for self.__connection. Therefore no check
-# needed.
-category, request, params, reqestUuid = self.__receiveJson()
-if category == EricRequestCategory.Error or request is None:
-selectErrors += 1
-elif category == EricRequestCategory.Server:
-if request.lower() == "exit":
-break
-elif request.lower() == "shutdown":
-shutdown = True
-break
-else:
-self.__handleRequest(
-category, request, params, reqestUuid
-)
-else:
-self.__handleRequest(category, request, params, reqestUuid)
-# reset select errors
-selectErrors = 0
-except (select.error, socket.error):
-selectErrors += 1
 except KeyboardInterrupt:
 # intercept user pressing Ctrl+C
-shutdown = True
+self.__shouldStop = True
 except Exception:
 exctype, excval, exctb = sys.exc_info()
 tbinfofile = io.StringIO()
 traceback.print_tb(exctb, None, tbinfofile)
 tbinfofile.seek(0)
 tbinfo = tbinfofile.read()
 print(f"{str(exctype)} / {str(excval)} / {tbinfo}")
-shutdown = True
+self.__shouldStop = True
 cleanExit = False
-if self.__connection is not None:
+if self.__shouldStop:
-self.__connection.shutdown(socket.SHUT_RDWR)
-self.__connection.close()
-self.__connection = None
-if shutdown:
 # exit the outer loop and shut down the server
 self.__shutdown()
 break
 return cleanExit
 @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:
-if category < EricRequestCategory.UserCategory:
-# it is an internally supported category
-if category == EricRequestCategory.FileSystem:
-from .EricServerFileSystemRequestHandler import (
-EricServerFileSystemRequestHandler,
-)
-handler = EricServerFileSystemRequestHandler(self).handleRequest
-elif category == EricRequestCategory.Project:
-# TODO: 'Project' handler not implemented yet
-handler = None
-elif category == EricRequestCategory.Debugger:
-# TODO: 'Debugger' handler not implemented yet
-handler = None
-# TODO: implement an 'EditorConfig' handler (?)
-else:
-# That internal category does not exist.
-handler = None
-self.registerRequestHandler(category, handler)
-else:
-handler = None
-if handler is not None:
-handler(request=request, params=params, reqestUuid=reqestUuid)
-else:
 self.sendJson(
 category=EricRequestCategory.Error,
 reply="UnsupportedServiceCategory",
 params={"Category": category},
 )

Mercurial Repositories > eric / file comparison

comparison: src/eric7/RemoteServer/EricServer.py

src/eric7/RemoteServer/EricServer.py