eric: comparison Utilities/BackgroundService.py

-:c0f78e9d0971
+:1fb284abe46e
 # -*- coding: utf-8 -*-
 # Copyright (c) 2013 - 2014 Detlev Offenbach <detlev@die-offenbachs.de>
 #
+# pylint: disable=C0103
 """
 Module implementing a background service for the various checkers and other
 python interpreter dependent functions.
 """
 import sys
 import threading
 from zlib import adler32
 from PyQt4.QtCore import QProcess, pyqtSignal
-from PyQt4.QtGui import QApplication
 from PyQt4.QtNetwork import QTcpServer, QHostAddress
-from E5Gui.E5Application import e5App
 import Preferences
 import Utilities
 from Utilities.BackgroundClient import BackgroundClient
 class BackgroundService(QTcpServer):
 """
 Class implementing the main part of the background service.
 """
-syntaxChecked = pyqtSignal(str, bool, str, int, int, str, str, list)
+serviceNotAvailable = pyqtSignal(str, str, int, str)
-#styleChecked = pyqtSignal(TBD)
-#indentChecked = pyqtSignal(TBD)
 def __init__(self):
 """
 Constructor of the BackgroundService class.
 """
 self.processes = [None, None]
 self.connections = [None, None]
+self.isWorking = False
+self.__queue = []
+self.services = {}
 super(BackgroundService, self).__init__()
 networkInterface = Preferences.getDebugger("NetworkInterface")
 if networkInterface == "all" or '.' in networkInterface:
 process = self.__startInternalClient(port)
 else:
 process = self.__startExternalClient(interpreter, port)
 self.processes[pyIdx] = process
-def on_newConnection(self):
-"""
-Slot for new incomming connections from the clients.
-"""
-connection = self.nextPendingConnection()
-if not connection.waitForReadyRead(1000):
-return
-ch = 0 if connection.read(1) == b'2' else 1
-self.connections[ch] = connection
-connection.readyRead.connect(
-lambda x=ch: self.__receive(x))
-def shutdown(self):
-"""
-Cleanup the connections and processes when Eric is shuting down.
-"""
-for connection in self.connections:
-if connection:
-connection.close()
-for process in self.processes:
-if isinstance(process, QProcess):
-process.close()
-process = None
-elif isinstance(process, threading.Thread):
-process.join(0.1)
-process = None
 def __startExternalClient(self, interpreter, port):
 """
 Private method to start the background client as external process.
 @param interpreter path and name of the executable to start (string)
 Private method to start the background client as internal thread.
 @param port socket port to which the interpreter should connect (int)
 @return the thread object (Thread) or None
 """
-self.backgroundClient = BackgroundClient(
+backgroundClient = BackgroundClient(
 self.hostAddress, port)
-thread = threading.Thread(target=self.backgroundClient.run)
+thread = threading.Thread(target=backgroundClient.run)
 thread.start()
 return thread
-# TODO: Implement a queued processing of incomming events. Dublicate file
+def __processQueue(self):
-# checks should update an older request to avoid overrun or starving of
+"""
-# the check.
+Private method to take the next service request and send it to the
-def __send(self, fx, fn, data, isPy3):
+client.
+"""
+if self.__queue and self.isWorking is False:
+self.isWorking = True
+fx, fn, pyVer, data = self.__queue.pop(0)
+self.__send(fx, fn, pyVer, data)
+def __send(self, fx, fn, pyVer, data):
 """
 Private method to send a job request to one of the clients.
 @param fx remote function name to execute (str)
 @param fn filename for identification (str)
+@param pyVer version for the required interpreter (int)
 @param data function argument(s) (any basic datatype)
-@param isPy3 flag for the required interpreter (boolean)
 """
 packedData = json.dumps([fx, fn, data])
 if sys.version_info[0] == 3:
 packedData = bytes(packedData, 'utf-8')
-connection = self.connections[int(isPy3)]
+connection = self.connections[pyVer - 2]
 if connection is None:
-self.__postResult(
+if fx != 'INIT':
-fx, fn, [
+self.serviceNotAvailable.emit(
-True, fn, 0, 0, '',
+fx, fn, pyVer, self.trUtf8(
-'No connection to Python{0} interpreter. '
+'Python{0} interpreter not configured.').format(pyVer))
-'Check your debugger settings.'.format(int(isPy3) + 2),
+# Reset flag and continue processing queue
-[]])
+self.isWorking = False
+self.__processQueue()
 else:
 header = struct.pack(
 b'!II', len(packedData), adler32(packedData) & 0xffffffff)
 connection.write(header)
 connection.write(packedData)
 assert adler32(packedData) & 0xffffffff == datahash, 'Hashes not equal'
 if sys.version_info[0] == 3:
 packedData = packedData.decode('utf-8')
 # "check" if is's a tuple of 3 values
-try:
+fx, fn, data = json.loads(packedData)
-fx, fn, data = json.loads(packedData)
+self.__postResult(fx, fn, data)
-self.__postResult(fx, fn, data)
-except:
-pass
 def __postResult(self, fx, fn, data):
 """
 Private method to emit the correspondig signal for the returned
 function.
 @param fx remote function name to execute (str)
 @param fn filename for identification (str)
 @param data function argument(s) (any basic datatype)
 """
-if fx == 'syntax':
+if fx == 'INIT':
-self.syntaxChecked.emit(fn, *data)
-elif fx == 'style':
-pass
-elif fx == 'indent':
 pass
 elif fx == 'exception':
 # Call sys.excepthook(type, value, traceback) to emulate the
 # exception which was caught on the client
-sys.excepthook(*data)
+#sys.excepthook(*data)
+print(data)
-#QApplication.translate(packedData)
+else:
+callback = self.services.get(fx)
-# ggf. nach Utilities verschieben
+if callback:
-def determinePythonVersion(self, filename, source):
+callback[2](fn, *data)
-"""
-Determine the python version of a given file.
+self.isWorking = False
+self.__processQueue()
-@param filename name of the file with extension (str)
-@param source of the file (str)
+def enqueueRequest(self, fx, fn, pyVer, data):
-@return flag if file is Python2 or Python3 (boolean)
+"""
-"""
+Implement a queued processing of incomming events.
-flags = Utilities.extractFlags(source)
-ext = os.path.splitext(filename)[1]
+Dublicate file checks update an older request to avoid overrun or
-project = e5App().getObject('Project')
+starving of the check.
-if "FileType" in flags:
+@param fx function name of the service (str)
-isPy3 = flags["FileType"] not in ["Python", "Python2"]
+@param fn filename for identification (str)
-elif (Preferences.getProject("DeterminePyFromProject") and
+@param pyVer version for the required interpreter (int)
-project.isOpen() and
+@param data function argument(s) (any basic datatype)
-project.isProjectFile(filename)):
+"""
-isPy3 = project.getProjectLanguage() == "Python3"
+args = [fx, fn, pyVer, data]
-else:
+if fx == 'INIT':
-isPy3 = ext in Preferences.getPython("PythonExtensions")
+self.__queue.insert(0, args)
-return isPy3
+else:
+for pendingArg in self.__queue:
-def syntaxCheck(self, filename, source="", checkFlakes=True,
+if pendingArg[:3] == args[:3]:
-ignoreStarImportWarnings=False, isPy3=None):
+pendingArg[3] = args[3]
-"""
+break
-Function to compile one Python source file to Python bytecode
+else:
-and to perform a pyflakes check.
+self.__queue.append(args)
+self.__processQueue()
-@param filename source filename (string)
-@keyparam source string containing the code to check (string)
+def serviceConnect(
-@keyparam checkFlakes flag indicating to do a pyflakes check (boolean)
+self, fx, modulepath, module, callback, onErrorCallback=None):
-@keyparam ignoreStarImportWarnings flag indicating to
+"""
-ignore 'star import' warnings (boolean)
+Announce a new service to the background service/ client.
-@keyparam isPy3 flag sets the interpreter to use or None for autodetect
-corresponding interpreter (boolean or None)
+@param fx function name of the service (str)
-"""
+@param modulepath full path to the module (str)
-if isPy3 is None:
+@param module name to import (str)
-isPy3 = self.determinePythonVersion(filename, source)
+@param callback function on service response (function)
+@param onErrorCallback function if client isn't available (function)
-data = [source, checkFlakes, ignoreStarImportWarnings]
+"""
-self.__send('syntax', filename, data, isPy3)
+self.services[fx] = modulepath, module, callback, onErrorCallback
+self.enqueueRequest('INIT', fx, 0, [modulepath, module])
+self.enqueueRequest('INIT', fx, 1, [modulepath, module])
+if onErrorCallback:
+self.serviceNotAvailable.connect(onErrorCallback)
+def serviceDisconnect(self, fx):
+"""
+Remove the service from the service list.
+@param fx function name of the service
+"""
+self.services.pop(fx, None)
+def on_newConnection(self):
+"""
+Slot for new incomming connections from the clients.
+"""
+connection = self.nextPendingConnection()
+if not connection.waitForReadyRead(1000):
+return
+ch = 0 if connection.read(1) == b'2' else 1
+self.connections[ch] = connection
+connection.readyRead.connect(
+lambda x=ch: self.__receive(x))
+for fx, args in self.services.items():
+self.enqueueRequest('INIT', fx, ch, args[:2])
+def shutdown(self):
+"""
+Cleanup the connections and processes when Eric is shuting down.
+"""
+for connection in self.connections:
+if connection:
+connection.close()
+for process in self.processes:
+if isinstance(process, QProcess):
+process.close()
+process = None
+elif isinstance(process, threading.Thread):
+process.join(0.1)
+process = None

Mercurial Repositories > eric / file comparison

comparison: Utilities/BackgroundService.py

Utilities/BackgroundService.py