#!/usr/bin/env python

import os
import re
import logging
import ATFLog
import ATFTests
import ATFTestEnv
import ATFSsh
import ATFGlusterd
import ATFGlusterPeer

#########################################################################
## ATFLog.Log Object 
#########################################################################
LogObj = ATFLog.Log()

#########################################################################
## ATFTests.Tests Object 
#########################################################################
TestsObj = ATFTests.Tests()

#########################################################################
## ATFTestEnv.TestEnv Object
#########################################################################
TestEnvObj = ATFTestEnv.TestEnv()

#########################################################################
## ATFSsh.Ssh Object
#########################################################################
SshObj = ATFSsh.Ssh()

#########################################################################
## Logger for 'ATF_LOG' 
#########################################################################
Logger = logging.getLogger('ATF_LOG')

def set_environ(**arguments):
    """
    Description:
        Set the Env Variable 'envvar' to Value 'value'

    Parameters:
        **arguments: key=value pairs. 
            key: Environment Variable name
            value: Value of the Environment Valiable

    Return:
        Success: 1 (Successfully Set the envar to value)
        Failure: 0 (Unable to set the envvar to value)
        
    Example:
        ATFUtils.set_environ(ATF_USER = user1 ,ATF_SERVER = server1)
    """

    envvars = sorted(arguments.keys())

    for var in envvars:
        try:
            os.environ[var] = arguments[var]

        except KeyError as (key):
            Logger.error("Unable to Export Environment Variable '" + key + "'")
            return 1

        else:
            Logger.debug("Exported Environment Variable '" + var + "' = " +
                    arguments[var])

    return 0

def get_environ(envvar, log = 1):
    """
    Description:
        Return the Value of Environment Variable 'envvar'

    Parameters:
        name: Name of the Environment Variable
        log: To keep track of whether to log the error message or not

    Return:
        Success : Value of Environment Variable 'envvar'
        Failure: 1
    """

    try:
        value = os.environ[envvar]

    except KeyError:
        if log == 1:
            Logger.error("Key Error: Environment Variable %s  Not Defined" %
                    envvar)
        value = 1
        
    except OSError as key:
        if log == 1:
            Logger.error("Environment Variable '" + key + "' Not Defined")
        value = 1
        
    else:
        Logger.debug("Returning " + envvar + " = " + value)
        
    return value

def parse_output(stdout, stderr):
    """
    Description:
        Parse the STDOUT and STDERR ChannelFiles

    Parameter:
        stdout: ChannelFile for stdout
        stderr: ChannelFile for stderr

    Return:
        Success: 0 (STDOUT has DATA)
        Failure: 1 (STDERR has DATA)
    """
    
    output = stderr.readlines()

    if len(output) == 0:
        for line in stdout.readlines():
            Logger.debug(line)
        return 0
    else:
        for line in output:
            Logger.error(line)
        return 1

def execute_command(command, **arguments):
    """
    Description:

    Parameter:
        command: Command to be executed
        **arguments: key=value pair for specifying server, host, user

    Returns:
        Success: 0
        Failure: 1
    """

    output = [1, 0, 0, 0]
    ip_string = '(?:[\d]{1,3})\.(?:[\d]{1,3})\.(?:[\d]{1,3})\.(?:[\d]{1,3})'
    serverkey = hostkey = userkey =  ''
    serverkeyfound = hostkeyfound = 0
    
    if arguments.has_key('server'):              
        serverkey = arguments['server']
        serverkeyfound = 1
    elif arguments.has_key('host'):             
        hostkey = arguments['host']
        hostkeyfound = 1
    else:
        serverkey = get_environ('ATF_SERVER', log = 0)

        if serverkey == 1:
            serverkeyfound = 0
            hostkey = get_environ('ATF_HOST')

            if hostkey == 1:
                Logger.error("Server/Host not defined for command execution")
                return output
            else:
                hostkeyfound = 1
        else:
            serverkeyfound = 1

    if serverkeyfound == 1:
        host, user = TestEnvObj.get_server(serverkey)

        if host == '' or user == '':
             Logger.error("Server: " + serverkey + 
                        "Not Defined in GlobalParam File")
             return output
    elif hostkey != '':
        if re.match(ip_string, hostkey):
            host = hostkey
        else :
            host = TestEnvObj.get_host(hostkey)
            if host == '':
                Logger.error("Host: " + hostkey + 
                        "Not Defined in GlobalParam File")
                return output

    if arguments.has_key('user'):
        userkey = arguments['user']
    else:
        userkey = get_environ('ATF_USER')
        if userkey == 1:
            Logger.error(
                    "Ignoring KeyError: Environment Variable ATF_USER Not " + 
                    "Defined for command execution")
            return output

    if userkey != 'root':
        user = TestEnvObj.get_user(userkey, log = 0)
        if user == '':
            Logger.error("User: " + userkey + 
                    "Not Defined in GlobalParam File")
            return output
    else:
        user = 'root'

    Logger.info("Executing Command:  " + command + " - " + user + "@" + host)
    status, stdin, stdout, stderr = SshObj.executecommand(command, host, user)
    output = [status, stdin, stdout, stderr]
    return output
    
def sshservers():
    """
    Description: 
        SSH to all Servers in the ServersList

    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """

    for server in TestEnvObj.get_serverslist():
        host = server['host']
        user = server['user']
    
        if SshObj.connect(host, user):
            return 1
        else:
            continue

    return 0

def sshclients():
    """
    Description: 
        SSH to all Clients in the ClientsList

    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """

    for client in TestEnvObj.get_clientslist():
        host = client['host']
        user = client['user']      
    
        if SshObj.connect(host, user):
            return 1
        else:
            continue
        
    return 0       

def cleanupserversglusterd():
    """
    Descriptions:
        Cleanup glusterd directory on all Servers in ServersList

    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """

    for host in TestEnvObj.get_servershostlist():
        if ATFGlusterd.cleanup_glusterd(host = host):
            return 1
        else:
            continue

    return 0

def cleanupclientsglusterd():
    """
    Description: 
        Cleanup Glusted directory on all the Clients in ClientsList

    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """

    for host in TestEnvObj.get_clientshostlist():
        if ATFGlusterd.cleanup_glusterd(host = host):
            return 1
        else:
            continue
        
    return 0

def stopserversglusterd():
    """
    Description:
        Stop Glusterd on all the Servers in ServersList

    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """
    
    for host in TestEnvObj.get_servershostlist():
        if ATFGlusterd.stop_glusterd(host = host):
            return 1
        else:
            continue
        
    return 0  

def stopclientsglusterd():
    """
    Description: 
        Stop Glusted on all the Clients in ClientsList

    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """
    
    for host in TestEnvObj.get_clientshostlist():
        if ATFGlusterd.stop_glusterd(host = host):
            return 1
        else:
            continue

    return 0

def startserversglusterd():
    """
    Description:
        Start Glusterd on all the Servers in ServersList
    
    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1 
    """
    
    for host in TestEnvObj.get_servershostlist():
        if ATFGlusterd.start_glusterd(host = host):
            return 1
        else:
            continue
        
    return 0

def startclientsglusterd():
    """
    Description: 
        Start GLusterd on all Clients in ClientsList
    
    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """
    
    for host in TestEnvObj.get_clientshostlist():
        if ATFGlusterd.start_glusterd(host = host):
            return 1
        else:
            continue

    return 0

def peerprobe():
    """
    Description: 
        PeerProbe to all Servers in ServerList from one of the server 
        in the ServerList
    
    Parameters:
        None

    Returns:
        Success: 0
        Failure: 1
    """
    
    if ATFGlusterPeer.probe():
        return 1
    else:
        return 0