"""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']