Slave.py

Go to the documentation of this file.

#
# Copyright 2007, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
 
 
import os
import re
import traceback
 
import xml.etree.cElementTree as etree
 
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
 
 
# Determine if the Standard SDK FME modules are available:
_isPublicSDK = bool(
    mevis.MLABPackageManager.packagesByGroup("FMEstable") and mevis.MLABPackageManager.packagesByGroup("FMEwork")
)
 
 
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:
    """The class controlling a MeVisLab slave instance.
    The slave is controlled by a master using socket based IPC to send messages.
    """
 
    def __init__(self, cfgFile, context, offline=False):
        """Initializes the slave process.
 
        @param cfgFile The configuration file used for this test run.
        @param context The context used for testing.
        @param offline Specifies whether the tests are run in same MeVisLab instance as master.
        """
        self.__ctx = context
        self.__com = IPC.ComSlave() if not offline else None
 
        self.__testCaseListener = None
        self.__agendaTestCase = None
        self.__isInsideTestCaseManager = False
        self.__testCase = None
        self.__running = False
        self.__testCfg = None
 
        # 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(self, testCaseNode):
        """Load the given test case.
        If the test case could not be loaded "None" is returned.
 
        @param testCaseNode XML representation containing information on the test case to load.
        @return The loaded test case.
        """
        testType = testCaseNode.get("type")
        moduleName = testCaseNode.get("module") if testType == "GenericTestCase" else None
        return self.__loadTestCase(testCaseNode.get("name"), testType, moduleName)
 
    @staticmethod
    def __loadTestCase(testCaseName, testCaseType, moduleName=None):
        """Internal loading mechanism.
 
        @param testCaseName Name of the test case to be loaded.
        @param testCaseType Type of the test case to be loaded.
        @param moduleName Name of module to be tested (in case of generic test cases.)
        @return The loaded test case. None if loading failed.
        """
        # Create test case depending on the type.
        try:
            match testCaseType:
                case "GenericTestCase":
                    return GenericTestCase(testCaseName, moduleName)
                case "FunctionalTestCase":
                    return FunctionalTestCase(testCaseName)
                case "CodeTestTestCase":
                    return CodeTestTestCase(testCaseName)
        except Exception as e:
            mevis.MLAB.logError("Error loading test case %s: %s" % (testCaseName, e))
            return None
        raise RuntimeError("Unsupported test case type %s" % testCaseType)
 
    def setAgendaTestCase(self, testCase):
        """Set the test case that is used for building the agenda/function list.
        Used in the TestCaseManager module to make local testing possible.
 
        @param testCase The test case object.
        """
        self.__agendaTestCase = testCase
 
    def getTestCase(self):
        """Returns the test case that has been run.
        Used in the TestCaseManager to keep test case after execution.
        @return The test case object.
        """
        return self.__testCase
 
    def unloadTestCase(self):
        """Clears the loaded test case."""
        self.__testCase = None
 
    def __doTest(self, testCaseNode, resultNode):
        """Run the test received from the master.
        The results (returned as an XML node) are appended to the resultNode.
 
        @param testCaseNode The test case description in XML.
        @param resultNode The result node returned (call by reference!).
        """
 
        try:
            maxErrorMessagesPerTestFunction = int(testCaseNode.get("maxErrorMessagesPerTestFunction"))
        except ValueError:
            maxErrorMessagesPerTestFunction = 10000
        try:
            maxInfoMessagesPerTestFunction = int(testCaseNode.get("maxInfoMessagesPerTestFunction"))
        except ValueError:
            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)
 
                self.__testCase.setTestCaseListener(self.__testCaseListener)
                self.__testCase.run(testCaseNode)
 
                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(self, testCfg, resultNode):
        """Build a test agenda for the given request.
        The agenda contains information which tests should be executed. The
        information is contained in the returned XML structure.
 
        @param testCfg The parameterization of the current test run.
        @param resultNode The resulting agenda.
        """
 
        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, "MissingTestCases")
        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(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")
        
            logHandler = LogHandler(None)
            logHandler.setErrorLimit(100)
            logHandler.setInfoLimit(1000)
            logHandler.allowNonFileBasedMessageLog()
            TestHelper.getInstance().setLogHandler(logHandler)
 
            testCase, status = self.__loadAndVerifyTestCase(
                testCaseName, testResultsNode, packagesToTest, modulesToTest
            )
            testCaseAgenda = testCase.getTestCaseNode()
            testCaseNode = testResultsNode.find("TestCase")
            # Remove TestFunctions for GenericTests with status TEST_STATUS_DO_NOT_TEST_MODULE.
            if testCaseNode is not None and testCaseNode.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)
            resultNode.append(testCaseAgenda)
            if status != "Ok":
                etree.SubElement(resultNode, "Error").text = "Failed to load the test case."
                errorMessages = etree.SubElement(resultNode, "Events")
                for timeStamp, type, info in logHandler.getCachedMessageList():
                    errorNode = etree.SubElement(errorMessages, "Event")
                    errorNode.set("timestamp", timeStamp)
                    errorNode.set("type", type)
                    etree.SubElement(errorNode, "Message").text = info
 
            TestHelper.getInstance().unsetLogHandler()
            logHandler.close()
 
            resultNode.set("errorCode", status)
        except:
            resultNode.set("errorCode", "Failed")
            etree.SubElement(resultNode, "Error").text = traceback.format_exc()
 
    def __verifyTestCaseList(self, testCfg, testRunNode):
        """Verify the availability of all the given tests.
        If no tests are given all available tests are returned.
 
        @param testCfg The test run parameterization.
        @param testRunNode The test run agenda.
        """
        # 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")
        testInfoNodeMissing = testRunNode.find("Information/MissingTestCases")
 
        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))
                testInfoNodeMissing.append(testCaseNode)
                testCaseNode.set("status", str(Utils.TEST_STATUS_LOAD_ERROR))
 
    def __loadAndVerifyTestCase(self, testCaseName, testResultNode, packagesToTest, modulesToTest):
        """Verify Test Case and add information on it."""
        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)
        testCase, status = self.__verifyTestCase(
            testCaseName, testResultNode, resolvedPackagesToTest, modulesToTest
        )
        return testCase, status
 
    @staticmethod
    def __getTestCaseInfo(testCaseName):
        infoDict = mevis.MLABTestCaseDatabase.testCaseInfo(testCaseName)
        if not infoDict:
            codeTest = getCodeTest(testCaseName)
            if codeTest is not None:
                infoDict = codeTest.getInfoDict()
        return infoDict
 
    # -- def __verifyTestCase --------------------------------------------------------------------{{{-
    def __verifyTestCase(self, testCaseName, testResultNode, packagesToTest, modulesToTest):
        """Verify Test Case and add information on it.
 
        @param testCaseName The name of the test case to be verified.
        @param testResultNode The node to append verified test cases.
        @return The XML info node and a status string.
        """
        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 is 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, ("Ok" if testCase.isValid() else "FAILED")
 
    @staticmethod
    def __verifyTestGroups(infoDict, testGroupList):
        """Verify whether test case should be executed.
        TestGroups can be used to specify groups of modules that should be tested.
        There is one special group: if 'automatic' is given modules of the 'manual' group are not executed.
        Tests in the testGroup 'disabled' are never executed.
 
        @param testGroupList The list of test groups that should be tested.
        @return Whether the test case should be executed.
        """
        testCaseGroupList = infoDict["testGroups"].lower() if "testGroups" in infoDict else ""
        testCaseGroupList = testCaseGroupList.split()
 
        if "disabled" in testCaseGroupList or ("needspublicsdk" in testCaseGroupList and not _isPublicSDK):
            return False
        testGroupList = [tg.lower() for tg in testGroupList]
        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(self, testCfg):
        """Build up a list of packages and verify existence of given ones.
        This method is given an XML node containing the names of all the packages
        that should be searched for TestCases and those that should be available.
        The wildcard "*" can be used to select either all available packages
        ("*/*") or all packages of a selected group ("Standard/*").
 
        @param testCfg The test run parameterization.
        """
        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 len(iPkgNode) > 0:
            self.__verifyPackageListNode(iPkgNode)
        ignoredPackageIDs = set()
        for ignoredPackage in iPkgNode:
            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")
 
    @staticmethod
    def __verifyPackageListNode(packageListNode, ignoredPackageIDs=None):
        """Substitute wildcards and verify package nodes.
 
        @param packageListNode Node with package sub-nodes that contain information
                               on the packages.
        """
        # If no packages are given add everything!
        if len(packageListNode) == 0:
            etree.SubElement(packageListNode, "Package", name="*/*")
 
        for packageNode in packageListNode:
            packageID = packageNode.get("name")
            try:
                pGroup, pName = packageID.split("/")
            except:
                packageNode.set("status", "Invalid")
                continue
 
            ignoredPackageIDs = ignoredPackageIDs or []
            # 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(self, testCfg):
        """Get a list of all modules to test.
        The list of all available modules is filtered using the settings the user made.
        Those can either be a specific list of tests or a set of filters to apply on the list of modules.
 
        @param testCfg The test run parameterization.
        """
        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(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 = str(value)
 
    @staticmethod
    def __setPackageList(xmlNode, resultNode):
        """Method to set the list of available packages given in the setting.
 
        @param xmlNode An XML node containing 'Package' sub-nodes.
        @param resultNode The result of the request.
        """
        packageList = []
        for item in xmlNode.findall("Package"):
            packageList.append(item.get("name"))
        TestHelper.getInstance().setPackageList(packageList)
        resultNode.set("errorCode", "Ok")
 
    def runCommand(self, requestNode):
        """Run a command given via the requestNode.
 
        @param requestNode The request that contains the command and its parameters.
        @return An XML node containing the results.
        """
        resultNode = etree.Element("Result")
        if not TestHelper.getInstance().getGlobalContext():
            command = "Quit"
            mevis.MLAB.logWarning("Test case manager has been closed - aborting test execution")
        else:
            command = requestNode.get("type")
            mevis.MLAB.log("Running command '%s'" % command)
 
        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(self):
        """The main method which handles all the request from the master."""
        self.__com.connect()
        self.__running = True
        TestHelper.getInstance().runTestInSecureMode()
        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
        TestHelper.getInstance().runTestInCurrentMlabInstance()
        self.__com.disconnect()