Adding New/Updated Automation Files

5 files changed, 966 insertions, 0 deletions

diff --git a/SharedModules/Globals/atfglobals.py b/SharedModules/Globals/atfglobals.py
new file mode 100644
index 0000000..ff1faad
--- /dev/null
+++ b/SharedModules/Globals/atfglobals.py
@@ -0,0 +1,85 @@
+"""atfglobals module contain AtfGlobal class and GlobalObj
+
+AtfGlobals class wrapps all global objects used in the framework
+*) TestrunInfo
+*) Logger
+*) Testenv
+*) ConnectionsManager
+
+GlobalObj is 'The Instance' of AtfGlobals which will be referred throughout
+the framework utilities. 
+"""
+
+import testruninfo
+import logger
+import testenv
+import manager
+
+class AtfGlobals:
+
+    
+    def __init__(self):
+        self._testruninfo = None
+        self._logger = logger.Log()
+        self._env = None
+        self._connectionsmanager = manager.ConnectionsManager()
+
+    def getTestrunInfoObj(self):
+        """Returns TestrunInfo Object
+        """
+        return self._testruninfo
+
+    def getLoggerObj(self):
+        """Returns Logger Object
+        """
+        return self._logger
+    
+    def getTestenvObj(self):
+        """Returns Current TestEnvironment Object.
+        """
+        return self._env
+
+    def getConnectionsManagerObj(self):
+        """Returns ConnectionsManager Object
+        """
+        return self._connectionsmanager
+
+    def initTestrunInfoObj(self):
+        """Instantiation of TestrunInfo Object
+        """
+        self._testruninfo = testruninfo.TestRunInfo()
+        
+    def initLoggerObj(self):
+        """Instantiation of Logger Object
+        """
+        self._logger = logger.Log()
+        
+    def initTestenvObj(self):
+        """Instantiation of Testenv Object
+        """
+        self._env = testenv.TestEnv()
+
+    def initConnectionsManagerObj(self):
+        """Instantiation of ConnectionsManager Object
+        """
+        self._connectionsmanager = manager.ConnectionsManager()
+
+GlobalObj = AtfGlobals()
+__all__ = ['GlobalObj']
+
+
+
+
+
+
+        
+        
+
+
+
+    
+
+
+
+    
+        
diff --git a/SharedModules/Globals/logger.py b/SharedModules/Globals/logger.py
new file mode 100644
index 0000000..9d11bd7
--- /dev/null
+++ b/SharedModules/Globals/logger.py
@@ -0,0 +1,211 @@
+"""
+ logger class contains variables and methods for Logging 
+ the events during the test run.
+
+ Variables:
+      SummaryLog: [filename, loglevel, format]
+
+      DetailLog: [filename, loglevel, format]
+
+      StdoutLog: [loglevel, format]
+
+"""
+import logging
+
+class Log():
+
+    def __init__(self):
+        self._summarylog = {'format':
+                '%(asctime)s %(levelname)s  : %(filename)s %(lineno)d  - \
+                \'%(message)s\''}
+        self._detaillog = {'format': 
+                '%(asctime)s %(levelname)s  : %(pathname)s %(funcName)s \
+                %(lineno)d - \'%(message)s\''}
+        self._stdoutlog = {'logstatus':'false', 'format':'%(asctime)s \
+                %(levelname)s : %(filename)s %(lineno)d - \'%(message)s\''}
+        self._loggers = []
+
+
+    def getLogLevel(self, loglevel):
+        """
+        Description:
+            Returns logging.(LogLevel)  for loglevel
+
+        Parameters:
+            loglevel: String specifying the loglevel
+
+        Returns:
+            logging.(Loglevel) 
+        """
+
+        LEVELS = {'DEBUG': logging.DEBUG,
+                  'INFO': logging.INFO,
+                  'WARNING': logging.WARNING,
+                  'ERROR': logging.ERROR,
+                  'CRITICAL': logging.CRITICAL,
+                  'debug': logging.DEBUG,
+                  'info': logging.INFO,
+                  'warning': logging.WARNING,
+                  'error': logging.ERROR,
+                  'critical': logging.CRITICAL}
+        return LEVELS.get(loglevel, logging.NOTSET)
+        
+    def setSummaryLog(self, filename='SummaryLog.out', loglevel='INFO'):
+        """
+        Description:
+            Set Summary Log Name and Log Level
+
+        Parameters:
+            filename: SummaryLog File Name
+            loglevel : Log level to be set for summary log
+        """
+
+        self._summarylog['filename'] = filename
+        self._summarylog['loglevel'] = self.getLogLevel(loglevel)
+
+    def setDetailLog(self, filename='DetailLog.out', loglevel = 'DEBUG'):
+        """
+        Description:
+            Set Detail Log Name and Log Level
+
+        Parameters:
+            filename: DetailLog FIle name
+            loglevel: Log level to be set for detail log
+        """
+        
+        self._detaillog['filename'] = filename
+        self._detaillog['loglevel'] = self.getLogLevel(loglevel)
+
+    def setStdoutLog(self, do_log=True, loglevel='INFO'):
+        """
+        Description:
+            Set Log Level for  logging to STDOUT
+
+        Parameters:
+            loglevel: Log level for logging to STDOUT
+        """
+        self._stdoutlog['do_log'] = do_log
+        self._stdoutlog['loglevel'] = self.getLogLevel(loglevel)
+    
+    def createLogger(self, atfdir, logname='ATFLOG'):
+        """
+        Description:
+            Create a Logger with LogName 'logname'
+            
+        Parameters:
+            logname: Name of the Logger
+
+        Return:
+            Success: 0 (Successful creation of logger with name : 'logname')
+            Failure: 1 (Unable to create logger with name: logname)
+        """
+
+        # Create a Logger Object with name "logname".
+        # Set the log level to 'DEBUG'
+        logger = logging.getLogger(logname)
+        logger.setLevel(logging.DEBUG)
+        self.loggers.append({'logname': logname})
+
+        # Create Summary Log File Handler
+        # Set the Log Level
+        # Set the Log Record format for Summary Log
+        summarylog_abspath = atfdir + "/" + self._summarylog['filename']
+        try:
+            summary_handler = logging.FileHandler(summarylog_abspath, mode='w')
+
+        except IOError as (errno, errstr):
+            print "I/0 error({0}): {1}".format(errno, errstr)
+            return 1
+
+        else:
+            summary_formatter = logging.Formatter(self._summarylog['format'])
+            summary_handler.setFormatter(summary_formatter)
+            summary_handler.setLevel(self._summarylog['loglevel'])
+            logger.addHandler(summary_handler)
+            for log in self._loggers:
+                if log['logname'] == logname:
+                    log['summary_handler'] = summary_handler
+                    break
+                
+        # Create Stdout Log StreamHandler if log to stdout is defined
+        # Set the Log Level
+        # Set the Log Record format for STDOUT
+        if self._stdoutlog['do_log'] == 'true':
+            stdout_handler = logging.StreamHandler()
+            stdout_handler.setLevel(self._stdoutlog['loglevel'])
+            stdout_formatter = logging.Formatter(self._stdoutlog['format'])
+            stdout_handler.setFormatter(stdout_formatter)
+            logger.addHandler(stdout_handler)
+            for log in self._loggers:
+                if log['logname'] == logname:
+                    log['stdout_handler'] = stdout_handler
+                    break
+        return 0
+
+    def addDetaillogHandler(self, abspath, logname):
+        """
+        Description:
+            Add a Detail Log FileHandler to Logger with logname 'logname'
+
+        Parameters:
+            logname: Name of the Logger
+
+        Returns:
+            Success: 0
+            Failure: 1
+        """
+
+        logger = logging.getLogger(logname)
+
+        # Create Detail Log File Handler
+        # Set the Log Level
+        # Set the Log Record format for Detail Log
+        abspath = abspath + self._detaillog['filename']
+
+        try:
+            detail_handler = logging.FileHandler(abspath, mode='w')
+
+        except IOError as (errno, errstr):
+            logger.error("IOError ({0}): {1}".format(errno, errstr))
+            return 1
+
+        else:
+            detail_handler.setLevel(self._detaillog['loglevel'])
+            detail_formatter = logging.Formatter(self._detaillog['format'])
+            detail_handler.setFormatter(detail_formatter)
+            logger.addHandler(detail_handler)
+            
+            for log in self._loggers:
+                if log['logname'] == logname:
+                    log['detail_handler'] = detail_handler
+                    break
+
+        logger.debug("Detail Log File Handler Successfully Added")
+            
+        return 0
+
+    def removeDetaillogHandler(self, logname):
+        """
+        Description:
+            Remove Detail Log File Handler from Logger with 
+            logname 'logname'
+
+        Parameters:
+            logname: Name of the Logger
+        """
+
+        logger = logging.getLogger(logname)
+        Map = {}
+        for log in self._loggers:
+            Map = log
+        
+            if Map.has_key('detail_handler'):
+                detail_handler = log.pop('detail_handler')
+                logger.removeHandler(detail_handler)              
+                logger.info("DetailLog Handler Removed for the Logger: " +
+                        logname)        
+            else:
+                logger.warning("DetailLog Handler Not Found for the Logger: " +
+                        logname)
+        return
+    
diff --git a/SharedModules/Globals/manager.py b/SharedModules/Globals/manager.py
new file mode 100755
index 0000000..d73cf15
--- /dev/null
+++ b/SharedModules/Globals/manager.py
@@ -0,0 +1,64 @@
+""" manager module contains:
+
+*) ConnectionsManager Class
+"""
+class ConnectionsManager():
+    """
+    *) Manages Client SSH Connections in the current TestEnvironment
+    *) Manages Server SSH Connections in the current TestEnvironment
+    *) Manages allhosts SSH Connection in the current TestEnvironment
+    """
+    def __init__(self):
+
+        self._serverpool = {}
+        self._clientpool = {}
+        self._all = {}
+
+    def addServer(self, key, server):
+        """
+        Add a server to _serverpool
+        """
+
+        self._serverpool[key] = server
+        self._all[key] = server
+        return
+
+    def addClient(self, key, client):
+        """
+        Add a client to clientpool
+        """
+
+        self._clientpool[key] = client
+        self._all[key] = client
+        return
+
+    def getServers(self):
+        """
+        Return the server object
+        """
+
+        return self._serverpool
+
+    def getClients(self):
+        """
+        Return the client object
+        """
+
+        return self._clientpool
+
+    def getConnection(self, key):
+        """
+        """
+        value = None
+        if self._all.has_key(key):
+            value = self._all[key]
+        return value
+
+    def getConnections(self):
+        """
+        """
+        return self._all
+
+    
+    
+        
diff --git a/SharedModules/Globals/testenv.py b/SharedModules/Globals/testenv.py
new file mode 100755
index 0000000..9aa8ec8
--- /dev/null
+++ b/SharedModules/Globals/testenv.py
@@ -0,0 +1,462 @@
+"""testenv module.
+
+TestEnv Class has attributes which holds information of the current
+testenvironment. It includes information about Servers, Clients, Volume,
+Bricks, MountPoints etc.
+TestEnv Class provides methods to access the testenvironment info
+"""
+
+from collections import namedtuple
+import re
+
+class TestEnv():
+
+    def __init__(self):
+        self._exportdirs = {}
+        self._servers = {}
+        self._bricks = {}
+        self._volumes = {}
+        self._clients = {}
+        self._mountdevices = {}
+        self._mounts = {}
+        self._gluster_download_paths = []
+        self._active_volume = None
+        
+        self._exportdir_tuple = namedtuple('ExportDir',
+                                           ['dir', 'fstype', 'device'])
+
+        self._server_tuple = namedtuple('Server',
+                                        ['hostname', 'user', 'password',
+                                         'glusterversion', 'installpath'])
+
+        self._brick_tuple = namedtuple('Brick',
+                                       ['hostname', 'path'])
+
+        self._volume_tuple = namedtuple('Volume',
+                                        ['volumename', 'volumetype', 'count',
+                                         'transporttype', 'bricks'])
+        
+        self._client_tuple = namedtuple('Client',
+                                        ['hostname', 'user', 'password',
+                                         'glusterversion', 'installpath'])
+
+        self._mountdevice_tuple = namedtuple('MountDevice',
+                                             ['hostname', 'volumename'])
+
+        self._mount_tuple = namedtuple('Mount',
+                                       ['client', 'dir', 'device',
+                                        'type', 'logfile', 'options'])
+
+    def addExportdir(self, key, dir_, **arguments):
+        """
+        """
+        fstype = device = None
+        if (arguments.has_key('fstype') and arguments['fstype']):
+            fstype = arguments['fstype']
+
+        if (arguments.has_key('device') and arguments['device']):
+            device = arguments['device']
+                
+        exportdir_obj = self._exportdir_tuple(dir_, fstype, device)
+        self._exportdirs[key] = exportdir_obj
+
+    def getExportdir(self, exportdirkey):
+        """
+        """
+        exportdir_obj = None
+        if self._exportdirs.has_key(exportdirkey):
+            exportdir_obj = self._exportdirs[exportdirkey]
+
+        return exportdir_obj
+
+    def getExportdirs(self):
+        """Returns self._exportdirs dictionary.
+        'key' in dict is exportdirkey
+        'value' is exportdir namedtuple object
+        """
+
+        return self._exportdirs
+    
+    def addServer(self, key, hostname, user, password,
+                  glusterversion, **arguments):
+        """
+        """
+        installpath = None
+        if (arguments.has_key('installpath') and arguments['installpath']):
+            installpath = arguments['installpath']
+        
+        server_obj = self._server_tuple(hostname, user, password,
+                                        glusterversion, installpath)
+        
+        self._servers[key] = server_obj
+
+    def getServer(self, serverkey):
+        """
+        """
+        server_obj = None
+        if self._servers.has_key(serverkey):
+            server_obj = self._servers[serverkey]
+            
+        return server_obj
+
+    def getServers(self):
+        """
+        """
+        servers = {}
+
+        for serverkey in self._servers.keys():
+            servers[serverkey] = self.getServer(serverkey)
+            
+        return servers
+
+    def addClient(self, key, hostname, user, password,
+                  glusterversion, **arguments):
+        """
+        """
+        installpath = None
+        if arguments.has_key('installpath') and arguments['installpath']:
+            installpath = arguments['installpath']
+            
+        client_obj = self._client_tuple(hostname, user, password,
+                                        glusterversion, installpath)
+        self._clients[key] = client_obj
+
+    def getClient(self, clientkey):
+        """
+        """
+        client_obj = None
+        if self._clients.has_key(clientkey):
+            client_obj = self._clients[clientkey]
+            
+        return client_obj
+
+    def getClients(self):
+        """
+        """
+        clients = {}
+
+        for clientkey in self._clients.keys():
+            clients[clientkey] = self.getClient(clientkey)
+
+        return clients
+        
+    def addBrick(self, key, hostname, path, **arguments):
+        """
+        """
+        brick_obj = self._brick_tuple(hostname, path)
+        self._bricks[key] = brick_obj
+
+    def getBrick(self, brickkey):
+        """
+        """
+        return_brick_obj = None
+        newhostname = newpath = ''
+        
+        if self._bricks.has_key(brickkey):
+            brick_obj = self._bricks[brickkey]
+        else:
+            return return_brick_obj
+
+        hostname_value = brick_obj.hostname
+        serverkey = re.split("\.", hostname_value, maxsplit=1)[0]
+        server_obj = self.getServer(serverkey)
+        if server_obj:
+            newhostname = server_obj.hostname
+        else:
+            return return_brick_obj
+        
+        path_value = brick_obj.path
+        if re.match("^\/", path_value):
+            path = path_value
+        else:
+            exportdir_obj = self.getExportdir(path_value)
+            if exportdir_obj:
+                newpath = exportdir_obj.dir
+            else:
+                brick_obj = None
+                return return_brick_obj
+
+        return_brick_obj = brick_obj._replace(hostname=newhostname,
+                                              path=newpath)
+        
+        return return_brick_obj
+
+    def getBricks(self):
+        """
+        """
+        return_bricks = {}
+
+        for brickkey in self._bricks.keys():
+            return_bricks[brickkey] = self.getBrick(brickkey)
+            
+        return return_bricks
+
+    def getRawBrick(self, brickkey):
+        brick_obj = None
+        if self._bricks.has_key(brickkey):
+            brick_obj = self._bricks[brickkey]
+        return brick_obj
+
+    def getBrickKeys(self):
+        """
+        """
+        brick_keys = []
+        brick_keys.extend(self._bricks.keys())
+        return brick_keys
+
+    def addBricksToVolume(self, volumekey="ActiveVolume", *bricks):
+        """
+        """
+        volume_obj = None
+        if volumekey == "ActiveVolume":
+            volumekey = self._active_volume
+        
+        if not (volumekey and self._volumes.has_key(volumekey)):
+            return 1 
+        
+        volume_obj = self._volumes[volumekey]
+            
+        for brick in bricks:
+            volume_obj.bricks.append(brick)
+            
+        return 0
+
+    def replaceBrickInVolume(self, replace_brick, to_brick,
+                             volumekey="ActiveVolume"):
+        """
+        """
+        volume_obj = None
+        replaced_status = False
+        if volumekey == "ActiveVolume":
+            volumekey = self._active_volume
+        
+        if not (volumekey and self._volumes.has_key(volumekey)):
+            return 1
+
+        volume_obj = self._volumes[volumekey]
+        for index, brick in enumerate(volume_obj.bricks):
+            if brick == replace_brick:
+                volume_obj.bricks[index] = to_brick
+                replaced_status = True
+                break
+            else:
+                continue
+            
+        if replaced_status:
+            return 0
+        else:
+            return 1
+
+    def addVolume(self, key, volumename, volumetype, count,
+                  transporttype, bricks):
+        """
+        """
+        brickskeylist = [x.strip() for x in bricks.split(",")]
+        volume_obj = self._volume_tuple(volumename, volumetype,
+                                        count, transporttype, brickskeylist)
+        self._volumes[key] = volume_obj
+
+    def getVolume(self, volumekey):
+        """
+        """
+        return_volume_obj = None
+
+        if not self._volumes.has_key(volumekey):
+            return return_volume_obj
+        
+        volume_obj = self._volumes[volumekey]
+        brickslist = []
+        for brickkey in volume_obj.bricks:
+            brick_obj = self.getBrick(brickkey)
+            if not brick_obj:
+                return return_volume_obj
+            else:
+                brickslist.append(brick_obj)
+
+        return_volume_obj = volume_obj._replace(bricks=brickslist)
+                                                
+        return return_volume_obj
+
+    def getVolumes(self):
+        """
+        """
+        return_volumes = {}
+        for volumekey in self._volumes.keys():
+            return_volumes[volumekey] = self.getVolume(volumekey)
+
+        return return_volumes
+
+    def addMountDevice(self, key, hostname, volumename):
+        """
+        """
+        mountdevice_obj = self._mountdevice_tuple(hostname, volumename)
+        self._mountdevices[key] = mountdevice_obj
+
+    def getMountDevice(self, mountdevicekey):
+        """
+        *) Check the hostname = IPAddress
+        *) Check hostname refers to any server
+        *) Check the volume is defined.
+        *) Substitute all values
+        """
+        returndevice_obj = None
+        ip_pattern = re.compile('(?:[\d]{1,3})\.(?:[\d]{1,3})\.(?:[\d]{1,3})\.(?:[\d]{1,3})')
+        
+        if not self._mountdevices.has_key(mountdevicekey):
+            return returndevice_obj
+        
+        else:
+            mountdevice_obj = self._mountdevices[mountdevicekey]
+            
+            hostname_value = mountdevice_obj.hostname
+            if ip_pattern.match(hostname_value):
+                newhostname = hostname_value
+            elif re.match('(([a-z]|[A-Z])+[0-9]+)\.hostname', hostname_value):
+                serverkey = re.split("\.", hostname_value, maxsplit=1)[0]
+                server_obj = self.getServer(serverkey)
+                if server_obj:
+                    newhostname = server_obj.hostname
+                else:
+                    return returndevice_obj
+            else:
+                newhostname = hostname_value
+            volumekey = re.split("\.", mountdevice_obj.volumename, maxsplit=1)[0]
+            volume_obj = self.getVolume(volumekey)
+            if volume_obj:
+                newvolumename = volume_obj.volumename
+            else:
+                return returndevice_obj
+            
+
+            returndevice_obj = mountdevice_obj._replace(hostname=newhostname,
+                                                        volumename=newvolumename)
+            return returndevice_obj
+
+    def getMountDevices(self):
+        """
+        """
+        return_mount_devices = {}
+
+        for mountdevicekey in self._mountdevices.keys():
+            return_mount_devices[mountdevicekey] = self.getMountDevice(mountdevicekey)
+
+        return return_mount_devices            
+        
+    def addMount(self, key, client, dir_, device, **arguments):
+        """
+        """
+        logfile = options = None
+        type_ = "glusterfs"
+
+        if (arguments.has_key("type") and arguments['type']):
+            type_ = arguments['type']
+
+        if (arguments.has_key("logfile") and arguments['logfile']):
+            logfile = arguments['logfile']
+
+        if (arguments.has_key("options") and arguments['options']):
+            options = arguments['options']
+            
+        mount_obj = self._mount_tuple(client, dir_, device,
+                                      type_, logfile, options)
+        self._mounts[key] = mount_obj
+        
+    def getMount(self, mountkey):
+        """
+        """
+        return_mount_obj = None
+        if not self._mounts.has_key(mountkey):
+            return return_mount_obj
+        
+        mount_obj = self._mounts[mountkey]
+        devicekey = mount_obj.device
+        device_obj = self.getMountDevice(devicekey)
+        if not device_obj:
+            return return_mount_obj
+        else:
+            return_mount_obj = mount_obj._replace(device=device_obj)
+
+        return return_mount_obj
+
+    def getMounts(self):
+        """
+        """
+        return_mounts = {}
+
+        for mountkey in self._mounts.keys():
+            return_mounts[mountkey] = self.getMount(mountkey)
+
+        return return_mounts
+
+    def getMountsKeys(self):
+        """
+        """
+        mounts_keys = []
+        mounts_keys.extend(self._mounts.keys())
+        return mounts_keys
+    
+    def addDefaults(self, **arguments):
+        """
+        """
+        downloadpaths = []
+            
+        if (arguments.has_key('downloadpath') and arguments['downloadpath']):
+            paths = arguments['downloadpath']
+            downloadpaths = [x.strip() for x in paths.split(",")]
+        
+        self._gluster_download_paths = downloadpaths
+
+    def setActiveVolume(self, volumekey):
+        """
+        """
+        if self._volumes.has_key(volumekey):
+            self._active_volume = volumekey
+            return 0
+        else:
+            return 1
+
+    def getActiveVolume(self):
+        """
+        """
+        active_volume_key = self._active_volume
+        active_volume = self.getVolume(active_volume_key)
+        return active_volume
+
+    def getGlusterDownloadPaths(self):
+        """
+        """
+        return self._gluster_download_paths
+
+    def getHosts(self):
+        """
+        """
+        all_hosts = {}
+        all_hosts.update(self.getServers)
+        all_hosts.update(self.getClients)
+        return all_hosts
+
+    def getHostsKeys(self):
+        """
+        """
+        hosts_keys = []
+        hosts_keys.extend(self._servers.keys())
+        hosts_keys.extend(self._clients.keys())
+        return hosts_keys
+
+    def getHost(self, hostkey):
+        """
+        """
+        host_obj = None
+        host_obj = self.getServer(hostkey)
+        if host_obj:
+            return host_obj
+        else:
+            host_obj = self.getClient(hostkey)
+            return host_obj
+
+
+        
+        
+        
+        
+
diff --git a/SharedModules/Globals/testruninfo.py b/SharedModules/Globals/testruninfo.py
new file mode 100644
index 0000000..9b012e8
--- /dev/null
+++ b/SharedModules/Globals/testruninfo.py
@@ -0,0 +1,144 @@
+"""testruninfo module
+
+TestRunInfo Class contains variables and methods for storing and retrieving 
+information about current "TestRun". 
+"""
+import re
+
+class TestRunInfo():
+    def __init__(self):
+        self._testunits = []
+        self._keywords = ''
+        self._glusterversion = ''
+        self._atfdir = ''
+        self._summaryloginfo = {}
+        self._detailloginfo = {}
+        self._stdoutloginfo = {}
+
+    def addGlusterVersion(self, version):
+        """
+        """
+        self._glusterversion = version
+
+    def getGlusterVersion(self):
+        """
+        """
+        return self._glusterversion
+    
+    def addSummaryLogInfo(self, filename, loglevel):
+        """
+        """
+        if not filename:
+            filename = "SummaryLog.out"
+
+        if not loglevel:
+            loglevel = "info"
+            
+        self._summaryloginfo['filename'] = filename
+        self._summaryloginfo['loglevel'] = loglevel
+
+    def getSummaryLogInfo(self):
+        """
+        """
+        return self._summaryloginfo
+    
+    def addDetailLogInfo(self, filename, loglevel):
+        """
+        """
+        if not filename:
+            filename = "DetailLog.out"
+
+        if not loglevel:
+            loglevel = "info"
+            
+        self._detailloginfo['filename'] = filename
+        self._detailloginfo['loglevel'] = loglevel
+
+    def getDetailLogInfo(self):
+        """
+        """
+        return self._detailloginfo
+        
+    def addStdoutLogInfo(self, do_log, loglevel):
+        """
+        """
+        true_pattern = re.compile('True|Yes', re.IGNORECASE)
+        false_pattern = re.compile('False|No', re.IGNORECASE)
+    
+        if not loglevel:
+            loglevel = "info"
+
+        if true_pattern.match(do_log):
+            do_log = True
+
+        elif false_pattern.match(do_log):
+            do_log = False
+
+        else:
+            do_log = True
+            
+        self._stdoutloginfo['do_log'] = do_log
+        self._stdoutloginfo['loglevel'] = loglevel
+
+    def getStdoutLogInfo(self):
+        """
+        """
+        return self._stdoutloginfo
+
+    def addAtfDir(self, atfdir):
+        """
+        """
+        self._atfdir = atfdir
+
+    def getAtfDir(self):
+        """
+        """       
+        return self._atfdir
+    
+    def addTestUnits(self, testunit):
+        """
+        Description:
+            Add a testunit to TestUnits List
+
+        Parameter:
+            testunit: Name of the Testing Unit
+
+        Returns:
+        """
+
+        self._testunits.append(testunit)
+        return
+
+    def getTestUnits(self):
+        """
+        Description:
+            Return TestUnits List
+
+        Parameters:
+
+        Returns:
+            Success: Testunit Name
+            Failure: ''
+        """
+
+        return self._testunits
+    
+    def addKeywords(self, keywords):
+        """
+        Description:
+            Add Keywords to KeyWords List
+
+        Parameters:
+            keyname: Keyword
+
+        Returns:
+        """
+        self._keywords = keywords
+
+    def getKeywords(self):
+        """
+        """
+        return self._keywords
+    
+    
+