Exemplo n.º 1
0
 def __init__(self, _strName="EDApplication", \
               _strVersion="1.0.1", \
               _strPluginName=None, \
               _strConfigurationFileName=None, \
               _strDataInputFilePath=None, \
               _edLogFile=None, \
               _strBaseDir=None, \
               _strWorkingDir=None, \
               _strDataOutputFilePath=None):
     self.__strName = _strName
     self.__strVersion = _strVersion
     self.__strPluginName = _strPluginName
     self.__strConfigurationFileName = _strConfigurationFileName
     self.__strDataInputFilePath = _strDataInputFilePath
     self.__strDataOutputFilePath = _strDataOutputFilePath
     self.__edLogFile = _edLogFile
     self.__strBaseDir = _strBaseDir
     self.__strWorkingDir = _strWorkingDir
     self.__strFullApplicationWorkingDirectory = None
     self.__strXMLData = None
     self.__listErrorMessages = []
     self.__listWarningMessages = []
     self.__xsDataOutput = None
     self.__edObtainedOutputDataFile = None
     self.__strDataOutputFilePath = None
     self.__edPlugin = None
     self.__edCommandLine = EDCommandLine(sys.argv)
     self.__strApplicationInstanceName = self.__strName + "_" + time.strftime("%Y%m%d-%H%M%S", time.localtime(time.time()))
     self.__strLogFileName = self.__strApplicationInstanceName + ".log"
     self.__bIsFailure = False
     self.__strCurrentWorkingDirectory = os.getcwd()
     self.__strConfigurationHome = None
     self.__strPathToLogFile = None
Exemplo n.º 2
0
 def preProcess(self):
     """
     Scans the command line.
     """
     EDVerbose.DEBUG("EDTestLauncher.preProcess")
     edCommandLine = EDCommandLine(sys.argv)
     EDVerbose.log(self.getEdCommandLine().getCommandLine())
     self.processCommandLineDebugVerboseLogFile()
     bContinue = True
     strTestName = edCommandLine.getArgument(EDTestLauncher.TEST_LABEL)
     EDVerbose.DEBUG("EDTestLauncher.preProcess: test name = %r" % strTestName)
     if (strTestName is None):
         EDVerbose.screen("ERROR - no --test argument found")
         bContinue = False
     else:
         self.__edTestCase = EDUtilsTest.getFactoryPluginTest().loadPlugin(strTestName)
     if (bContinue):
         # Determine the base directory
         if(self.getBaseDir() is None):
             self.processCommandLineBaseDirectory()
         # Create the application working directory  
         strApplicationInstanceName = strTestName + "_" + time.strftime("%Y%m%d-%H%M%S", time.localtime())
         if(self.getWorkingDir() is None):
             self.setWorkingDir(strApplicationInstanceName)
         self.createApplicationWorkingDirectory()
         # Set the name of the log file
         EDVerbose.setLogFileName(os.path.join(self.getBaseDir(), strApplicationInstanceName + ".log"))
         # The check for --quiet and --DEBUG should ideally be placed elsewhere,
         # for example in EDApplication.
         if (edCommandLine.existCommand(EDTestLauncher.QUIET_LABEL)):
             EDVerbose.setVerboseOff()
             EDVerbose.setTestOff()
         if (edCommandLine.existCommand(EDApplication.DEBUG_PARAM_LABEL_1) or \
             edCommandLine.existCommand(EDApplication.DEBUG_PARAM_LABEL_2)):
             EDVerbose.setVerboseDebugOn()
             EDVerbose.DEBUG("EDTestLauncher.preProcess: Debug mode")
Exemplo n.º 3
0
class EDApplication(object):
    """
    This is the main EDNA application class. This class can be sub-classed for any specific application need.
    An EDNA application is able to launch an entry point plugin. It accepts the following parameter:
    --execute    : name of the plugin to be executed 
    --inputFile  : related plugin data (xml input data file name)
    --outputFile : related plugin result (xml output data file name)
    --conf       : configuration file name
    --basedir    : where the application working directory should go 
    --DEBUG or --debug : turns on debugging   
    -v or --version : Displays the application name and version
    --verbose    : Turns on verbose mode
    --no-log     : Turns off logging
    -h or --help : Prints out an usage message
    """

    CONFIGURATION_PARAM_LABEL = "--conf"
    PLUGIN_PARAM_LABEL = "--execute"
    DATASET_PARAM_LABEL = "--inputFile"
    OUTPUT_PARAM_LABEL = "--outputFile"
    DATASET_BASE_DIRECTORY = "--basedir"
    DEBUG_PARAM_LABEL_1 = "--DEBUG"
    DEBUG_PARAM_LABEL_2 = "--debug"
    VERSION_PARAM_LABEL_1 = "-v"
    VERSION_PARAM_LABEL_2 = "--version"
    VERBOSE_MODE_LABEL = "--verbose"
    NO_LOG_LABEL = "--no-log"
    HELP_LABEL_1 = "-h"
    HELP_LABEL_2 = "--help"

    __edConfiguration = None
    __edFactoryPlugin = None
    __semaphore = Semaphore()


    def __init__(self, _strName="EDApplication", \
                  _strVersion="1.0.1", \
                  _strPluginName=None, \
                  _strConfigurationFileName=None, \
                  _strDataInputFilePath=None, \
                  _edLogFile=None, \
                  _strBaseDir=None, \
                  _strWorkingDir=None, \
                  _strDataOutputFilePath=None):
        self.__strName = _strName
        self.__strVersion = _strVersion
        self.__strPluginName = _strPluginName
        self.__strConfigurationFileName = _strConfigurationFileName
        self.__strDataInputFilePath = _strDataInputFilePath
        self.__strDataOutputFilePath = _strDataOutputFilePath
        self.__edLogFile = _edLogFile
        self.__strBaseDir = _strBaseDir
        self.__strWorkingDir = _strWorkingDir
        self.__strFullApplicationWorkingDirectory = None
        self.__strXMLData = None
        self.__listErrorMessages = []
        self.__listWarningMessages = []
        self.__xsDataOutput = None
        self.__edObtainedOutputDataFile = None
        self.__strDataOutputFilePath = None
        self.__edPlugin = None
        self.__edCommandLine = EDCommandLine(sys.argv)
        self.__strApplicationInstanceName = self.__strName + "_" + time.strftime("%Y%m%d-%H%M%S", time.localtime(time.time()))
        self.__strLogFileName = self.__strApplicationInstanceName + ".log"
        self.__bIsFailure = False
        self.__strCurrentWorkingDirectory = os.getcwd()
        self.__strConfigurationHome = None
        self.__strPathToLogFile = None


    def execute(self):
        """
        This is the main execute method which executes preProcess, process and postProcess.
        """
        self.preProcess()
        self.process()
        self.postProcess()


    def preProcess(self):
        """
        Creates the application working directory (log dir)
        Initializes the configuration
        retrieves the plugin xml data to be passed to the plugin
        """
        EDVerbose.DEBUG("EDApplication.preProcess")
        self.processCommandline()
        if (not self.__bIsFailure):
            # Check that the plugin can be located
            strPluginLocation = EDFactoryPluginStatic.getFactoryPlugin().getModuleLocation(self.__strPluginName)
            if (strPluginLocation is None):
                EDVerbose.error("Plugin  %s cannot be loaded!" % self.__strPluginName)
                self.__bIsFailure = True
            # Check that the input file can be read
            if (self.getDataInputFilePath() is not None) and (not os.path.exists(self.__strDataInputFilePath)):
                EDVerbose.error("Input XML file not found : %s" % self.__strDataInputFilePath)
                self.__bIsFailure = True
            # Check that the output file can be created
            if (self.__strDataOutputFilePath is not None):
                strOutputDirectory = os.path.dirname(self.__strDataOutputFilePath)
                if (strOutputDirectory is None or strOutputDirectory == ""):
                    strOutputDirectory = os.getcwd()
                    self.__strDataOutputFilePath = os.path.join(strOutputDirectory, self.__strDataOutputFilePath)
                if (not os.access(strOutputDirectory, os.W_OK)):
                    EDVerbose.error("Output directory not writable: %s" % strOutputDirectory)
                    self.__bIsFailure = True
                elif (os.path.exists(self.__strDataOutputFilePath)):
                    if (not os.access(self.__strDataOutputFilePath, os.W_OK)):
                        EDVerbose.error("Output file not writable: %s" % self.__strDataOutputFilePath)
                        self.__bIsFailure = True
        if (not self.__bIsFailure):
            EDVerbose.DEBUG("EDApplication.PLUGIN_PARAM_LABEL: " + EDApplication.PLUGIN_PARAM_LABEL)

            # Load the configuration file
            if (os.path.exists(self.__strConfigurationFileName)):
                EDVerbose.screen("Loading Configuration file: %s" % self.__strConfigurationFileName)
                EDConfigurationStatic.addConfigurationFile(self.__strConfigurationFileName, _bReplace=True)
                pyDictionary = {}
                pyDictionary[ "${EDNA_HOME}" ] = EDUtilsPath.getEdnaHome()
                if self.getDataInputFilePath() is not None:
                    self.__strXMLData = EDUtilsFile.readFileAndParseVariables(self.getDataInputFilePath(), pyDictionary)
            else:
                EDVerbose.warning("Cannot find configuration file: %s" % self.__strConfigurationFileName)
            # Create the application working directory    
            if(self.__strWorkingDir is None):
                self.__strWorkingDir = self.__strApplicationInstanceName
            self.createApplicationWorkingDirectory()


    def process(self):
        """
        Calls the Plugin to be executed
        """
        if (not self.__bIsFailure):
            self.__edPlugin = EDFactoryPluginStatic.loadPlugin(self.__strPluginName)
            if(self.__edPlugin is not None):
                self.__edPlugin.setBaseDirectory(self.__strFullApplicationWorkingDirectory)
                self.__edPlugin.setBaseName(self.__strPluginName)
                self.__edPlugin.setDataInput(self.__strXMLData)
                self.__edPlugin.connectSUCCESS(self.doSuccessActionPlugin)
                self.__edPlugin.connectFAILURE(self.doFailureActionPlugin)
                EDVerbose.DEBUG("EDApplication.process: Executing " + self.__strPluginName)
                self.__edPlugin.execute()
                self.__edPlugin.synchronize()
            else:
                EDVerbose.error(EDMessage.ERROR_PLUGIN_NOT_LOADED_02 % ('EDApplication.process', self.__strPluginName))
                self.__bIsFailure = True




    def processCommandline(self):
        """
        This method is intended to be overridden by applications who
        would like to implement their own command line handling.
        
        This default method implements the following workflow:
            - Check for debug, verbose and log file command line options
        
        """
        EDVerbose.DEBUG("EDApplication.execute")
        EDVerbose.log(self.__edCommandLine.getCommandLine())
        self.processCommandLineDebugVerboseLogFile()
        # Determine the base directory
        if(self.__strBaseDir is None):
            self.processCommandLineBaseDirectory()
        # Set the name of the log file
        self.__strPathToLogFile = os.path.abspath(os.path.join(self.__strBaseDir, self.__strLogFileName))
        EDVerbose.setLogFileName(self.__strPathToLogFile)
        self.processCommandLineHelp()
        if (not self.__bIsFailure):
            self.processCommandLineVersion()
        if (not self.__bIsFailure):
            # Name of the plugin to be executed        
            if (self.__strPluginName is None):
                self.processCommandLinePluginName()
            # Path to the input XML file
            if (self.__strDataInputFilePath is None):
                self.processCommandLineInputFilePath()
            # Path to the output XML file
            if(self.__strDataOutputFilePath is None):
                self.processCommandLineOutputFilePath()
            if (self.__bIsFailure):
                self.usage()
        if (not self.__bIsFailure):
            # If strConfigurationFileName is None, this means that it has not been given to the constructor\
            # It has been given by the command line\
            if(self.__strConfigurationFileName is None):
                self.__strConfigurationFileName = self.getCommandLineArgument(EDApplication.CONFIGURATION_PARAM_LABEL)



    def processCommandLineDebugVerboseLogFile(self):
        EDVerbose.DEBUG("EDApplication.processCommandLineDebugVerboseLogFile")
        EDVerbose.setVerboseOff()
        # Check if no log file
        if (self.__edCommandLine.existCommand(EDApplication.NO_LOG_LABEL)):
            EDVerbose.setLogFileOff()
            EDVerbose.DEBUG("Log file output switched off")
        # Check if debug mode
        if (self.__edCommandLine.existCommand(EDApplication.DEBUG_PARAM_LABEL_1) or
            self.__edCommandLine.existCommand(EDApplication.DEBUG_PARAM_LABEL_2)):
            EDVerbose.setVerboseDebugOn()
            EDVerbose.DEBUG("Debug Mode [ON]")
        # Check if verbose
        if (self.__edCommandLine.existCommand(EDApplication.VERBOSE_MODE_LABEL)):
            EDVerbose.setVerboseOn()


    def processCommandLineHelp(self):
        EDVerbose.DEBUG("EDApplication.processCommandLineHelp")
        if (self.__edCommandLine.existCommand(EDApplication.HELP_LABEL_1)
            or self.__edCommandLine.existCommand(EDApplication.HELP_LABEL_2)):
            EDVerbose.setVerboseOn()
            self.usage()
            self.__bIsFailure = True


    def processCommandLineVersion(self):
        EDVerbose.DEBUG("EDApplication.processCommandLineVersion")
        if (self.__edCommandLine.existCommand(EDApplication.VERSION_PARAM_LABEL_1) or
            self.__edCommandLine.existCommand(EDApplication.VERSION_PARAM_LABEL_2)):
            EDVerbose.setVerboseOn()
            EDVerbose.screen("%s version %s" % (self.__strName, self.__strVersion))
            self.__bIsFailure = True



    def processCommandLinePluginName(self):
        """
        """
        EDVerbose.DEBUG("EDApplication.processCommandLinePluginName")
        if (not self.__edCommandLine.existCommand(EDApplication.PLUGIN_PARAM_LABEL)):
            EDVerbose.error("No %s command line argument found!" % EDApplication.PLUGIN_PARAM_LABEL)
            self.__bIsFailure = True
        else:
            self.__strPluginName = self.getCommandLineArgument(EDApplication.PLUGIN_PARAM_LABEL)
            EDVerbose.DEBUG("EDApplication.processCommandLinePluginName : %s = %s" % (EDApplication.PLUGIN_PARAM_LABEL, self.__strPluginName))


    def processCommandLineInputFilePath(self):
        """
        """
        EDVerbose.DEBUG("EDApplication.processCommandLineInputFilePath")
        if (not self.__edCommandLine.existCommand(EDApplication.DATASET_PARAM_LABEL)):
            EDVerbose.error("No %s command line argument found!" % EDApplication.DATASET_PARAM_LABEL)
            self.__bIsFailure = True
        else:
            self.__strDataInputFilePath = self.getCommandLineArgument(EDApplication.DATASET_PARAM_LABEL)
            EDVerbose.DEBUG("EDApplication.initApplication : %s = %s" % (EDApplication.DATASET_PARAM_LABEL, self.__strDataInputFilePath))


    def processCommandLineOutputFilePath(self):
        """
        """
        EDVerbose.DEBUG("EDApplication.processCommandLineOutputFilePath")
        if (not self.__edCommandLine.existCommand(EDApplication.OUTPUT_PARAM_LABEL)):
            EDVerbose.DEBUG("No %s command line argument found" % EDApplication.OUTPUT_PARAM_LABEL)
        else:
            self.__strDataOutputFilePath = self.getCommandLineArgument(EDApplication.OUTPUT_PARAM_LABEL)
            EDVerbose.DEBUG("EDApplication.initApplication : %s = %s" % (EDApplication.OUTPUT_PARAM_LABEL, self.__strDataOutputFilePath))


    def processCommandLineBaseDirectory(self):
        """
        """
        EDVerbose.DEBUG("EDApplication.processCommandLineBaseDirectory")
        self.__strBaseDir = self.getCommandLineArgument(EDApplication.DATASET_BASE_DIRECTORY)
        if(self.__strBaseDir is None):
            self.__strBaseDir = os.getcwd()
            EDVerbose.DEBUG("Base directory set to current working directory = %s" % (self.__strBaseDir))
        else:
            EDVerbose.DEBUG("%s = %s" % (EDApplication.DATASET_BASE_DIRECTORY, self.__strBaseDir))





    def postProcess(self):
        """
        """
        # Restore the current working directory 
        os.chdir(self.__strCurrentWorkingDirectory)


    @classmethod
    def usage(cls):
        """
        Print usage...
        """
        EDVerbose.screen("")
        EDVerbose.screen("Usage: ")
        EDVerbose.screen("")
        EDVerbose.screen("%35s : Name of the plugin to be executed" % (cls.PLUGIN_PARAM_LABEL))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : Path to the XML input file" % (cls.DATASET_PARAM_LABEL))
        EDVerbose.screen("")
        EDVerbose.screen("-----------------------------------------------------------------------------------------------------------")
        EDVerbose.screen("")
        EDVerbose.screen(" Additional options available:")
        EDVerbose.screen("")
        EDVerbose.screen("%35s : Path to the file wich will contain the XML output" % (cls.OUTPUT_PARAM_LABEL))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : Base directory, i.e. working directory for the application" % (cls.DATASET_BASE_DIRECTORY))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : Verbose mode" % (cls.VERBOSE_MODE_LABEL))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : XSConfiguration file" % (cls.CONFIGURATION_PARAM_LABEL))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : Executable version info" % (cls.VERSION_PARAM_LABEL_1 + " or " + cls.VERSION_PARAM_LABEL_2))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : DEBUG log traces" % (cls.DEBUG_PARAM_LABEL_1 + " or " + cls.DEBUG_PARAM_LABEL_2))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : No log file" % (cls.NO_LOG_LABEL))
        EDVerbose.screen("")
        EDVerbose.screen("%35s : This help message" % (cls.HELP_LABEL_1 + " or " + cls.HELP_LABEL_2))
        EDVerbose.screen("")


    @classmethod
    def getFactoryPlugin(cls):
        EDVerbose.WARNING("the use of EDclsetFactoryPlugin is deprecated. Please use EDFactoryPluginStatic.getFactoryPlugin instead.")
        return EDFactoryPluginStatic.getFactoryPlugin


    @classmethod
    def loadPlugin(cls, _strPluginName):
        EDVerbose.WARNING("The use of EDApplication.loadPlugin is deprecated. Please use EDFactoryPluginStatic.getFactoryPlugin instead.")
        return EDFactoryPluginStatic.loadPlugin(_strPluginName)


    @classmethod
    def loadModule(cls, _strModuleName):
        EDVerbose.WARNING("The use of EDApplication.loadModule is deprecated. Please use EDFactoryPluginStatic.getFactoryPlugin instead.")
        EDFactoryPluginStatic.loadModule(_strModuleName)


    def getDataInputFilePath(self):
        return self.__strDataInputFilePath


    def getBaseDir(self):
        """
        Getter for base directory
        @return: path of the base directory
        @rtype: string
        """
        return self.__strBaseDir


    def createApplicationWorkingDirectory(self):
        """
        Created the working directory of the application (<date>-<application name>)
        First tries to retrieve the base dir from --basedir option or related parameter from constructor
        Otherwise tries to retrieve it from EDNA_BASE_DIRECTORY environment variable
        Otherwise put the base dir as the current directory
        """
        EDVerbose.DEBUG("EDApplication.createApplicationWorkingDirectory")
        strBaseDirectory = self.getBaseDir()
        strDateTime = time.strftime("%Y%m%d-%H%M%S", time.localtime(time.time()))
        self.__strFullApplicationWorkingDirectory = os.path.join(strBaseDirectory, self.__strWorkingDir)
        # Check that a folder / file with the same name already exists
        if(os.path.exists(self.__strFullApplicationWorkingDirectory) or \
            os.path.exists(self.__strFullApplicationWorkingDirectory)):
            # It does exist so we have to modify the name of the working directory
            iIndex = 1
            bContinueFlag = True
            while (bContinueFlag):
                self.__strFullApplicationWorkingDirectory = os.path.join(strBaseDirectory,
                                                                                        "%s_%d" % \
                                                                                        (strDateTime, \
                                                                                          iIndex))
                if(os.path.isdir(self.__strFullApplicationWorkingDirectory) or \
                    os.path.exists(self.__strFullApplicationWorkingDirectory)):
                    iIndex += 1
                else:
                    bContinueFlag = False
        # Make the directory
        os.mkdir(self.__strFullApplicationWorkingDirectory)
        # Change it to be the current working directory
        os.chdir(self.__strFullApplicationWorkingDirectory)


    def getFullApplicationWorkingDirectory(self):
        return self.__strFullApplicationWorkingDirectory

    def getCurrentWorkingDirectory(self):
        return self.__strCurrentWorkingDirectory


    def doSuccessActionPlugin(self, _edPlugin):
        """
        """
        EDVerbose.DEBUG("EDApplication.doSuccessActionPlugin")
        # Print the potential Warnings and Errors
        self.__listWarningMessages = _edPlugin.getListOfWarningMessages()
        EDVerbose.DEBUG("EDApplication.doSuccessActionPlugin: Plugin %s Successful with : %i Warnings " % (_edPlugin.getPluginName(), len(self.__listWarningMessages)))
        for warningMessage in self.__listWarningMessages:
            EDVerbose.screen(warningMessage)
        self.__listErrorMessages = _edPlugin.getListOfErrorMessages()
        EDVerbose.DEBUG("EDApplication.doSuccessActionPlugin: Plugin %s Successful with : %i Errors" % (_edPlugin.getPluginName(), len(self.__listErrorMessages)))
        for errorMessage in self.__listErrorMessages:
            EDVerbose.error(errorMessage)
        if (_edPlugin.hasDataOutput()):
            xsDataOutput = _edPlugin.getDataOutput()
            if (xsDataOutput is not None and self.__strDataOutputFilePath is not None):
                xsDataOutput.exportToFile(self.__strDataOutputFilePath)
            if (xsDataOutput is not None and self.__edObtainedOutputDataFile is not None):
                xsDataOutput.exportToFile(self.__edObtainedOutputDataFile)


    def doFailureActionPlugin(self, _edPlugin):
        EDVerbose.DEBUG("EDApplication.doFailureActionPlugin")

        # Print the potential Warnings and Errors
        EDVerbose.DEBUG("EDApplication.doFailureActionPlugin: Plugin %s failed" % _edPlugin.getClassName())
        self.__listWarningMessages = _edPlugin.getListOfWarningMessages()
        for warningMessage in self.__listWarningMessages:
            EDVerbose.screen(warningMessage)

        self.__listErrorMessages = _edPlugin.getListOfErrorMessages()
        for errorMessage in self.__listErrorMessages:
            EDVerbose.screen(errorMessage)
        if (_edPlugin.hasDataOutput()):
            xsDataOutput = _edPlugin.getDataOutput()
            if (xsDataOutput is not None and self.__strDataOutputFilePath is not None):
                xsDataOutput.exportToFile(self.__strDataOutputFilePath)
            if (xsDataOutput is not None and self.__edObtainedOutputDataFile is not None):
                xsDataOutput.exportToFile(self.__edObtainedOutputDataFile)


    def getPlugin(self):
        return self.__edPlugin


    def getPluginOutputData(self):
        return self.__xsDataOutput


    def getWarningMessages(self):
        return self.__listWarningMessages


    def getErrorMessages(self):
        return self.__listErrorMessages


    def getEdCommandLine(self):
        return self.__edCommandLine


    def getCommandLine(self):
        return self.__edCommandLine.getCommandLine()


    def getCommandLineArguments(self):
        with self.__class__.__semaphore:
            edCommandLine = self.__edCommandLine.getCommandLine()
        return edCommandLine

    def getCommandLineArgument(self, _strKey):
        with self.__class__.__semaphore:
            strCommandLineArgument = self.__edCommandLine.getArgument(_strKey)
        return strCommandLineArgument

    @classmethod
    def synchronizeOn(cls):
        """
        Lock the whole class
        """
        cls.__semaphore.acquire()


    @classmethod
    def synchronizeOff(cls):
        """
        Unlock the whole class
        """
        cls.__semaphore.release()


    def getApplicationName(self):
        return self.__strName + "-" + self.__strVersion


    def getWorkingDir(self):
        """
        Getter for working dir
        @rtype: string
        @return working dir 
        """
        return self.__strWorkingDir


    def setWorkingDir(self, _strDir):
        """
        Setter for working dir
        @type _strDir: string
        @param _strDir: working dir 
        """
        self.__strWorkingDir = _strDir


    def isFailure(self):
        return self.__bIsFailure


    def setFailure(self, _bFailure):
        self.__bIsFailure = _bFailure


    def getPluginName(self):
        return self.__strPluginName