Slave.py

Go to the documentation of this file.

# Already ported to Python 3
# **InsertLicense** code author="Gereon A. Frey"


# -- system imports ----------------------------------------------------------------------------{{{-
import os
import re
import traceback

import sys
if sys.version_info.major >= 3:
  unicode = str

import xml.etree.cElementTree as etree
# ----------------------------------------------------------------------------------------------}}}-

# -- local imports -----------------------------------------------------------------------------{{{-
import mevis
import PackageSorter

from . import IPC
from . import Config
from . import Utils
from .LogHandler             import LogHandler
from TestSupport.TestHelper import TestHelper

from .TestCaseGeneric        import GenericTestCase
from .TestCaseFunctional     import FunctionalTestCase
import TestSupport

from . import CodeCoverage
from .CodeTestSupport import getCodeTest, getCodeTestsByPackage, CodeTestTestCase

# ----------------------------------------------------------------------------------------------}}}-
class TestCaseRemoteListener():

  def __init__(self, com):
    self.stopped = False
    self.__com = com

  def startTestCaseFunction(self, testType, testCase, testFunction):
    resultNode = etree.Element("Progress")
    resultNode.set("testType", testType)
    resultNode.set("testCase", testCase)
    resultNode.set("testFunction", testFunction)
    if not self.__com.send(etree.tostring(resultNode), 5):
      mevis.MLAB.logError("Couldn't send progress")
      raise TestSupport.TestHelper.CancelTestException
    # receive the result, if it is "0", we are supposed to stop,
    # otherwise we can continue
    result = self.__com.recv(5)
    if result=="0":
      raise TestSupport.TestHelper.CancelTestException

  def endTestCaseFunction(self, status, duration):
    resultNode = etree.Element("Status")
    resultNode.set("status", str(status))
    if not self.__com.send(etree.tostring(resultNode), 5):
      mevis.MLAB.logError("Couldn't send status")
      raise TestSupport.TestHelper.CancelTestException

# -- class Slave -------------------------------------------------------------------------------{{{-

class Slave (object):
  # -- member variables ------------------------------------------------------------------------{{{-
  
  __ctx                    = None
  
  __com                    = None

  
  __testCase               = None

  
  __running                = None

  
  __testCfg                = None
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __init__ ----------------------------------------------------------------------------{{{-
  
  def __init__ (self, cfgFile, context, offline=False):
    self.__ctx = context
    self.__com = IPC.ComSlave() if not offline else None

    self.__testCaseListener = None
    self.__agendaTestCase = None
    self.__isInsideTestCaseManager = False

    # The current configuration
    self._config = Config.Configuration(cfgFile)

    # Create result directory if not available.
    resultDir = self._config.getResultDir()
    if not os.path.isdir(resultDir):
      os.makedirs(resultDir)

    # Set new logfile to use. This is required as there could be multiple
    # MeVisLab instances writing to the same logfile what would make crash
    # handling impossible.
    self.__logfile = self._config.getSlaveLogFilePath()

    # Load test cases if not done already.
    if not mevis.MLABTestCaseDatabase.areTestCasesLoaded():
      mevis.MLABTestCaseDatabase.loadTestCases()

    # Initialize the test helper singleton.
    TestHelper.getInstance(context=self.__ctx, resultDir=self._config.getResultDir())
  # --------------------------------------------------------------------------------------------}}}-
  
  def setIsInsideTestCaseManager(self, isInsideTestCaseManager):
    self.__isInsideTestCaseManager = isInsideTestCaseManager

  def setTestCaseListener(self, listener):
    self.__testCaseListener = listener

  # -- def loadTestCase ------------------------------------------------------------------------{{{-
  
  def loadTestCase (self, testCaseNode):
    testType = testCaseNode.get('type')
    moduleName = testCaseNode.get('module') if testType == "GenericTestCase" else None
    return self.__loadTestCase(testCaseNode.get('name'), testType, moduleName)
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __loadTestCase ----------------------------------------------------------------------{{{-
  
  def __loadTestCase (self, testCaseName, testCaseType, moduleName=None):
    # Create test case depending on the type.
    if testCaseType == 'GenericTestCase':
      testCase = GenericTestCase(testCaseName, moduleName)
    elif testCaseType == 'FunctionalTestCase':
      testCase = FunctionalTestCase(testCaseName)
    elif testCaseType == 'CodeTestTestCase':
      testCase = CodeTestTestCase(testCaseName)
    else:
      raise Exception('Unsupported test case type %s' % testCaseType)
    return testCase
  # --------------------------------------------------------------------------------------------}}}-

  # -- def setAgendaTestCase -------------------------------------------------------------------------{{{-
  
  def setAgendaTestCase (self, testCase):
    self.__agendaTestCase = testCase
  # --------------------------------------------------------------------------------------------}}}-

  # -- def getTestCase -------------------------------------------------------------------------{{{-
  
  def getTestCase ( self ):
    return self.__testCase
  # --------------------------------------------------------------------------------------------}}}-

  # -- def unloadTestCase -------------------------------------------------------------------------{{{-
  
  def unloadTestCase ( self ):
    self.__testCase = None
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __doTest ----------------------------------------------------------------------------{{{-
  

  def __doTest (self,
                testCaseNode,
                resultNode):
    
    try:
      maxErrorMessagesPerTestFunction = int(testCaseNode.get("maxErrorMessagesPerTestFunction"))
    except:
      maxErrorMessagesPerTestFunction = 10000
    try:
      maxInfoMessagesPerTestFunction = int(testCaseNode.get("maxInfoMessagesPerTestFunction"))
    except:
      maxInfoMessagesPerTestFunction = 10000
    
    # clear encoding cache for each test to prevent it from containing outdated encoding data
    TestSupport.Base.clearEncodingCache()

    #start coverage right in front of loading, since some code parts are only
    #traversed during the loading phase of a test case. Those
    #are mainly function definitions etc.
    try:
      pythonCoverage = CodeCoverage.PythonCoverage(config=self._config,
                                                   testCaseNode=testCaseNode)
    except CodeCoverage.CoverageException as e:
      pythonCoverage = None
      mevis.MLAB.logError(e)

    try:
      bullseyeCoverage = CodeCoverage.BullseyeCoverage(config=self._config,
                                                       testCaseNode=testCaseNode)
    except CodeCoverage.CoverageException as e:
      bullseyeCoverage = None
      mevis.MLAB.logError(e)

    self.__testCase =  self.loadTestCase(testCaseNode)

    # Run the test case only if it loaded correctly.
    if self.__testCase:
      # Do NOT run test, when status is TEST_STATUS_DO_NOT_TEST_MODULE. Only relevant for GenericTests
      if not testCaseNode.get("status") == Utils.TEST_STATUS_DO_NOT_TEST_MODULE:
        if pythonCoverage and pythonCoverage.isRunning():
          #store the target file in a subNode so the HTML creation process knows there
          #were coverage results for this test.
          resultNode.set('pythonCoverage', pythonCoverage.getCoverageBinaryFilePath())
  
        if bullseyeCoverage and bullseyeCoverage.isRunning():
          #store the target file in a subNode so the HTML creation process knows there
          #were coverage results for this test.
          resultNode.set('bullseyeCoverage', bullseyeCoverage.getCoverageBinaryFilePath())
  
        logHandler = LogHandler(self.__logfile)
        logHandler.setErrorLimit(maxErrorMessagesPerTestFunction)
        logHandler.setInfoLimit(maxInfoMessagesPerTestFunction)
        TestHelper.getInstance().setLogHandler(logHandler)
  
        mevis.MLAB.priv().connect("loggingMessage(const QString&)", logHandler.appendMessage)
        mevis.MLAB.priv().aboutToLogMessage.connect(logHandler.aboutToLogMessage)
        mevis.MLAB.priv().startLogCollect()
        self.__testCase.setTestCaseListener(self.__testCaseListener)
        self.__testCase.run(testCaseNode)
  
        mevis.MLAB.priv().stopLogCollect()
        mevis.MLAB.priv().disconnect("loggingMessage(const QString&)", logHandler.appendMessage)
        mevis.MLAB.priv().aboutToLogMessage.disconnect(logHandler.aboutToLogMessage)
  
        TestHelper.getInstance().unsetLogHandler()
        logHandler.close()
  
      resultNode.set('errorCode', 'Ok')
      # Append results to the resultNode.
      resultNode.append(testCaseNode)
    else:
      resultNode.set('errorCode', 'TestCaseError')
      etree.SubElement(resultNode, 'Error').text = "Unknown test case (%s)." % (testCaseNode.get('name'))

    if pythonCoverage:
      pythonCoverage.stop()

    if bullseyeCoverage:
      try:
        bullseyeCoverage.stop()
      except CodeCoverage.CoverageException as e:
        mevis.MLAB.logError(e)

  # --------------------------------------------------------------------------------------------}}}-

  # -- def __buildTestAgenda -------------------------------------------------------------------{{{-
  
  def __buildTestAgenda (self, testCfg, resultNode):
    
    def ___addPackageInfoNode( rootNode ):
      packageInfoNode = etree.SubElement( rootNode, 'PackageSortingInReport')
      packageInfoNode.set( 'PackagesByNumberOfDependencies', ",".join( PackageSorter.byNumberOfDependencies.packages ) )
      packageInfoNode.set( 'PackageGroupsByNumberOfDependencies', ",".join( PackageSorter.byNumberOfDependencies.packageGroups ) )
      
    testRunNode = etree.Element('TestRun')

    # An internal data structure with easier access than the XML structure.
    self.__testCfg = { 'Packages': { 'Tested': [], 'Available': [] },
                       'TestGroups': [],
                       'TestSuites': [],
                       'Modules': [] }

    # Consolidate the information on the packages available.
    self.__verifyPackages(testCfg)

    # Get information on the test groups selected.
    for testGroupNode in testCfg.findall('TestGroups/TestGroup'):
      self.__testCfg['TestGroups'].append(testGroupNode.get('name'))

    # Add the test cases from given test suites to the TestCases node
    for testSuiteNode in testCfg.findall('TestSuites/TestSuite'):
      testSuite = testSuiteNode.get('name')
      testCaseNames = mevis.MLABTestCaseDatabase.allTestCaseSuites().get(testSuite, {}).get("testCases", [])
      testCasesNode = testCfg.find('TestCases')
      for name in testCaseNames:
        etree.SubElement(testCasesNode, 'TestCase', {'name': name})

    # Set system information.
    testRunNode.set('platform', mevis.MLAB.systemId())
    testRunNode.set('compiler', mevis.MLAB.compilerInfo())
    # Set build information.
    testRunNode.set('builddate', mevis.MLAB.dateOfBuildJob().date().toString("yyyy-MM-dd"))
    testRunNode.set('version', mevis.MLAB.priv().variable('Version', False))

    # Create nodes to store information on the test run.
    infoNode = etree.SubElement(testRunNode, 'Information')
    testResultNode = etree.SubElement(testRunNode, 'Results')
    etree.SubElement(infoNode, 'TestCases')
    etree.SubElement(infoNode, 'Modules')
    ___addPackageInfoNode( infoNode )

    # Consolidate the information on the test cases that should be executed.
    self.__verifyTestCaseList(testCfg, testRunNode)

    # If no generic test cases are used then don't build information list for
    # modules (this causes major performance on windows machines when storing
    # the resulting xml).
    for testCaseNode in infoNode.findall("./TestCases/TestCase"):
      if testCaseNode.get("type") == "GenericTestCase":
        # extend the XML structure and hook in all modules to test
        self.__collectModulesToTest(testCfg)
        self.__buildModuleInfo(infoNode.find("Modules"))
        break

    resultNode.set('errorCode', 'Ok')
    resultNode.append(testRunNode)
    resultNode.append(testCfg)

    self.__testCfg = None
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __buildTestCaseAgenda ---------------------------------------------------------------{{{-
  def __buildTestCaseAgenda(self, requestNode, resultNode):
    try:
        parameterNode = requestNode.find('Parameters')
        packagesToTest = parameterNode.get('packages', '').split(',')
        modulesToTest  = parameterNode.get('modules', '').split(',')
        testCaseName = parameterNode.find('TestCase').get('name')
        testResultsNode = etree.SubElement(resultNode, 'Results')
        testCaseAgenda, status = self.__loadAndVerifyTestCase(testCaseName, testResultsNode, packagesToTest, modulesToTest)
        testCase = testResultsNode.find('TestCase')
        # Remove TestFunctions for GenericTests with status TEST_STATUS_DO_NOT_TEST_MODULE.
        if testCase is not None and testCase.get('status',"") == str(Utils.TEST_STATUS_DO_NOT_TEST_MODULE):
          functionListNode = testCaseAgenda.find('TestFunctions')
          functionNodes = functionListNode.findall('Function')
          for functionNode in functionNodes:
            functionListNode.remove(functionNode)
        assert(testCaseAgenda)
        resultNode.append(testCaseAgenda)
        if status != 'Ok':
          etree.SubElement(resultNode, 'Error').text = 'Failed to load the test case'
        resultNode.set('errorCode', status)
    except:
        resultNode.set('errorCode', 'Failed')
        etree.SubElement(resultNode, 'Error').text = traceback.format_exc()
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __verifyTestCaseList ----------------------------------------------------------------{{{-
  
  def __verifyTestCaseList (self, testCfg, testRunNode):
    # Get list of all available test cases.
    availTestCaseList = []
    for package in self.__testCfg['Packages']['Tested']:
      availTestCaseList.extend(mevis.MLABTestCaseDatabase.allTestCasesForPackage(package))
      if self.__isInsideTestCaseManager:
        availTestCaseList.extend(getCodeTestsByPackage().get(package,{}).keys())

    # If no test cases were given use list of available ones.
    testCaseListNode = testCfg.find('TestCases')
    if len(testCaseListNode.findall('TestCase')) == 0:
      for testCaseName in availTestCaseList:
        etree.SubElement(testCaseListNode, 'TestCase', name=testCaseName)

    # Get the node to append information to.
    testInfoNode = testRunNode.find('Information/TestCases')

    for testCaseNode in testCfg.findall('TestCases/TestCase'):
      testCaseName = testCaseNode.get('name')
      if testCaseName in availTestCaseList:
        infoDict = self.__getTestCaseInfo(testCaseName)
        # Verify test groups if necessary.
        if not self.__verifyTestGroups(infoDict, self.__testCfg['TestGroups']):
          mevis.MLAB.logError("TestCase %s not in tested groups (%s)." % (testCaseName, ", ".join(self.__testCfg['TestGroups'])))
          testCaseNode.set('isNotInTestGroups', str(True))
        else:
          testCaseNode.set('type', infoDict['type'])
          testInfoNode.append(testCaseNode)
          testCaseNode.set('status', str(Utils.TEST_STATUS_OK))
      else:
        mevis.MLAB.logError("test case not found %s %s" %( testCaseName, availTestCaseList))
        testCaseNode.set('status', str(Utils.TEST_STATUS_ERROR))
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __verifyTestCase --------------------------------------------------------------------{{{-
  
  def __loadAndVerifyTestCase(self, testCaseName, testResultNode, packagesToTest, modulesToTest):
    resolvedPackagesToTest = []
    for package in packagesToTest:
        pGroup, pName = package.split('/')
        if pGroup == "*" and pName == "*":
          for package in mevis.MLABPackageManager.packages():
            resolvedPackagesToTest.append(package.packageIdentifier())
        elif pName == "*":
            for package in mevis.MLABPackageManager.packages():
                if package.packageGroup() == pGroup:
                    resolvedPackagesToTest.append(package.packageIdentifier())
        else:
            resolvedPackagesToTest.append(package)
    testCaseNode, status = self.__verifyTestCase(testCaseName, testResultNode, resolvedPackagesToTest, modulesToTest)
    return testCaseNode, status
  # --------------------------------------------------------------------------------------------}}}-
  
  def __getTestCaseInfo(self, testCaseName):
    infoDict = mevis.MLABTestCaseDatabase.testCaseInfo(testCaseName)
    if not infoDict:
      codeTest = getCodeTest(testCaseName)
      if codeTest != None:
        infoDict = codeTest.getInfoDict()
    return infoDict

  # -- def __verifyTestCase --------------------------------------------------------------------{{{-
  
  def __verifyTestCase (self, testCaseName, testResultNode, packagesToTest, modulesToTest):
    infoDict = self.__getTestCaseInfo(testCaseName)

    # Try to load the test case.
    testType = infoDict['type']

    # if agenda test case is set from outside, use it
    testCase = self.__agendaTestCase
    if not testCase:
      mevis.MLAB.log("Trying to load test case %s" % testCaseName)
      # no test case set, try loading it instead
      testCase = self.__loadTestCase(testCaseName, testType)
      mevis.MLAB.log("Loading complete")

    if testCase == None:
      return None, 'Failed'

        # Add basic information for the actual testing.
    if testType == 'GenericTestCase':
      modulesToTest, modulesNotToTest = testCase.getModulesToTest(modulesToTest, packagesToTest)
      for moduleName in modulesToTest:
        etree.SubElement(testResultNode, "TestCase", name=testCaseName, type=testType, module=moduleName)
      for moduleName in modulesNotToTest:
        etree.SubElement(testResultNode, "TestCase", name=testCaseName, type=testType, module=moduleName, status=str(Utils.TEST_STATUS_DO_NOT_TEST_MODULE))
    else:
      etree.SubElement(testResultNode, 'TestCase', name=testCaseName, type=testType)

    return testCase.getTestCaseNode(), 'Ok'
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __verifyTestGroups ------------------------------------------------------------------{{{-
  
  def __verifyTestGroups (self, infoDict, testGroupList):
    testCaseGroupList = infoDict['testGroups'] if 'testGroups' in infoDict else []

    if testGroupList:
      if 'automatic' in testGroupList:
        if 'manual' in testCaseGroupList:
          return False
        return True
      for testGroup in testGroupList:
        if testGroup in testCaseGroupList:
          return True
      return False
    return True
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __verifyPackages --------------------------------------------------------------------{{{-
  
  def __verifyPackages (self, testCfg):
    packageRoot = testCfg.find('Packages')

    # First go over list and substitute wildcards and verify all given
    # packages.
    tPkgNode = packageRoot.find('Tested')
    aPkgNode = packageRoot.find('Available')
    iPkgNode = packageRoot.find('Ignored')
    # if no ignored package is given, 
    # then self.__verifyPackageListNode() would ignore all packages
    if iPkgNode.getchildren():
      self.__verifyPackageListNode(iPkgNode)
    ignoredPackageIDs = set()
    for ignoredPackage in iPkgNode.getchildren():
      ignoredPackageIDs.add(ignoredPackage.get('name'))

    self.__verifyPackageListNode(tPkgNode, ignoredPackageIDs)
    self.__verifyPackageListNode(aPkgNode, ignoredPackageIDs)
    # Get list of verified packages.
    tPkgSet = set()
    for packageNode in tPkgNode.findall('Package'):
      if packageNode.get('status') in ('Ok', 'Added'):
        tPkgSet.add(packageNode.get('name'))

    aPkgSet = set()
    for packageNode in aPkgNode.findall('Package'):
      if packageNode.get('status') in ('Ok', 'Added'):
        aPkgSet.add(packageNode.get('name'))

    # Save lists of packages sets for usage on slave side.
    self.__testCfg['Packages']['Tested'] = list(tPkgSet)
    self.__testCfg['Packages']['Available'] = list(tPkgSet.union(aPkgSet))

    # Add all available packages for usage on master side.
    for item in tPkgSet.difference(aPkgSet):
      etree.SubElement(aPkgNode, 'Package', name=item, status='Ok')
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __verifyPackageListNode -------------------------------------------------------------{{{-
  
  def __verifyPackageListNode (self, packageListNode, ignoredPackageIDs=[]):
    # If no packages are given add everything!
    if not packageListNode.getchildren():
      etree.SubElement(packageListNode, "Package", name="*/*")

    for packageNode in packageListNode:
      packageID = packageNode.get('name')
      try:
        pGroup, pName = packageID.split("/")
      except:
        packageNode.set('status', 'Invalid')
        continue

      # Substitute the wildcards.
      if pGroup == "*":
        if pName == "*":
          for package in mevis.MLABPackageManager.packages():
            packageID = package.packageIdentifier()
            if not packageID in ignoredPackageIDs:
              etree.SubElement(packageListNode, "Package", name=packageID, status='Added')
          # Remove node as the wildcard has been executed.
          packageNode.set('status', 'Substituted')
        else:
          packageNode.set('status', 'Failed')
      elif pName == "*":
        packageNode.set('status', 'Substituted')
        for package in mevis.MLABPackageManager.packagesByGroup(pGroup):
          packageID = package.packageIdentifier()
          if not packageID in ignoredPackageIDs:
            etree.SubElement(packageListNode, "Package", name=packageID, status='Added')
      else:
        # If the given package exists add it to the package set otherwise
        # remove the XML node.
        if mevis.MLABPackageManager.packageByIdentifier(packageID):
          packageNode.set('status', 'Ok')
        else:
          packageNode.set('status', 'Failed')
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __collectModulesToTest ---------------------------------------------------------------------{{{-
  
  def __collectModulesToTest (self, testCfg):
    modulesNode = testCfg.find('Modules')

    # Build up a dictionary with all specified filters.
    filterDict = {}
    for filterNode in modulesNode.findall('Filter'):
      key, valueList = filterNode.text.split(":")
      filterDict[key] = []
      for value in valueList.split(","):
        filterDict[key].append(value)

    # Build up a list with all modules to be be taken into account.
    availableModuleList = []
    for packageName in self.__testCfg['Packages']['Tested']:
      availableModuleList.extend(mevis.MLAB.allModulesForPackageIdentifier(packageName))

    # If the user did not specify a list of modules use all available.
    if len(modulesNode.findall('Module')) == 0:
      for moduleName in availableModuleList:
        etree.SubElement(modulesNode, "Module", name=moduleName)

    # Find all modules to test.
    for moduleNode in modulesNode.findall('Module'):
      moduleName = moduleNode.get('name')
      moduleInfo = mevis.MLAB.moduleInfo(moduleName)

      if moduleInfo and moduleName in availableModuleList:
        useModule = True
        # Does module pass filters?
        for f in filterDict:
          if not f in moduleInfo or not [x for x in filterDict[f] if re.search(x, moduleInfo[f])]:
            useModule = False
            break
        if useModule:
          self.__testCfg['Modules'].append(moduleName)
          moduleNode.set('status', str(Utils.TEST_STATUS_OK))
        else:
          moduleNode.set('isModuleFiltered', str(True))
      else:
        modulesNode.set('status', str(Utils.TEST_STATUS_ERROR))
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __buildModuleInfo -------------------------------------------------------------------{{{-
  #  @param modulesInfoNode XML node taking the module information.
  def __buildModuleInfo (self, modulesInfoNode):
    for moduleName in self.__testCfg['Modules']:
      moduleInfo = mevis.MLAB.moduleInfo(moduleName)
      newModuleNode = etree.SubElement(modulesInfoNode, 'Module', name=moduleName)
      for key in moduleInfo:
        value = moduleInfo[key]
        etree.SubElement(newModuleNode, key, type=value.__class__.__name__).text = unicode(value)
  # --------------------------------------------------------------------------------------------}}}-

  # -- def __setPackageList --------------------------------------------------------------------{{{-
  
  def __setPackageList (self, xmlNode, resultNode):
    packageList = []
    for item in xmlNode.findall('Package'):
      packageList.append(item.get('name'))
    TestHelper.getInstance().setPackageList(packageList)
    resultNode.set('errorCode', 'Ok')
  # --------------------------------------------------------------------------------------------}}}-

  # -- def runCommand --------------------------------------------------------------------------{{{-
  
  def runCommand (self, requestNode):
    command = requestNode.get('type')
    mevis.MLAB.log("Running command '%s'" % command)

    resultNode = etree.Element('Result')
    try:
      if   command == 'Quit':
        resultNode.set('errorCode', 'Ok')
        self.__running = False
      elif command == 'DoTest':
        testCaseNode = requestNode.find('TestCase')
        if self.__com and testCaseNode.get("requestProgress") == "1":
          self.setTestCaseListener(TestCaseRemoteListener(self.__com))
          
        self.__doTest(testCaseNode, resultNode)

        if self.__com and testCaseNode.get("requestProgress") == "1":
          self.setTestCaseListener(None)

      elif command == 'SetPackageList':  self.__setPackageList(requestNode.find('Packages'), resultNode)
      elif command == 'BuildTestAgenda': self.__buildTestAgenda(requestNode.find('Configuration'), resultNode)
      elif command == 'BuildTestCaseAgenda': self.__buildTestCaseAgenda(requestNode, resultNode)
      else:
        raise Exception('Unknown command: %s' % (command))
    except:
      resultNode.set('errorCode', 'Exception')
      etree.SubElement(resultNode, 'Error').text = traceback.format_exc()
      mevis.MLAB.log(traceback.format_exc())
      self.__running = False

    content = etree.tostring(resultNode).decode()
    mevis.MLAB.log("Result content: %s%s" % (content[:150], " [...]" if len(content)>150 else ""))
    return resultNode
  # --------------------------------------------------------------------------------------------}}}-

  # -- def run ---------------------------------------------------------------------------------{{{-
  
  def run (self):
    self.__com.connect()
    self.__running = True
    while self.__running:
      request = self.__com.recv(20)
      if request in ('', None):
        mevis.MLAB.logError(self.__com.getLastErrorWithMessage()[1])
        break

      requestNode = etree.fromstring(request)
      resultNode = self.runCommand(requestNode)

      if not self.__com.send(etree.tostring(resultNode), 5):
        mevis.MLAB.logError("Couldn't send result to request %s" % (request))
        self.__running = False
    self.__com.disconnect()
  # --------------------------------------------------------------------------------------------}}}-
# ----------------------------------------------------------------------------------------------}}}-