Changing the return value of all the libraries. The libraries will return a dictionary with 'exitstatus', 'stdoutdata', 'stderrdata' as keys. The value of 'exitstatus' is the exit status of the command execution. The 'stdoutdata' contains data written to the stdout during command execution. The 'stderrdata' contains data written to stderr during command execution.

Change-Id: Ib04062ab34ddf6cf1d8bde07716c4a3be1800ec5
Signed-off-by: Shwetha-H-Panduranga <shwetha@gluster.com>

1 files changed, 348 insertions, 540 deletions

diff --git a/libs/utils/glusterutils.py b/libs/utils/glusterutils.py
index 8264f3e..2c21d9b 100644
--- a/libs/utils/glusterutils.py
+++ b/libs/utils/glusterutils.py
@@ -25,200 +25,169 @@ import re
 import os
 import atfutils
 import hostutils
+from atfutils import commands
 from atfglobals import GlobalObj
 
 def glusterd_start(serverkey, force=False):
     """
     """
     logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     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:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
+    server_obj = env.getServer(serverkey)
+    if server_obj is None:
+        logger.error("Invalid Server. %s is not defined in TestEnvironment" %
+                     serverkey)
+        output["exitstatus"] = 1
+        return output
+    gluster_version = server_obj.glusterversion
 
     """ 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)
+    command = "ps -e | grep glusterd"
+    output = hostutils.execute_command(serverkey, command)
     return_status = atfutils.assert_success(output['exitstatus'])
-    if not return_status:
+    if return_status is 0:
         if force:
-            return_status = glusterd_restart(serverkey)
-            return return_status
+            output = glusterd_restart(serverkey)
+            return output
         else:
-            return return_status
-
-    command = commands_to_execute.pop()
-    output = host_connection.executecommand(command)
-    if output["exitstatus"]:
-        logger.error("Unable to start glusterd")
-        return_status = atfutils.assert_success(output['exitstatus'])
-        return return_status
+            return output
+
+    """ Check the glusterd installed PATH"""
+    command = "which glusterd"
+    output = hostutils.execute_command(serverkey, command)
+    return_status = atfutils.assert_success(output['exitstatus'])
+    if return_status is not 0:
+        logger.error("Unable to find glusterd PATH")
+        return output
     else:
         if output["stdoutdata"]:
-            gluster_path = None
             gluster_path = output["stdoutdata"][0].strip("\n")
         else:
-            logger.error("Unable to find gluster path")
-            return_status = atfutils.assert_success(output['exitstatus'])
-            return return_status
+            logger.error("Unable to find glusterd PATH")
+            return output
 
+        """ Get the glusterd version installed in path gluster_path"""
         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"])):
-                    logger.debug('%s: Executing Command: %s'
-                                 %(serverkey, gluster_path))
-                    output = host_connection.executecommand(gluster_path)
-                    return_status = atfutils.assert_success(output['exitstatus'])
-                    atfutils.print_stdout(output['stdoutdata'])
-                    atfutils.print_stderr(output['stderrdata'])
-                    return return_status
-                else:
-                    logger.error("Unable to start glusterd")
-                    return 1
+            output = hostutils.execute_command(serverkey, command)
+            return_status = atfutils.assert_success(output['exitstatus'])
+            if return_status is not 0:
+                logger.error("Unable to get glusterd version")
+                return output
+            else:
+                """ Check if the installed glusted version in path gluster_path
+                matches with gluster_version specified in testenv"""
+                if output["stdoutdata"] is not None:
+                    if re.search(gluster_version, str(output["stdoutdata"])):
+                        command = gluster_path
+                        output = hostutils.execute_command(serverkey, command)
+                        return output
+                    else:
+                        logger.error("Unable to start glusterd")
+                        output['exitstatus'] = 1
+                        return output
         else:
-            logger.error("Unable to start glusterd")
-            return 1
+            logger.error("Unable to find glusterd PATH")
+            output['exitstatus'] = 1
+            return output
 
 def glusterd_start_allservers(force=False):
     """
     """
+    glusterd_start_output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
     all_servers = env.getServers()
     for serverkey in all_servers.keys():
-        return_status = glusterd_start(serverkey)
-        if return_status:
-            return return_status
+        output = glusterd_start(serverkey)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
 
-    return 0
+    glusterd_start_output["exitstatus"] = 0
+    glusterd_start_output["stdoutdata"] = "Successful in starting glusterd on all servers"
+    return glusterd_start_output
 
-def glusterd_stop(serverkey):
+def glusterd_stop(serverkey, signal="SIGTERM"):
     """
     """
-    logger = GlobalObj.getLoggerObj()
-    base_command = "kill -KILL "
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("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['exitstatus'])
-    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
-                logger.debug('%s: Executing Command: %s' % (serverkey, command))
-                output = host_connection.executecommand(command)
-                return_status = atfutils.assert_success(output['exitstatus'])
-                atfutils.print_stdout(output['stdoutdata'])
-                atfutils.print_stderr(output['stderrdata'])
-                if return_status:
-                    break
-
-        return return_status
+    base_command = "pidof glusterd | xargs --no-run-if-empty kill -s %s"
+    command = base_command % (signal)
+    output = hostutils.execute_command(serverkey, command)
+    return output
 
-def glusterd_stop_allservers():
+def glusterd_stop_allservers(signal="SIGTERM"):
     """
     """
+    glusterd_stop_output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
     all_servers = env.getServers()
     for serverkey in all_servers.keys():
-        return_status = glusterd_stop(serverkey)
-        if return_status:
-            return return_status
+        output = glusterd_stop(serverkey, signal)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
 
-    return 0
+    glusterd_stop_output["exitstatus"] = 0
+    glusterd_stop_output["stdoutdata"] = "Successful in stoping glusterd on all servers"
+    return glusterd_stop_output
 
-def glusterd_restart(serverkey):
+def glusterd_restart(serverkey, signal="SIGTERM"):
     """
     """
-    return_status = glusterd_stop(serverkey)
-    if return_status:
-        return return_status
+    output = glusterd_stop(serverkey, signal)
+    if output['exitstatus']:
+        return output
     else:
-        return_status = glusterd_start(serverkey)
-        return return_status
+        output = glusterd_start(serverkey)
+        return output
 
 def glusterd_remove_dir(serverkey):
     """
     """
-    logger = GlobalObj.getLoggerObj()
-    base_command = "rm -rf"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     glusterd_dir = GlobalObj.glusterd_dir
-
-    server_obj = env.getServer(serverkey)
-    if not server_obj:
-        logger.error("Invalid Host. %s not defined in TestEnvironment"
-                     % serverkey)
-        return 1
-
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    command = ' '.join([base_command, glusterd_dir])
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = server_connection.executecommand(command)
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return 0
+    command = ' '.join([commands['unlink_dir_force'], glusterd_dir])
+    output = hostutils.execute_command(serverkey, command)
+    return output
 
 def glusterd_remove_dir_allservers():
     """
     """
+    glusterd_remove_dir_output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
     all_servers = env.getServers()
     for serverkey in all_servers.keys():
-        return_status = glusterd_remove_dir(serverkey)
-
-    return 0
+        output = glusterd_remove_dir(serverkey)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
 
+    glusterd_remove_dir_output["exitstatus"] = 0
+    glusterd_remove_dir_output["stdoutdata"] = "Successful in removing glusterd dir on all servers"
+    return glusterd_remove_dir_output
 
 def glusterd_remove_logs(serverkey):
     """
     """
     logger = GlobalObj.getLoggerObj()
-    base_command = "rm -rf"
+    output = atfutils.get_new_output_obj()
+
     log_paths = GlobalObj.glusterd_log_paths
     absolute_path_list = []
     prefix_path = ''
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
 
+    env = GlobalObj.getTestenvObj()
     server_obj = env.getServer(serverkey)
-    if not server_obj:
+    if server_obj is None:
         logger.error("Invalid Host. %s not defined in TestEnvironment"
                      % serverkey)
-        return 1
-
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
+        output['exitstatus'] = 1
+        return output
 
     if server_obj.installpath:
         prefix_path = server_obj.installpath
@@ -226,67 +195,68 @@ def glusterd_remove_logs(serverkey):
     for path in log_paths:
         absolute_path_list.append(prefix_path + path)
 
-    for path in absolute_path_list:
-        command = ' '.join([base_command, path])
-        logger.debug('%s: Executing Command: %s' % (serverkey, command))
-        output = server_connection.executecommand(command)
-        return_status = atfutils.assert_success(output['exitstatus'])
-        atfutils.print_stdout(output['stdoutdata'])
-        atfutils.print_stderr(output['stderrdata'])
-
-    return 0
+    command = [commands['unlink_dir_force']]
+    command.extend(absolute_path_list)
+    command = ' '.join(command)
+    output = hostutils.execute_command(serverkey, command)
+    return output
 
 def glusterd_remove_logs_allservers():
     """
     """
+    glusterd_remove_logs_output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
     all_servers = env.getServers()
     for serverkey in all_servers.keys():
-        return_status = glusterd_remove_logs(serverkey)
+        output = glusterd_remove_logs(serverkey)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
 
-    return 0
+    glusterd_remove_logs_output["exitstatus"] = 0
+    glusterd_remove_logs_output["stdoutdata"] = "Successful in removing glusterd logs on all servers"
+    return glusterd_remove_logs_output
 
 def volume_delete(serverkey):
     """
     """
+    base_command = "gluster volume delete"
     logger = GlobalObj.getLoggerObj()
-    base_command = "gluster volume delete "
-    command = [base_command]
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("Invalid Volume.ActiveVolume not defined" +
                      "for the TestEnvironment")
-        return 1
-    command.extend([active_volume.volumename])
-    command = ' '.join(command)
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
+        output['exitstatus'] = 1
+        return output
+    volumename = active_volume.volumename
 
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    command = [base_command]
+    command.extend([volumename])
+    command = ' '.join(command)
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
 def volume_create(serverkey):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume create"
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
-    command.extend([active_volume.volumename])
+        output['exitstatus'] = 1
+        return output
+    volumename = active_volume.volumename
+
+    command = [base_command]
+    command.extend([volumename])
 
     if active_volume.replica:
         command.extend(["replica", active_volume.replica])
@@ -298,113 +268,98 @@ def volume_create(serverkey):
         command.extend(["transport", active_volume.transporttype])
 
     command = ' '.join(command)
+
     for brick_obj in active_volume.bricks:
         brick_value = brick_obj.hostname + ":" + brick_obj.path
         command = ' '.join([command, brick_value])
 
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    if return_status:
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    assert_success_status = atfutils.assert_success(output['exitstatus'])
+    if assert_success_status is not 0:
         if str(output["stdoutdata"]).rfind("already exists"):
-            return_status = 0
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+            output = volume_stop(serverkey, force=True)
+            output = volume_delete(serverkey)
+            assert_success_status = atfutils.assert_success(output['exitstatus'])
+            if assert_success_status is not 0:
+                return output
+            else:
+                output = hostutils.execute_command(serverkey, command,
+                                                   commandInput="y\n")
+                return output
+    else:
+        return output
 
 def volume_start(serverkey, force=False):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume start"
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
-    command.extend([active_volume.volumename])
+        output['exitstatus'] = 1
+        return output
+    volumename = active_volume.volumename
 
+    command = [base_command]
+    command.extend([volumename])
     if force:
         command.extend(["force"])
-
-    command=' '.join(command)
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    if return_status:
+    command = ' '.join(command)
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    assert_success_status = atfutils.assert_success(output['exitstatus'])
+    if assert_success_status is not 0:
         if str(output["stdoutdata"]).rfind("already started"):
-            return_status = 0
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+            output['exitstatus'] = 0
+    return output
 
 def volume_stop(serverkey, force=False):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume stop"
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
-    command.extend([active_volume.volumename])
+        output['exitstatus'] = 1
+        return output
+    volumename = active_volume.volumename
 
+    command = [base_command]
+    command.extend([volumename])
     if force:
         command.extend(["force"])
-
     command = ' '.join(command)
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
 def volume_addbrick(serverkey, *bricks, **arguments):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume add-brick"
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
-    command = [base_command]
-
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
 
+    command = [base_command]
     command.extend([volumename])
-
     """
     arguments can have key brick_type
     brick_type=[<stripe|replica> <COUNT>]
     """
-
     if arguments.has_key('brick_type'):
         command.extend([arguments['brick_type']])
 
@@ -412,26 +367,20 @@ def volume_addbrick(serverkey, *bricks, **arguments):
         brick_obj = env.getBrick(brick)
         if not brick_obj:
             logger.error("Invalid Brick. Brick Not defined in TestEnvironment")
-            return 1
+            output['exitstatus'] = 1
+            return output
         brick_value = brick_obj.hostname + ":" + brick_obj.path
         command.extend([brick_value])
 
     command = ' '.join(command)
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    if not return_status:
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    assert_success_status = atfutils.assert_success(output['exitstatus'])
+    if assert_success_status is 0:
         if env.addBricksToVolume(*bricks):
-            return 1
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+            output['exitstatus'] = 1
+            return output
+
+    return output
 
 def volume_removebrick(serverkey, *bricks, **arguments):
     """
@@ -442,17 +391,20 @@ def volume_removebrick(serverkey, *bricks, **arguments):
     brick_type: [replica <COUNT>]
     operation:{start|pause|abort|status|commit|force}
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume remove-brick"
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
-    command = [base_command]
-
     if not active_volume:
         logger.error("ActiveVolume not defined in the TestEnvironment")
-        return 1
-    command.extend([active_volume.volumename])
+        output['exitstatus'] = 1
+        return output
+    volumename = active_volume.volumename
+
+    command = [base_command]
+    command.extend([volumename])
     """
     brick_type can have only [replica <COUNT>]
     """
@@ -463,48 +415,42 @@ def volume_removebrick(serverkey, *bricks, **arguments):
         brick_obj = env.getBrick(brick)
         if not brick_obj:
             logger.error("Invalid Brick. Brick not defined in TestEnviroment")
-            return 1
+            output['exitstatus'] = 1
+            return output
         brick_value = brick_obj.hostname +':'+ brick_obj.path
         command.extend([brick_value])
     """
     operation can have {start|pause|abort|status|commit|force}
     which is optional.
     """
-
     if arguments.has_key('operation'):
         command.extend([arguments['operation']])
 
     command = ' '.join(command)
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s:Executing Command: %s'% (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    if not return_status:
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    assert_success_status = atfutils.assert_success(output['exitstatus'])
+    if assert_success_status is 0:
         if env.removeBricksFromVolume(*bricks):
-            return 1
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+            output['exitstatus'] = 1
+            return output
+
+    return output
 
 def volume_replacebrick(serverkey, replace_brick, to_brick, operation):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume replace-brick"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
 
+    env = GlobalObj.getTestenvObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
+
     replace_brick_obj = env.getBrick(replace_brick)
     to_brick_obj = env.getBrick(to_brick)
     """
@@ -512,158 +458,116 @@ def volume_replacebrick(serverkey, replace_brick, to_brick, operation):
     """
     if not (replace_brick_obj and to_brick_obj):
         logger.error("Invalid Brick. Brick Not defined in TestEnvironment")
-        return 1
-
-    replace_brick_value = replace_brick_obj.hostname+':'+replace_brick_obj.path
-    to_brick_value = to_brick_obj.hostname+':'+to_brick_obj.path
-
+        output['exitstatus'] = 1
+        return output
+    replace_brick_value = replace_brick_obj.hostname + ':' + replace_brick_obj.path
+    to_brick_value = to_brick_obj.hostname + ':' + to_brick_obj.path
 
+    command = [base_command]
     command.extend([volumename, replace_brick_value, to_brick_value, operation])
     command = ' '.join(command)
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    assert_success_status = atfutils.assert_success(output['exitstatus'])
+    if ((assert_success_status is 0) and (operation == "commit")):
+        if env.replaceBrickInVolume(replace_brick, to_brick):
+            output['exitstatus'] = 1
+            return output
 
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    if (not return_status) and (operation == "commit"):
-        if env.replaceBrickInVolume(brick, newbrick):
-            return 1
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    return output
 
 def volume_set(serverkey, key, value):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume set"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
 
+    env = GlobalObj.getTestenvObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
 
+    command = [base_command]
     command.extend([volumename, key, value])
     command = ' '.join(command)
-
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
 def volume_log_rotate(serverkey, brick):
     """
     brick is compulsory parameter
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume log rotate"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
 
+    env = GlobalObj.getTestenvObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the Testenvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
 
     brick_obj = env.getBrick(brick)
     if not brick_obj:
         logger.error("Invalid Brick. Brick Not defined in TestEnvironment")
-        return 1
-
+        output['exitstatus'] = 1
+        return output
     brick_value = brick_obj.hostname + ":" + brick_obj.path
 
+    command = [base_command]
     command.extend([volumename, brick_value])
-
     command = ' '.join(command)
-
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' %(serverkey, command))
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
 def volume_reset(serverkey):
     """
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume reset "
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
-    command = base_command + volumename
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
 
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command, commandInput="y\n")
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    command = [base_command]
+    command.extend([volumename])
+    command = ' '.join(command)
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
 def volume_profile(serverkey, operation):
     """
     operation:{start|info|stop}
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume profile"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
 
+    env = GlobalObj.getTestenvObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the TestEnvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
 
+    command = [base_command]
     command.extend([volumename, operation])
     command = ' '.join(command)
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to the Host '%s' has not been established"
-                     & serverkey)
-        return 1
-
-    logger.debug('%s: Execute Command: %s' %(serverkey, command))
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
 
 def volume_quota(serverkey, operation, **arguments):
     """
@@ -673,17 +577,19 @@ def volume_quota(serverkey, operation, **arguments):
     value: value can be in GB or MB
         ex: value=1GB
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume quota"
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defined for the Testenvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
 
+    command = [base_command]
     command.extend([volumename, operation])
 
     if arguments.has_key('path'):
@@ -693,19 +599,9 @@ def volume_quota(serverkey, operation, **arguments):
         command.extend([arguments['value']])
 
     command = ' '.join(command)
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to the host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
 
 def volume_top(serverkey, operation, **arguments):
     """
@@ -716,25 +612,27 @@ def volume_top(serverkey, operation, **arguments):
     list-cnt: can take any number
 
     """
-    logger = GlobalObj.getLoggerObj()
     base_command = "gluster volume top"
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
+    logger = GlobalObj.getLoggerObj()
+    output = atfutils.get_new_output_obj()
 
+    env = GlobalObj.getTestenvObj()
     active_volume = env.getActiveVolume()
     if not active_volume:
         logger.error("ActiveVolume not defines for the TestEnvironment")
-        return 1
+        output['exitstatus'] = 1
+        return output
     volumename = active_volume.volumename
 
+    command = [base_command]
     command.extend([volumename, operation])
 
     if arguments.has_key('brick'):
         brick_obj = env.getBrick(arguments['brick'])
         if not brick_obj:
             logger.error("Invalid Brick. Brick Not defined in TestEnvironment")
-            return 1
+            output['exitstatus'] = 1
+            return output
         brick_value = brick_obj.hostname+':'+brick_obj.path
         command.extend(['brick',brick_value])
 
@@ -742,43 +640,26 @@ def volume_top(serverkey, operation, **arguments):
         command.extend(['list-cnt', arguments['list_cnt']])
 
     command = ' '.join(command)
-
-    host_connection = cm.getConnection(serverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     %serverkey)
-        return 1
-
-    logger.debug("%s: Executing command: %s" %(serverkey, command))
-    output = host_connection.executecommand(command)
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
+    return output
 
 def volume_stop_brick(brickkey, signal="SIGTERM"):
     """
     Description: Stop a brick
     Arguments: brickkey. (The brick to be stopped. Ex:- "brick1")
     """
-    output = {}
-    output['exitstatus'] = None
-    output['stdoutdata'] = None
-    output['stderrdata'] = None
-
     base_command = "kill -s %s $(cat %s)"
     glusterd_vol_dir = "/etc/glusterd/vols"
     brick_pid_dir = "run"
     pid_file_extension = ".pid"
 
     logger = GlobalObj.getLoggerObj()
-    env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
+    output = atfutils.get_new_output_obj()
 
-    """Get the active volume
-    """
-    active_volume = atfutils.get_active_volume()
-    if active_volume is None:
+    env = GlobalObj.getTestenvObj()
+    active_volume = env.getActiveVolume()
+    if not active_volume:
+        logger.error("ActiveVolume not defines for the TestEnvironment")
         output['exitstatus'] = 1
         return output
     volumename = active_volume.volumename
@@ -792,12 +673,6 @@ def volume_stop_brick(brickkey, signal="SIGTERM"):
         output['exitstatus'] = 1
         return output
     serverkey = re.split("\.", raw_brick_obj.hostname, maxsplit=1)[0]
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        output['exitstatus'] = 1
-        return output
 
     """ Get the brickobj
     """
@@ -816,62 +691,55 @@ def volume_stop_brick(brickkey, signal="SIGTERM"):
                             brick_pid_dir, pid_filename)
 
     command = base_command % (signal, pid_file_abspath)
-    output = server_connection.executecommand(command, commandInput="y\n")
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
+    output = hostutils.execute_command(serverkey, command, commandInput="y\n")
     return output
 
-def peer_probe(fromserverkey):
+def peer_probe(from_serverkey):
     """
     """
-    logger = GlobalObj.getLoggerObj()
-    base_command = "gluster peer probe "
-    all_servers = {}
+    base_command = "gluster peer probe"
+    peer_probe_output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
-    cm = GlobalObj.getConnectionsManagerObj()
     all_servers = env.getServers()
-    all_servers.pop(fromserverkey)
-    host_connection = cm.getConnection(fromserverkey)
-    if not host_connection:
-        logger.error("SSH connection to host '%s' has not been established"
-                     % serverkey)
-        return 1
-
-    for key in all_servers.keys():
-        if not key is fromserverkey:
-            server_obj = all_servers[key]
+    all_servers.pop(from_serverkey)
+    for serverkey in all_servers.keys():
+        if not serverkey is from_serverkey:
+            server_obj = all_servers[serverkey]
             """
             One hostname is being taken at a time while executing peer probe
             """
             command = ' '.join([base_command, server_obj.hostname])
-            logger.debug('%s: Executing Command: %s' % (fromserverkey, command))
-            output = host_connection.executecommand(command)
-            return_status = atfutils.assert_success(output['exitstatus'])
-            atfutils.print_stdout(output['stdoutdata'])
-            atfutils.print_stderr(output['stderrdata'])
+            output = hostutils.execute_command(from_serverkey, command,
+                                               commandInput="y\n")
+            assert_success_status = atfutils.assert_success(output['exitstatus'])
+            if assert_success_status is not 0:
+                return output
 
-            if return_status:
-                return 1
-
-    return 0
+    peer_probe_output["exitstatus"] = 0
+    peer_probe_output["stdoutdata"] = "Peer Probe Successful for all servers"
+    return peer_probe_output
 
 def create_brick(brickkey):
     """
     """
     logger = GlobalObj.getLoggerObj()
-    return_status = 1
+    output = atfutils.get_new_output_obj()
+
     env = GlobalObj.getTestenvObj()
     brick_obj = env.getRawBrick(brickkey)
-
+    if not brick_obj:
+        logger.error("Invalid brick. Brick not defined in Testenvironment")
+        output['exitstatus'] = 1
+        return output
     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
     else:
@@ -881,118 +749,58 @@ def create_brick(brickkey):
         fstype = export_obj.fstype
         options = export_obj.options
 
-    logger.debug('%s: Executing Command: %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, options, 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):
-    """
-    """
-    logger = GlobalObj.getLoggerObj()
-    base_command = "umount "
-    cm = GlobalObj.getConnectionsManagerObj()
-
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        logger.error("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
-        logger.debug('%s: Executing Command: %s' % (serverkey, command))
-        output = server_connection.executecommand(command)
-        return_status = atfutils.assert_success(output['exitstatus'])
-        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, options, dirpath):
-    """
-    """
-    logger = GlobalObj.getLoggerObj()
-    base_command = "mount "
-    cm = GlobalObj.getConnectionsManagerObj()
-    command = [base_command]
-
-    server_connection = cm.getConnection(serverkey)
-    if not server_connection:
-        logger.error("SSH connection to host '%s' has not been established"
+    server_obj = env.getServer(serverkey)
+    if server_obj is None:
+        logger.error("Invalid Host. %s not defined in TestEnvironment"
                      % serverkey)
-        return 1
-
-    if fstype is None:
-        fstype = "xfs"
-    command.extend(["-t", fstype])
-
-    if options:
-        command.extend([options])
-
-    command.extend([device, dirpath])
-    command = ' '.join(command)
+        output['exitstatus'] = 1
+        return output
+    server_hostname = server_obj.hostname
 
-    logger.debug('%s: Executing Command: %s' % (serverkey, command))
-    output = server_connection.executecommand(command)
-    return_status = atfutils.assert_success(output['exitstatus'])
-    atfutils.print_stdout(output['stdoutdata'])
-    atfutils.print_stderr(output['stderrdata'])
-    return return_status
+    logger.debug('%s: Executing Command: %s' %(server_hostname, 'create_brick'))
+    if device:
+        output = hostutils.umount_device(serverkey, device)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
+
+        output = hostutils.mkfs(serverkey, device, fstype, options)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
+
+        output = hostutils.mount(serverkey, device, fstype, dirpath, options)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
+    else:
+        output = hostutils.rmdir(serverkey, dirpath)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
+
+        output = hostutils.mkdir(serverkey, dirpath)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
+
+    output["exitstatus"] = 0
+    output["stdoutdata"] = "Successfully Created Brick %s" % brickkey
+    return output
 
 def create_brick_allservers():
     """
     """
+    create_brick_output = atfutils.get_new_output_obj()
+
     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']
+        output = create_brick(brickkey)
+        assert_success_status = atfutils.assert_success(output['exitstatus'])
+        if assert_success_status is not 0:
+            return output
+
+    create_brick_output["exitstatus"] = 0
+    create_brick_output["stdoutdata"] = "Successful in creating bricks on all servers"
+    return create_brick_output