Renaming Directories

13 files changed, 0 insertions, 2660 deletions

diff --git a/SharedModules/Connect/ssh.py b/SharedModules/Connect/ssh.py
deleted file mode 100755
index a9952bb..0000000
--- a/SharedModules/Connect/ssh.py
+++ /dev/null
@@ -1,114 +0,0 @@
-"""
- sshConnection Class for connecting and performing operation on
- remote server using SSH Protocol.
-"""
-import paramiko
-import pdb
-import time
-
-class SshConnection():
-    
-    def __init__(self):
-        self._connection = None 
-        self._connection = paramiko.SSHClient()
-
-    def connect(self, host, user=None, password=None):
-        """
-        Objective:
-            SSH to Server "host" as User "user"
-
-        Parameter:
-            host: Server IP Address 
-            user: Login Username
-            password: Login password
-
-        Return:
-            Success: 0
-            Failure: 1
-        """  
-        self._connection.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-        if user == None:
-            user = "root"
-
-        if password == None:
-            password = "syst3m"
-
-        try:
-            self._connection.connect(host, username=user, password=password)
-
-        except paramiko.BadHostKeyException as result:
-            print(
-                "BadHostKeyException: Unable to Connect to Server: '" + host + 
-                "' as User: '" + user + "'")
-            return 1
-
-        except paramiko.AuthenticationException:
-            print("AuthenticationException: Unable to Authenticate "
-                            + user + "@" + host)
-            return 1
-
-        except paramiko.SSHException:
-            print("SSHException: Unknown server " + host)
-            return 1      
-
-        return 0
-
-    def close(self):
-        """
-        Objective:
-            Close SSH Connections 
-        """
-        self._connection.close()
-        return 
-
-    def executecommand(self, command, commandInput=None):
-        """
-        Objective:
-            Execute Command "comamnd" 
-
-        Parameters:
-            command: command to execute
-
-        Return:
-            Success: 0
-            Failure: 1
-        """
-        output = {}
-        output["exitstatus"] = None
-        output["stdoutdata"] = None
-        output["stderrdata"] = None
-        exit_status_ready_flag = True
-                        
-        try:
-            transport = self._connection.get_transport()
-            channel = transport.open_session()
-            channel.exec_command(command)
-            # Adding sleep to get the correct exit_status.
-            time.sleep(5)
-            exit_status_ready_flag = channel.exit_status_ready()
-            if not exit_status_ready_flag:
-                stdin = channel.makefile("wb")
-
-                if commandInput:
-                    stdin.write(commandInput)
-                else:
-                    print "This command requirs Command Input \
-                            after executing comamnd for command completion"
-                    stdin.write("\n")
-                    return output
-                
-            stdout = channel.makefile("rb")
-            stderr = channel.makefile_stderr("rb")
-            exit_status = channel.recv_exit_status()
-
-            output["exitstatus"] = exit_status
-            output["stdoutdata"] = stdout.readlines()
-            output["stderrdata"] = stderr.readlines()
-
-        except paramiko.SSHException:
-            print("Unable to Execute Command: " + command)
-
-        return output
-    
-        
diff --git a/SharedModules/Globals/atfglobals.py b/SharedModules/Globals/atfglobals.py
deleted file mode 100644
index ff1faad..0000000
--- a/SharedModules/Globals/atfglobals.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""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
deleted file mode 100644
index 9d11bd7..0000000
--- a/SharedModules/Globals/logger.py
+++ /dev/null
@@ -1,211 +0,0 @@
-"""
- 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
deleted file mode 100755
index d73cf15..0000000
--- a/SharedModules/Globals/manager.py
+++ /dev/null
@@ -1,64 +0,0 @@
-""" 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
deleted file mode 100755
index 9aa8ec8..0000000
--- a/SharedModules/Globals/testenv.py
+++ /dev/null
@@ -1,462 +0,0 @@
-"""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
deleted file mode 100644
index 9b012e8..0000000
--- a/SharedModules/Globals/testruninfo.py
+++ /dev/null
@@ -1,144 +0,0 @@
-"""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
-    
-    
-    
diff --git a/SharedModules/Parser/parser.py b/SharedModules/Parser/parser.py
deleted file mode 100644
index ee3a2d1..0000000
--- a/SharedModules/Parser/parser.py
+++ /dev/null
@@ -1,315 +0,0 @@
-""" Parser module contains parsers for parsing:
-*) TestrunInfo file
-*) TestEnvironment file
-*) Testcaselist file. 
-"""
-
-import ConfigParser
-import re
-from collections import OrderedDict
-import os
-from atfglobals import GlobalObj
-
-
-def verify_necessary_options(cp, section, necessary_options):
-    """Helper function for all parsers to verify necessary options
-    in a section of the config file.
-
-    Parameters:
-        cp : Config Parser Object
-        section: name of the section in ConfigFile
-        necessary_options: Options necessary under Section 'section'
-
-    Returns:
-        Success: True (if all necessary_options are found in 'section')
-        Failure: False ( if any of the necessaty_options not found in 'section')
-    """
-    all_options_found = True
-    items = dict(cp.items(section))
-    for option in necessary_options:
-        if not (items.has_key(option) and items[option]):
-            print "' %s ' Should be defined in Section: %s" % (option, section)
-            all_options_found = False
-    return all_options_found
-        
-
-def parse_testrun_info_file(filename):
-    """
-    Parse TestrunInfo File
-    """
-    GlobalObj.initTestrunInfoObj()
-    testruninfo_obj = GlobalObj.getTestrunInfoObj()
-    cp = ConfigParser.SafeConfigParser()
-    necessary_sections = ["keywords", "testunits", "atfdir",
-                          "summarylog","detaillog", "stdoutlog",
-                          "glusterversion"]
-    matched_sections = []
-    unmatched_sections = []
-
-    if not cp.read(filename):
-        print "Error reading file ' %s '.File  Not found " % filename
-        return 1
-    else:
-        available_sections = cp.sections()
-        found_all_sections = True
-        for section in necessary_sections:
-            matched_obj = re.search(section, str(available_sections),
-                                    re.IGNORECASE)
-            if not matched_obj:
-                found_all_sections = False
-                unmatched_sections.append(section)
-            else:
-                matched_sections.append(matched_obj.group(0))
-                
-        if not found_all_sections:
-            for section in unmatched_sections:
-                print "Section %s Not Found" % section
-            print "Please define the above sections in TestRunInfo File"
-            return 1
-        
-        else:
-            for section in matched_sections:
-                Map = {}
-                if re.match("keywords", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    testruninfo_obj.addKeywords(Map['keywords'])
-                        
-                elif re.match("testunits", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    testunits = Map.values()
-                    for testunit in testunits:
-                        if testunit:
-                            testruninfo_obj.addTestUnits(testunit)
-
-                elif re.match("atfdir", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    atfdir = Map['dir']
-                    if not atfdir:
-                        print "dir option not defined in ATFDir. " + \
-                              "The 'dir'option should be defined"
-                        return 1
-                    else:
-                        testruninfo_obj.addAtfDir(atfdir)
-
-                elif re.match("summarylog", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    testruninfo_obj.addSummaryLogInfo(Map['filename'],
-                                                      Map['loglevel'])
-
-                elif re.match("detaillog", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    testruninfo_obj.addDetailLogInfo(Map['filename'],
-                                                      Map['loglevel'])
-
-                elif re.match("stdoutlog", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    testruninfo_obj.addStdoutLogInfo(Map['do_log'],
-                                                      Map['loglevel'])
-
-                elif re.match("glusterversion", section, re.IGNORECASE):
-                    Map = dict(cp.items(section))
-                    glusterversion = Map['version']
-                    if not glusterversion:
-                        print "version option not defined in GlusterVersion. " + \
-                        "The 'version' option should be defined"
-                        return 1
-                    else:
-                        testruninfo_obj.addGlusterVersion(glusterversion)
-
-            return 0
-
-def parse_testcaseslist_file(filename):
-    """
-    Parse TestCasesList file
-    """
-    return_status = 1
-    testcaseslist = []
-    if not os.path.exists(filename):
-        print "%s file not found." % filename
-        return return_status
-
-    testruninfo_obj = GlobalObj.getTestrunInfoObj()
-    glusterversion = testruninfo_obj.getGlusterVersion()
-
-    testcaseslistfile = open(filename, "r")
-    filedata = testcaseslistfile.readlines()
-
-    testcaseslist = []
-    for data in filedata:
-        if (not data.strip() or re.match("^#", data)):
-            continue
-
-        else:
-            testcaseid, version, keyword = (value.strip() for value in
-                                            data.split(':'))
-            testcaseslist.append({'testcaseid':testcaseid, 'version':version,
-                                  'keyword':keyword})
-
-    selected_testcases = []
-    if glusterversion == "master":
-        for testcase in testcaseslist:
-            selected_testcases.append(testcase['testcaseid'])
-        return selected_testcases
-    else:
-        for testcase in testcaseslist:
-            if re.match("^(<|>|=|<=|>=)", testcase['version']):
-                condition, version = (x.strip() for x in
-                                      testcase['version'].split())
-                                 
-                if ((condition == "<=" and glusterversion <= version) or
-                    (condition == ">=" and glusterversion >= version) or
-                    (condition == "<" and glusterversion < version) or
-                    (condition == ">" and glusterversion > version) or
-                    (condition == "=" and glusterversion == version)):
-                    selected_testcases.append(testcase['testcaseid'])
-
-            elif re.search("-", testcaseid['version']):
-                fromversion, toversion = (x.strip() for x in
-                                          testcaseid['version'].split("-"))
-                if (glusterversion >= fromversion and
-                    glusterversion <= toversion):
-                    selected_testcases.append(testcase['testcaseid'])
-
-    return selected_testcases
-                    
-                
-def parse_testenv_configfile(filename):
-    """
-    parse testenv.cfg file
-    """
-    GlobalObj.initTestenvObj()
-    env = GlobalObj.getTestenvObj()
-    cp = ConfigParser.SafeConfigParser(dict_type=OrderedDict)
-    sections_to_functions_mapping = {
-        "export" : "addExportdir",
-        "server" : "addServer",
-        "brick"  : "addBrick",
-        "volume" : "addVolume",
-        "client" : "addClient",
-        "mountdevice" : "addMountDevice",
-        "mount"  : "addMount",
-        "defaults" : "addDefaults"}
-    section_pattern = re.compile('(export|server|brick|volume|client|mountdevice|mount)*')
-    if not cp.read(filename):
-        print "Error reading file ' %s '.File  Not found " % filename
-        return 1
-    else:
-        defaults = dict(cp.defaults())
-        function = getattr(env, "addDefaults")
-        function(**defaults)
-        sections = cp.sections()
-        for section in sections:
-            items = dict(cp.items(section))
-            matched_obj = section_pattern.match((section.lower()))
-            result = matched_obj.group(0)
-            if result is '':
-                continue
-            else:
-                funcname = sections_to_functions_mapping[result]
-                function = getattr(env, funcname)
-                necessary_options = []
-    
-                if re.match('export', result):
-                    necessary_options = ["dir"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        dir_ = items.pop('dir')
-                        function(section, dir_, **items)                  
-                    else:
-                        return 1
-
-                elif re.match('server', result):
-                    necessary_options = ["hostname", "user", "password",
-                                         "glusterversion"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        hostname = items.pop('hostname')
-                        user = items.pop('user')
-                        password = items.pop('password')
-                        glusterversion = items.pop('glusterversion')
-                        function(section, hostname, user, password,
-                                 glusterversion, **items)
-                    else:
-                        return 1
-
-                elif re.match('client', result):
-                    necessary_options = ["hostname", "user", "password",
-                                         "glusterversion"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        hostname = items.pop('hostname')
-                        user = items.pop('user')
-                        password = items.pop('password')
-                        glusterversion = items.pop('glusterversion')
-                        function(section, hostname, user, password,
-                                 glusterversion, **items)
-                    else:
-                        return 1                    
-
-                elif re.match('brick', result):
-                    necessary_options = ["hostname", "path"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        hostname = items.pop('hostname')
-                        path = items.pop('path')
-                        function(section, hostname, path, **items)
-                    else:
-                        return 1
-
-                elif re.match('volume', result):
-                    necessary_options = ["volumename", "volumetype",
-                                         "count", "transporttype",
-                                         "bricks"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        volumename = items.pop('volumename')
-                        volumetype = items.pop('volumetype')
-                        count = items.pop('count')
-                        transporttype = items.pop('transporttype')
-                        bricks = items.pop('bricks')
-                        function(section, volumename, volumetype,
-                                 count, transporttype, bricks)
-                    else:
-                        return 1
-
-                elif re.match('mountdevice', result):
-                    necessary_options = ["hostname", "volumename"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        hostname = items.pop('hostname')
-                        volumename = items.pop('volumename')
-                        function(section, hostname, volumename)
-
-                elif re.match('mount', result):
-                    necessary_options = ["client", "dir", "device"]
-                    if verify_necessary_options(cp, section, necessary_options):
-                        client = items.pop('client')
-                        dir_ = items.pop('dir')
-                        device = items.pop('device')
-                        function(section, client, dir_, device, **items)
-
-                    else:
-                        return 1
-    return 0                                          
-                    
-            
-__all__ = ['parse_testrun_info_file',
-           'parse_testcaseslist_file',
-           'parse_testenv_configfile']
-
-        
-            
-            
-        
-
-
-        
-        
-    
-
-    
-    
-
-    
-    
-    
-    
-
-    
-    
-    
-    
diff --git a/SharedModules/Utils/atfutils.py b/SharedModules/Utils/atfutils.py
deleted file mode 100644
index 980c286..0000000
--- a/SharedModules/Utils/atfutils.py
+++ /dev/null
@@ -1,58 +0,0 @@
-"""atfutils module contains  general purpose wrappers
-
-*) assert_success
-*) assert_failure
-*) print-stdout
-*) print_stderr
-*) set_active_volume
-"""
-
-import re
-import ssh
-from atfglobals import GlobalObj
-
-def assert_success(**arguments):
-    """
-    """     
-    if not arguments["exitstatus"]:
-        return 0
-    else:
-        return 1
-
-def assert_failure(**arguments):
-    """
-    """        
-    if arguments["exitstatus"]:
-        return 0
-    else:
-        return 1
-
-def print_stdout(stdoutdata):
-    """
-    """
-    if not stdoutdata == None:
-        for data in stdoutdata:
-            print data
-
-def print_stderr(stderrdata):
-    if not stderrdata == None:
-        for data in stderrdata:
-            print data
-
-def set_active_volume(volumekey):
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    return_status = env.setActiveVolume(volumekey)
-    if return_status:
-        print "Unable to set Active Volume. '%s' Not defined in TestEnvironment"\
-              % volumekey
-    return return_status
-
-
-
-__all__ = ['assert_success',
-           'assert_failure',
-           'print-stdout',
-           'print_stderr',
-           'set_active_volume']
diff --git a/SharedModules/Utils/clientutils.py b/SharedModules/Utils/clientutils.py
deleted file mode 100644
index ad5d593..0000000
--- a/SharedModules/Utils/clientutils.py
+++ /dev/null
@@ -1,282 +0,0 @@
-"""clientutils module contains functions required for performing
-certain operations on client
-
-Supported Wrappers :-
------------
-*) umount
-*) umountall
-*) mount
-*) mountall
-"""
-
-import atfutils
-import hostutils
-from atfglobals import GlobalObj
-
-def umount(mountkey):
-    """unmounts a mountpoint
-
-    Parameters:
-        mountkey : name given to a mount as specified in testenv.cfg file.
-        Ex:-"mount1"
-        
-    Returns:
-        Success : 0
-        Failure : 1`  
-    """
-    base_command = "umount "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    
-    mount_obj = env.getMount(mountkey)
-    if not mount_obj:
-        print "InValid Mount. %s not defined in TestEnvironment" % mountkey
-        return 1
-    
-    clientkey = mount_obj.client
-    client_connection = cm.getConnection(clientkey)
-    if not client_connection:
-        print "SSH connection to host '%s' has not been established" % clientkey
-        return 1
-
-    command = base_command + mount_obj.dir
-    print "%s : %s" % (clientkey, command)
-    output = client_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    if return_status:
-        stdoutdata = str(output["stdoutdata"])
-        if ((stdoutdata.rfind("not found")) or (stdoutdata.rfind("not mount"))):
-            return_status = 0
-
-        else:
-            print "Unable to umount %s" % mountkey
-            
-    return return_status
-
-def umountall():
-    """unmounts all mount specified in testenv.cfg file.
-        Ex:- mount1, mount2 etc
-
-    Parameters:
-        None
-        
-    Returns:
-        Success : 0
-        Failure : 1`  
-    """
-    env = GlobalObj.getTestenvObj()
-    failure_flag = False
-
-    mounts_keys = env.getMountsKeys()
-    for mountkey in mounts_keys:
-        return_status = umount(mountkey)
-        if return_status:
-            failure_flag = True
-
-    if failure_flag:
-        return 1
-    else:
-        return 0
-
-def mount(mountkey):
-    """mounts a filesystem
-
-    Parameters:
-        mountkey : name given to a mount as specified in testenv.cfg file.
-        Ex:-"mount1"
-        
-    Returns:
-        Success : 0
-        Failure : 1`  
-    """
-
-    base_command = command = "mount "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    
-    mount_obj = env.getMount(mountkey)
-    if not mount_obj:
-        print "InValid Mount. %s not defined in TestEnvironment" % mountkey
-        return 1
-    
-    clientkey = mount_obj.client
-    client_connection = cm.getConnection(clientkey)
-    if not client_connection:
-        print "SSH connection to host '%s' has not been established" % clientkey
-        return 1
-
-    mountdevice_obj = mount_obj.device
-    device = mountdevice_obj.hostname + ":/" + mountdevice_obj.volumename
-    options = ["-t", mount_obj.type] 
-    if mount_obj.logfile:
-        options.extend(["-o", ("log-file="+mount_obj.logfile),
-                        "log-level=INFO"])
-
-    if mount_obj.options:
-        options.extend([mount_obj.option])
-
-    options.extend([device, mount_obj.dir])
-    for index, option in enumerate(options):
-        command = command + option + " "
-        
-    return_status = hostutils.mkdir(clientkey, mount_obj.dir)
-    if return_status:
-        return return_status
-
-    print "%s : %s" % (clientkey, command)
-    output = client_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def mountall():
-    """mounts a filesystem for all mounts specified in testenv.cfg file. 
-
-    Parameters:
-        None
-        
-    Returns:
-        Success : 0
-        Failure : 1`  
-    """
-    env = GlobalObj.getTestenvObj()
-
-    mounts_keys = env.getMountsKeys()
-    for mountkey in mounts_keys:
-        return_status = mount(mountkey)
-        if return_status:
-            return return_status
-
-    return 0
-
-
-def execute_on_mount(mountkey, command, commandInput=None):
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    mount_obj = env.getMount(mountkey)
-    if not mount_obj:
-        print "InValid Mount. %s not defined in TestEnvironment" % mountkey
-        return 1
-    
-    clientkey = mount_obj.client
-    mountdir = mount_obj.dir
-    command = "cd " + mountdir + " ;" + command
-    return_status = hostutils.execute_command(clientkey, command, commandInput)
-    return return_status
-    
-__all__ = ['execute_on_mount',
-           'umount',
-           'umountall',
-           'mount',
-           'mountall']
-
-##def umountall(clientkey):
-##    """
-##    """
-##    base_command = "umount "
-##    env = GlobalObj.get_testenv_obj()
-##    cm = GlobalObj.get_connectionsmanager_obj()
-##    client_obj = env.getclient(clientkey)
-##    mountdir = client_obj.mountdir
-##    volume = client_obj.device 
-##    client = cm.getconnection(clientkey)
-##    
-##    mountpoints = []
-##    success_flag = False
-##    failure_flag = False
-##    command = "mount | grep " + mountdir
-##    output = client.executecommand(command)
-##    if not output["exitstatus"]:
-##        for data in output["stdoutdata"]:
-##            mountpoints.append(data.split(" ")[2])
-##
-##        for mountpoint in mountpoints:
-##            command = base_command + mountpoint
-##            output = client.executecommand(command)
-##            return_code = utils.assert_success(**output)
-##            if return_code:
-##                failure_flag = True
-##            else:
-##                success_flag = True
-##                continue
-##
-##        if failure_flag:
-##            return 1
-##
-##    mountpoints = []
-##    success_flag = False
-##    failure_flag = False
-##    command = "mount | grep " + volume
-##    output = client.executecommand(command)
-##    if not output["exitstatus"]:
-##        for data in output["stdoutdata"]:
-##            mountpoints.append(data.split(" ")[2])
-##
-##        for mountpoint in mountpoints:
-##            command = base_command + mountpoint
-##            output = client.executecommand(command)
-##            return_code = utils.assert_success(**output)
-##            if return_code:
-##                failure_flag = True
-##            else:
-##                success_flag = True
-##                continue
-##
-##        if failure_flag:
-##            return 1
-##        
-##    return 0
-
-##def cd_mount(mountkey):
-##    """
-##    """
-##    env = GlobalObj.getTestenvObj()
-##    mount_obj = env.getMount(mountkey)
-##    if not mount_obj:
-##        print "InValid Mount. %s not defined in TestEnvironment" % mountkey
-##        return 1
-##    
-##    clientkey = mount_obj.client
-##    dirpath = mount_obj.dir
-##    return_status = hostutils.cd(clientkey, dirpath)
-##    return return_status
-##
-##def cd_allmounts():
-##    """
-##    """
-##    env = GlobalObj.getTestenvObj()
-##    mounts_keys = env.getMountsKeys()
-##    for mountkey in mounts_keys:
-##        return_status = cd_mount(mountkey)
-##        if return_status:
-##            return return_status
-##
-##    return 0
- 
-    
-
-        
-    
-        
-        
-
-
-
-    
-    
-    
-
-    
-    
-    
-       
-
-    
-    
-
-    
-            
diff --git a/SharedModules/Utils/glusterutils.py b/SharedModules/Utils/glusterutils.py
deleted file mode 100644
index 0c15af1..0000000
--- a/SharedModules/Utils/glusterutils.py
+++ /dev/null
@@ -1,644 +0,0 @@
-"""glusterutils module contains wrappers for gluster commands.
-
-*) glusterd_start
-*) glusterd_start_allservers
-*) glusterd_stop
-*) glusterd_stop_allservers
-*) glusterd_restart
-*) glusterd_remove_dir
-*) glusterd_remove_dir_allservers
-*) glusterd_remove_logs_allservers
-*) volume_delete
-*) volume_create
-*) volume_start
-*) volume_stop
-*) volume_addbrick
-*) volume_replacebrick
-*) volume_set
-*) volume_reset
-*) peer_probe
-*) create_brick
-*) mount_exportdir
-*) umount_exportdir
-"""
-
-import re
-import atfutils
-import hostutils
-from atfglobals import GlobalObj
-
-
-def glusterd_start(serverkey, force=False):
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    commands_to_execute = ["which glusterd", "ps -e | grep glusterd"]
-    gluster_version = env.getServer(serverkey).glusterversion
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    """ Check if gluster is already running. If already Running and force=True,
-    restart glusterd process"""
-    command = commands_to_execute.pop()
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    if not return_status:
-        if force:
-            return_status = glusterd_restart(serverkey)
-            return return_status
-        else:
-            return return_status
-
-    command = commands_to_execute.pop()
-    output = host_connection.executecommand(command)
-    if output["exitstatus"]:
-        print "Unable to start glusterd"
-        return_status = atfutils.assert_success(**output)
-        return return_status
-    else:
-        if output["stdoutdata"]:
-            gluster_path = None
-            gluster_path = output["stdoutdata"][0].strip("\n")
-        else:
-            print "Unable to find gluster path"
-            return_status = atfutils.assert_success(**output)
-            return return_status
-
-        if gluster_path:
-            command = gluster_path + " --version"
-            output = host_connection.executecommand(command)
-            if not output["stdoutdata"] == None:
-                if re.search(gluster_version, str(output["stdoutdata"])):
-                    print "%s : %s" % (serverkey, gluster_path)
-                    output = host_connection.executecommand(gluster_path)
-                    return_status = atfutils.assert_success(**output)
-                    atfutils.print_stdout(output['stdoutdata'])
-                    atfutils.print_stderr(output['stderrdata'])
-                    return return_status
-                else:
-                    print "Unable to start glusterd"
-                    return 1
-        else:
-            print "Unable to start glusterd"
-            return 1
-        
-def glusterd_start_allservers(force=False):
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    all_servers = env.getServers()
-    for serverkey in all_servers.keys():
-        return_status = glusterd_start(serverkey)
-        if return_status:
-            return return_status
-
-    return 0
-
-def glusterd_stop(serverkey):
-    """
-    """
-    base_command = "kill -KILL "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-    
-    gluster_pid_list = []
-    output = host_connection.executecommand("pidof glusterd")
-    return_status = atfutils.assert_failure(**output)
-    if not return_status:
-        return return_status
-
-    else:
-        if output["stdoutdata"]:
-            for output in output["stdoutdata"]:
-                gluster_pid_list.append(output)
-
-            for pid in gluster_pid_list:
-                command = base_command + pid
-                print "%s : %s" % (serverkey, command)
-                output = host_connection.executecommand(command)
-                return_status = atfutils.assert_success(**output)
-                atfutils.print_stdout(output['stdoutdata'])
-                atfutils.print_stderr(output['stderrdata'])
-                if return_status:
-                    break
-
-        return return_status
-    
-def glusterd_stop_allservers():
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    all_servers = env.getServers()
-    for serverkey in all_servers.keys():
-        return_status = glusterd_stop(serverkey)
-        if return_status:
-            return return_status
-
-    return 0
-
-def glusterd_restart(serverkey):
-    """
-    """
-    return_status = glusterd_stop(serverkey)
-    if return_status:
-        return return_status
-    else:
-        return_status = glusterd_start(serverkey)
-        return return_status
-    
-def glusterd_remove_dir(serverkey):
-    """
-    """
-    command = "rm -rf /etc/glusterd/*"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-
-    server_obj = env.getServer(serverkey)
-    if not server_obj:
-        print "Invalid Host. %s not defined in TestEnvironment" % serverkey
-        return 1
-
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = server_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return 0
-
-def glusterd_remove_dir_allservers():
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    all_servers = env.getServers()
-    for serverkey in all_servers.keys():
-        return_status = glusterd_remove_dir(serverkey)
-        
-    return 0
-
-
-def glusterd_remove_logs(serverkey):
-    """
-    """
-    base_command = "rm -rf "
-    log_paths = ["/var/log/glusterfs/*.log", "/var/log/glusterfs/bricks/*"]
-    absolute_path_list = []
-    prefix_path = ''
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-
-    server_obj = env.getServer(serverkey)
-    if not server_obj:
-        print "Invalid Host. %s not defined in TestEnvironment" % serverkey
-        return 1
-
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    if server_obj.installpath:
-        prefix_path = server_obj.installpath
-        
-    for path in log_paths:
-        absolute_path_list.append(prefix_path + path)
-
-    for path in absolute_path_list:
-        command = base_command + path
-        print "%s : %s" % (serverkey, command)
-        output = server_connection.executecommand(command)
-        return_status = atfutils.assert_success(**output)
-        atfutils.print_stdout(output['stdoutdata'])
-        atfutils.print_stderr(output['stderrdata'])
-
-    return 0
-    
-def glusterd_remove_logs_allservers():
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    all_servers = env.getServers()
-    for serverkey in all_servers.keys():
-        return_status = glusterd_remove_logs(serverkey)
-        
-    return 0
-
-def volume_delete(serverkey):
-    """
-    """
-    base_command = "gluster volume delete "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "Invalid Volume.ActiveVolume not defined for the TestEnvironment" 
-        return 1
-    volumename = active_volume.volumename
-    command = base_command + volumename
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_create(serverkey):
-    """
-    """
-    base_command = "gluster volume create "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    
-    command = base_command + \
-              active_volume.volumename + " " + \
-              active_volume.volumetype + " " + \
-              active_volume.count + " " + \
-              "transport " + active_volume.transporttype + " "
-    
-    for brick_obj in active_volume.bricks:
-        brick_value = brick_obj.hostname + ":" + brick_obj.path
-        command = command + brick_value + " "
-        
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    if return_status:
-        if str(output["stdoutdata"]).rfind("already exists"):
-            return_status = 0
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_start(serverkey, force=False):
-    """
-    """
-    base_command = "gluster volume start "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    volumename = active_volume.volumename
-    command = base_command + volumename
-    if force:
-        command = command + " force"
-    
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    if return_status:
-        if str(output["stdoutdata"]).rfind("already started"):
-            return_status = 0
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_stop(serverkey, force=False):
-    """
-    """
-    base_command = "gluster volume stop "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    volumename = active_volume.volumename
-    command = base_command + volumename
-    if force:
-        command = command + " force"
-        
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_addbrick(serverkey, *bricks):
-    """
-    """
-    base_command = "gluster volume add-brick "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    volumename = active_volume.volumenameGlobalObj.getConnectionsManagerObj()
-    command = base_command + volumename + " "
-    for brick in bricks:
-        brick_obj = env.getBrick(brick)
-        if not brick_obj:
-            print "Invalid Brick. Brick Not defined in TestEnvironment"
-            return 1
-        brick_value = brick_obj.hostname + ":" + brick_obj.path
-        command = command + brick_value
-
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    if not return_status:
-        if env.addBricksToVolume(*bricks):
-            return 1
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_replacebrick(serverkey, replacebrick_key, tobrick_key):
-    """
-    """
-    base_command = "gluster volume replace-brick "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    volumename = active_volume.volumename
-    command = base_command + volumename + " "
-    replace_brick = env.getbrick(replacebrick_key)
-    to_brick = env.getbrick(tobrick_key)
-    command = command + replace_brick + " " + to_brick
-    
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    if not return_status:
-        if env.replaceBrickInVolume(replacebrick_key, tobrick_key):
-            return 1
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_set(serverkey, key, value):
-    """
-    """
-    base_command = "gluster volume set "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    volumename = active_volume.volumename
-    command = base_command + volumename + " " + key + " " + value
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def volume_reset(serverkey):
-    """
-    """
-    base_command = "gluster volume reset "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    active_volume = env.getActiveVolume()
-    if not active_volume:
-        print "ActiveVolume not defined for the TestEnvironment"
-        return 1
-    volumename = active_volume.volumename
-    command = base_command + volumename
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (serverkey, command)
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def peer_probe(fromserverkey):
-    """
-    """
-    base_command = "gluster peer probe "
-    command = base_command
-    all_servers = {}
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    all_servers = env.getServers()
-    all_servers.pop(fromserverkey)
-    
-    for key in all_servers.keys():
-        if key is fromserverkey:
-            continue
-        else:
-            server_obj = all_servers[key]
-            command = command + server_obj.hostname + " "
-        
-    host_connection = cm.getConnection(fromserverkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    print "%s : %s" % (fromserverkey, command)
-    output = host_connection.executecommand(command)  
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def create_brick(brickkey):
-    """
-    """
-    return_status = 1
-    env = GlobalObj.getTestenvObj()
-    brick_obj = env.getRawBrick(brickkey)
-    
-    hostname_value = brick_obj.hostname
-    serverkey = re.split("\.", hostname_value, maxsplit=1)[0]
-
-    exportdir = brick_obj.path
-    device = fstype = None
-    """If the exportdir is not a mount point of a device:
-    1) Remove the existing exportdir
-    2) Create new exportdir"""
-    
-    if re.match("^\/", exportdir):
-        dirpath = exportdir
-        command = base_command + dirpath
-    else:
-        export_obj = env.getExportdir(exportdir)
-        dirpath = export_obj.dir
-        device = export_obj.device
-        fstype = export_obj.fstype
-
-    print "%s : %s" % (serverkey, 'create_brick')
-    if device:
-        if umount_device(serverkey, device):
-            return return_status
-        if hostutils.mkfs(serverkey, device, fstype):
-            return return_status
-        if mount_exportdir(serverkey, device, fstype, dirpath):
-            return return_status
-        return 0
-    
-    else:
-        if hostutils.rmdir(serverkey, dirpath):
-            return return_status
-        if hostutils.mkdir(serverkey, dirpath):
-            return return_status
-
-        return 0
-
-def umount_device(serverkey, device):
-    """
-    """
-    base_command = "umount "
-    cm = GlobalObj.getConnectionsManagerObj()
-    
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-    
-    mountpoints = hostutils.find_mountpoints(serverkey, device)
-
-    for mountpoint in mountpoints:
-        command = base_command + mountpoint
-        print "%s : %s" % (serverkey, command)
-        output = server_connection.executecommand(command)
-        return_status = atfutils.assert_success(**output)
-        atfutils.print_stdout(output['stdoutdata'])
-        atfutils.print_stderr(output['stderrdata'])
-        if return_status:
-            stdoutdata = str(output["stdoutdata"])
-            if ((stdoutdata.rfind("not found")) or (stdoutdata.rfind("not mount"))):
-                return_status = 0
-
-            else:
-                return return_status
-
-    return 0
-
-def mount_exportdir(serverkey, device, fstype, dirpath):
-    """
-    """
-    base_command = "mount "
-    cm = GlobalObj.getConnectionsManagerObj()
-    
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        print "SSH connection to host '%s' has not been established" % serverkey
-        return 1
-
-    if fstype is None:
-        fstype = "xfs"
-
-    command = base_command + "-t " + fstype + " " + device + " " + dirpath
-
-    print "%s : %s" % (serverkey, command)
-    output = server_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def create_brick_allservers():
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    brick_keys = env.getBrickKeys()
-    for brickkey in brick_keys:
-        return_status = create_brick(brickkey)
-        if return_status:
-            return return_status
-
-    return 0
-        
-
-__all__ = ['glusterd_start',
-           'glusterd_start_allservers',
-           'glusterd_stop',
-           'glusterd_stop_allservers',
-           'glusterd_restart',
-           'glusterd_remove_dir',
-           'glusterd_remove_dir_allservers',
-           'glusterd_remove_logs_allservers',
-           'volume_delete',
-           'volume_create',
-           'volume_start',
-           'volume_stop',
-           'volume_addbrick',
-           'volume_replacebrick',
-           'volume_set',
-           'volume_reset',
-           'peer_probe',
-           'create_brick',
-           'create_brick_allservers',
-           'mount_exportdir',
-           'umount_device']
-    
-    
-
-    
-        
-
-
-
-    
-            
-            
-            
-            
-    
-    
-    
-    
diff --git a/SharedModules/Utils/hostutils.py b/SharedModules/Utils/hostutils.py
deleted file mode 100644
index 68bb1bf..0000000
--- a/SharedModules/Utils/hostutils.py
+++ /dev/null
@@ -1,193 +0,0 @@
-"""hostutils module contains wrappers for commands that can be executed on any
-host in the test environment
-
-Supported Wrappers:
--------------------
-*) rmdir
-*) mkdir
-*) mkfs
-*) execute_command
-"""
-
-import re
-import atfutils
-from atfglobals import GlobalObj
-
-def cd(hostkey, dirpath):
-    """
-    """
-    base_command = "cd "
-    cm = GlobalObj.getConnectionsManagerObj()
-    host_connection = cm.getConnection(hostkey)
-    if not host_connection:
-        print "SSH Connection Not established to host '%s' " % hostkey
-        return 1
-    command = base_command + dirpath
-    print "%s : %s" % (hostkey, command)
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status   
-    
-def rmdir(hostkey, dirpath):
-    """
-    """
-    base_command = "rm -rf "
-    cm = GlobalObj.getConnectionsManagerObj()
-    system_dirs = re.compile('(/bin|/boot|/dev|/etc|/lib|/mnt|/net|/opt|/root|/sbin|/usr|/var|/sys)\/?$')
-    if system_dirs.match(dirpath):
-        print "System Directiories cannot be deleted"
-        return 1
-    
-    else:
-        host_connection = cm.getConnection(hostkey)
-        if not host_connection:
-            print "SSH Connection Not established to host '%s' " % hostkey
-            return 1
-        command = base_command + dirpath
-        print "%s : %s" % (hostkey, command)
-        output = host_connection.executecommand(command)
-        return_status = atfutils.assert_success(**output)
-        atfutils.print_stdout(output['stdoutdata'])
-        atfutils.print_stderr(output['stderrdata'])
-        return return_status
-        
-def mkdir(hostkey, dirpath):
-    """
-    """
-    base_command = "mkdir -p "
-    cm = GlobalObj.getConnectionsManagerObj()
-    system_dirs = re.compile('(/bin|/boot|/dev|/etc|/lib|/mnt|/net|/opt|/root|/sbin|/usr|/var|/sys)\/?$')
-    if system_dirs.match(dirpath):
-        print "System Directiories cannot be created"
-        return 1
-
-    else:
-        host_connection = cm.getConnection(hostkey)
-        if not host_connection:
-            print "SSH Connection Not established to host '%s' " % hostkey
-            return 1
-        command = base_command + dirpath
-        print "%s : %s" % (hostkey, command)
-        output = host_connection.executecommand(command)
-        return_status = atfutils.assert_success(**output)
-        atfutils.print_stdout(output['stdoutdata'])
-        atfutils.print_stderr(output['stderrdata'])
-        return return_status
-
-def mkfs(hostkey, device, fstype=None):
-    """
-    """
-    base_command = "mkfs "
-    cm = GlobalObj.getConnectionsManagerObj()    
-    host_connection = cm.getConnection(hostkey)
-    if not host_connection:
-        print "SSH Connection Not established to host '%s' " % hostkey
-        return 1
-
-    if fstype is None:
-        fstype = "xfs"
-
-    command = base_command + " -t " + fstype + " -f " + device
-    print "%s : %s" % (hostkey, command)
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-def find_mountpoints(hostkey, device):
-    """
-    """
-    base_command = "mount | grep " 
-    cm = GlobalObj.getConnectionsManagerObj()
-    
-    host_connection = cm.getConnection(hostkey)
-    if not host_connection:
-        print "SSH connection to host '%s' has not been established" % hostkey
-        return 1
-
-    mountpoints = []
-    command = base_command + device
-    print "%s : %s" % (hostkey, command)
-    output = host_connection.executecommand(command)
-    if not output["exitstatus"]:
-        for data in output["stdoutdata"]:
-            mountpoints.append(data.split(" ")[2])
-
-    return mountpoints
-
-def execute_command(hostkey, command, commandInput=None):
-    """
-    """
-    cm = GlobalObj.getConnectionsManagerObj()
-    host_connection = cm.getConnection(hostkey)
-    if not host_connection:
-        print "SSH Connection Not established to host '%s' " % hostkey
-        return 1
-    new_command = _substitute_value_for_variables(hostkey, command)
-
-    print "%s : %s" % (hostkey, command)
-    output = host_connection.executecommand(new_command, commandInput)
-    return_status = atfutils.assert_success(**output)
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
-
-
-def _substitute_value_for_variables(hostkey, command):
-    """
-    """
-    pattern_for_variables = re.compile("<[a-z]+\d*>")
-    pattern_for_hosts = re.compile('(server|client|master)*')
-    variables_to_replace = []
-    replace_values = {}
-    new_command = command
-    Functions_Map = {
-        "server" : "getserver",
-        "client" : "getclient",
-        "master" : "getmaster"
-        }
-    variables = pattern_for_variables.findall(command)
-    host = None
-
-    if not variables: 
-        return new_command
-    
-    else:
-        result = pattern_for_hosts.match(hostkey.lower()).group(0)
-        if result:
-            funcname = Functions_Map[result]
-            function = getattr(env, funcname)
-            if re.match("master", result):
-                host = function()
-            else:
-                host = function(hostkey)
-            
-        if not host:
-            print "No Host to execute the command\n"
-            return 1
-        
-        for variable in variables:
-            if variable not in variables_to_replace:
-                variables_to_replace.append(variable.strip("<>"))
-
-        for variable in variables_to_replace:
-            value = host.__getattribute__(variable)
-            replace_values[variable] = value
-
-        for key in replace_values.keys():
-            value = replace_values[key]
-            key = "<" + key + ">"
-            pattern = re.compile(key)
-            new_command = pattern.sub(value, new_command)
-
-        return new_command
-
-__all__ = ['cd',
-           'rmdir',
-           'mkdir',
-           'mkfs',
-           'find_mountpoints',
-           'execute_command']
diff --git a/SharedModules/Utils/managerutils.py b/SharedModules/Utils/managerutils.py
deleted file mode 100644
index ca38b3f..0000000
--- a/SharedModules/Utils/managerutils.py
+++ /dev/null
@@ -1,55 +0,0 @@
-"""managerutils module. 
-
-Supported Wrappers:-
----------------
-*) ssh_connect
-*) ssh_connect_allhosts
-"""
-
-import re
-import ssh
-from atfglobals import GlobalObj
-
-def ssh_connect(hostkey):
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    host_connection = cm.getConnection(hostkey)
-    if not host_connection:
-        host_obj = env.getHost(hostkey)
-        if not host_obj:
-            print "Invalid Host. %s is not defined in TestEnvironment" % hostkey
-            return 1
-        else:
-            host_connection = ssh.SshConnection()
-            if host_connection.connect(host_obj.hostname, host_obj.user,
-                                       host_obj.password):
-                return 1
-            else:
-                if re.match("server", hostkey, re.IGNORECASE):
-                    cm.addServer(hostkey, host_connection)
-                else:
-                    cm.addClient(hostkey, host_connection)
-                return 0
-    else:
-        print "Connection to %s already exist" % hostkey
-
-    return 0
-
-def ssh_connect_allhosts():
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    hosts_keys = env.getHostsKeys()
-    for hostkey in hosts_keys:
-        return_status = ssh_connect(hostkey)
-        if return_status:
-            return return_status    
-    
-    return 0
-
-__all__ = ['ssh_connect',
-           'ssh_connect_allhosts']
-
diff --git a/SharedModules/Utils/serverutils.py b/SharedModules/Utils/serverutils.py
deleted file mode 100644
index 618ee23..0000000
--- a/SharedModules/Utils/serverutils.py
+++ /dev/null
@@ -1,33 +0,0 @@
-"""serverutils module
-"""
-import re
-import hostutils
-from atfglobals import GlobalObj
-
-def execute_on_brick(brickkey, command, commandInput=None):
-    """
-    """
-    env = GlobalObj.getTestenvObj()
-
-    raw_brick_obj = env.getRawBrick(brickkey)
-    if not raw_brick_obj:
-        print "InValid Brick. %s not defined in TestEnvironment" % brickkey
-        return 1
-    serverkey = re.split("\.", raw_brick_obj.hostname, maxsplit=1)[0]
-    
-    brick_obj = env.getBrick(brickkey)
-    if not brick_obj:
-        print "InValid Brick. %s not defined in TestEnvironment" % brickkey
-        return 1
-    exportdirpath = brick_obj.path
-
-    command = "cd " + exportdirpath + ";" + command
-    return_status = hostutils.execute_command(serverkey, command, commandInput)
-    return return_status
-
-__all__ = ['execute_on_brick']
-
-
-    
-    
-