//#include "StdAfx.h"
#include "host.hpp"
#define MAX_PARALLEL_THREAD_HOST 5
// Static members
boost::mutex host::host_move_mutex;
// Constructor
host :: host(presetHandler pHandle, CLIHandler *cHandle, 
                outputHandler *oHandle, int nHostType)
           :m_pOutputHandle(NULL),m_pSeqController(NULL), 
            m_pParallelHost(NULL),m_pConnectionHandle(NULL),
            m_pTempFilePtr(NULL),m_pStrHostSpecificPaths(NULL)
{
	m_pCommonOutputHandle = oHandle;
	m_pCLIHandle = cHandle;
    m_bIsSSHSupported = true;
    m_bConfigJustOnce = false;
	m_HostType = nHostType;
    m_nBeginID = 0;
	m_nEndID = 0;
	m_bOraclePresent = false;
	m_bStart = false;
    m_pPresetHandle = pHandle;
    m_pOutputHandle = new outputHandler();
    m_pSeqController = new controller();
    m_nHistoInterval = m_pCLIHandle->getSampleInterval();
    m_nHistoCount = m_pCLIHandle->getSamples();
    m_nHistoTotalSecs = (m_pCLIHandle->getSampleTime())*60;
    m_nIterationNumber = 0;

    m_strOracleLogin = STR_ORACLE_DEFAULT_LOGIN;
    m_strRunAsUser = "";
    m_bSysDBAFlag = false;
    m_strSqlPlus = STR_SQL_PLUS;

    if(m_pCLIHandle->getAppFlag())
    {
        setAppParams();
    }
    m_pStrHostSpecificPaths = new string[NUM_HOST_SPECIFIC_PATHS];	
    bRHEL5 = false;
    bquickPoststatsFlag = false;
    startTime = 0;
}

host :: ~host()
{
    SAFE_DELETE(m_pOutputHandle);
    SAFE_DELETE(m_pSeqController);
    SAFE_ARRAY_DELETE(m_pStrHostSpecificPaths);
}

void host :: ProcessCommands(int iterNum, boost::barrier *serThreadBar)
{
    try
    {
        bool bWindows = false;
#ifdef WIN32
        bWindows = true;
#endif
        m_nIterationNumber = iterNum;
        int nMaxNumOfIterations = m_pCLIHandle->getNumberOfIter();
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, "Connecting to Host.");
		if(!m_bStart)
		{
			m_strHostType = GetHostOSType();
            // Added to get the OS Version for Linux
            getOSVersion();
			m_bStart = true;
			if(m_strHostType.empty())
			{
				m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName,
										"Exiting as Host type not identified properly");
				m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName,
										"Please check RSH connectivity");
			}
			GenerateHeader(serThreadBar);
		}
        if(!bWindows || (m_HostType == HOST_REMOTE))
        {
	        GetHostSpecificPaths();
        }
        time_t cmdStartTime;
        time(&cmdStartTime);
        time(&startTime);
        string dateStr = ProcessDateCommand(serThreadBar);
        string temp = STR_ITERATION + boost::lexical_cast<std::string>(m_nIterationNumber) + "/" +
                                boost::lexical_cast<std::string>(nMaxNumOfIterations) + ":\n";
        m_pCommonOutputHandle->writeDataToLogFile(STR_STATUS, m_strHostName, temp);
        temp = STR_BEGIN_ITER_NUM;
        temp.append(boost::lexical_cast<std::string>(m_nIterationNumber));
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, temp);
        m_pOutputHandle->writeIterToHostFile(m_nIterationNumber, STR_BEGIN_ITER, dateStr);

        longerRuntimeCmd.clear();
        if(m_HostType == HOST_REMOTE && m_pConnectionHandle != NULL)
        {
            m_pConnectionHandle->setIterationChanged(true);
        }
        bool status = ProcessPrestatCommands(serThreadBar);
        if(!status)
        {
            m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, 
                                    "Failed to execute processPrestatsCommands. ");
        }
        (*serThreadBar).wait();
        
        /*
        StartParallelThread(serThreadBar);
        //StartParallelThread(serThreadBar, iterationNum);
        status = ProcessPoststatCommands(serThreadBar);
        if(!status)
        {
            m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, 
                                            "Failed to execute processPoststatsCommands. ");
        }
        dateStr = ProcessDateCommand(serThreadBar);

        time_t cmdEndTime;
        time(&cmdEndTime);
        string data="--- EXE-TIME of : Iteration number: ";
        data.append(boost::lexical_cast<std::string>(iterNum) + " : ");
        data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, data);
        m_pOutputHandle->writeIterToHostFile(m_nIterationNumber, STR_END_ITER, dateStr);
        temp = STR_END_ITER_NUM + boost::lexical_cast<std::string>(m_nIterationNumber);
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, temp);
        //check for long runtime commands
        if(longerRuntimeCmd.size() != 0)
        {
            for(int k = 0; k < (int)longerRuntimeCmd.size(); k++)
            {
                string tmp = "Execution time for command \'" + longerRuntimeCmd[k];
                tmp.append("\' was more than 2 mins");
                m_pCommonOutputHandle->writeDataToLogFile(STR_WARNING, m_strHostName, tmp);
            }
        }
        if( m_nIterationNumber == nMaxNumOfIterations )
        {
            m_pOutputHandle->closeHostFile();
            if(m_HostType == HOST_REMOTE && m_pConnectionHandle != NULL)
            {
                m_pConnectionHandle->disconnectToFiler();
            }
        }
        */
    }
    catch(std::exception& e)
    {
        string tmp = "";
        if(m_HostType == HOST_REMOTE) {
            tmp = "Exception : Remote Host : processCommands :";
        }
        else {
            tmp = "Exception : Local Host : processCommands :";
        }
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, tmp);
    }
}


void host :: GenerateHeader(boost::barrier *serThreadBar)
{
    try
    {
        string headerNote = ("*------------- ");
        headerNote.append(m_pCLIHandle->getVersion());
        headerNote.append(" -------------*");
        string header;
        header.append(" \n");
        //print user inputs:
        map<string, vector<string> > dataMap = m_pCLIHandle->getCLIDataMap();
        map<string, vector<string> >::iterator iter;
        for (iter=dataMap.begin(); iter!= dataMap.end(); iter++)
        {
            vector<string> data = ((*iter).second);
            if(((*iter).first.find("passwd")!=string::npos) && data[0].compare("set") ==0)
            {
                header.append(printHeader((*iter).first, data[0], "*******"));
            }
            else
            {
                header.append(printHeader((*iter).first, data[0], data[1]));
            }
        }
        header.append("\n");
        m_pOutputHandle->writeDataToHostFile(headerNote, header);
        if(serThreadBar)
        {
            (*serThreadBar).wait();
        }
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : GenerateHeader :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName, tmp);
    }
}

void host :: GetHostSpecificPaths()
{
    string strPaths[NUM_HOST_SPECIFIC_PATHS] = 
                        {"/opt/sanlun/bin/ /opt/NetApp/santools/sanlun/ /opt/NTAPsanlun/bin/ /opt/NetApp/santools/bin/ /opt/netapp/santools/ /opt/ontap/santools",
                        "/usr/sbin/", "/usr/sbin/ /usr/local/sbin/",
                        "/usr/bin/ /usr/local/bin/", "/usr/bin/"};
    string strSearchFor[NUM_HOST_SPECIFIC_PATHS] = 
                        {"sanlun", "nfsstat", "iscsi-ls", 
                        "sar", "iostat"};
    for(int nIndex = 0; nIndex < NUM_HOST_SPECIFIC_PATHS; ++nIndex)
    {
        string strPath = SetPaths(strPaths[nIndex], strSearchFor[nIndex]);
		
        if(!strPath.empty())
        {
            m_pStrHostSpecificPaths[nIndex] = strPath;
        }
		
		//m_pStrHostSpecificPaths.push_back(strPath);
    }
}

string host :: SetPaths(string strPath, string strCmdToFind)
{
    string strCorrectPath = "";
    vector<string> vec_strPaths = tokenizeString(strPath, " ");
    for(size_t nIndex = 0; nIndex < vec_strPaths.size(); ++nIndex)
    {
        string strTestPath = vec_strPaths.at(nIndex);
        string strCmd = "ls " + strTestPath;
        strCmd = strCmd + strCmdToFind;
        strCmd = strCmd + " 2>/dev/null | wc -l ";
        vector<string> vec_strRes;
        bool bFlag = ProcessCommand(strCmd, false, NULL, &vec_strRes);
		string strOutput = "";
		if(vec_strRes.size() >= 1 && bFlag)
		{
			strOutput = vec_strRes.at(0);
		}
		//execCommandOnHost( strCmd, false, NULL, vec_strRes);
        boost::algorithm::trim(strOutput);
        if(!strOutput.empty() && (strOutput.compare("1") == 0))
        {
            strCorrectPath = strTestPath;
            break;
        }
    }
    return strCorrectPath;
}


vector<string> host :: tokenizeString(string dataStr, string sep)
{
    vector<string> output;
    char * token = NULL;
    char *dataArr = NULL;

    dataArr = new char[dataStr.length() + 1];
    strcpy(dataArr, dataStr.c_str());

    token = strtok (dataArr, sep.c_str());
    while (token != NULL)
    {
        output.push_back(token);
        token = strtok (NULL, sep.c_str());
    }
    delete [] dataArr;
    dataArr = NULL;

    return output;
}


void host :: ProcessPresetCommand(presetMetaData presetInfo)
{
    try
    {
        string command = presetInfo.getCommand();
        GetCommand(command, presetInfo);
        string temp = STR_PROCESSING_CMD;
        temp.append(presetInfo.toString());
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, temp);		

        if(command != "")
        {
            m_pTempFilePtr = m_pOutputHandle->createTempFile("temp_host");

            time_t cmdStartTime;
            time(&cmdStartTime);
            string data = "=-=-=-=-=-= " + presetInfo.getType() + " " + m_strHostName + " ";
            data.append(presetInfo.getSection() + " =-=-=-=-=-= ");
            if(presetInfo.getShortname().compare("") != 0)
            {
                data.append(presetInfo.getShortname());
            }
            else
            {
                data.append(presetInfo.getCommand());
            }
            //m_pOutputHandle->writeDataToTempFile(m_pTempFilePtr, data);
            string totalOutput = "";
            totalOutput.append(STR_PERF_EPOCH);
            totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
            totalOutput.append("\n");
            //m_pOutputHandle->writeDataToTempFile(m_pTempFilePtr, totalOutput);
            m_pOutputHandle->writeDataToHostFile(data, totalOutput);
            ProcessCommand(command, true, m_pTempFilePtr);
            time_t cmdEndTime;
            time(&cmdEndTime);
            data="\n--- EXE-TIME of : " + presetInfo.getCommand() + " : ";
            data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
            m_pOutputHandle->writeDataToTempFile(m_pTempFilePtr, data);
            if((int)(cmdEndTime - cmdStartTime) > cmdRunTime)
            {
                longerRuntimeCmd.push_back(presetInfo.toString());
            }
            m_pOutputHandle->closeTempFile(m_pTempFilePtr);
            m_pOutputHandle->MoveFromTempToHostFile("temp_host", true);
            m_pOutputHandle->removeTempFile("temp_host");
        }

    }
    catch(std::exception& e)
    {
        string tmp = "";
        if(m_HostType == HOST_REMOTE) {
            tmp = "Exception : Remote Host : processCommands :";
        }
        else {
            tmp = "Exception : Local Host : processCommands :";
        }
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName, tmp);
    }
}

string host :: ProcessDateCommand(boost::barrier *serThreadBar)
{
    vector<string> vec_strData;
    bool bFlag = ProcessCommand("date", false, NULL, &vec_strData);
	string output = "";
	if(vec_strData.size() >= 1 && bFlag)
	{
		output = vec_strData.at(0);
	}
    boost::algorithm::trim(output);
    if(serThreadBar)
    {
        (*serThreadBar).wait();
    }
    return output;
}

void host :: ProcessDateCommand(string token, boost::barrier *serThreadBar)
{
    vector<string> data;
    data.push_back(token);
    data.push_back("PERF");
    data.push_back("");
    data.push_back("*");
    data.push_back("*");
    data.push_back("*");
    data.push_back("");
    data.push_back("");
    data.push_back("date");
    data.push_back("true");
    presetMetaData dateCmd = presetMetaData(data);
    ProcessPresetCommand(dateCmd);
    if(serThreadBar)
    {
        (*serThreadBar).wait();
    }
}

bool host :: ProcessPrestatCommands(boost::barrier *serThreadBar)
{
    try
	{
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, STR_START_PRESTAT);
        ProcessDateCommand(STR_PRESTATS, serThreadBar);
        m_pOutputHandle->writeSTATSToHostFile(STR_BEGIN_PRESTATS, m_strHostName);
        bool bSignalStatus = checkSignal();
        if(bSignalStatus)
        {
            //m_pSeqController->startPreStatsCommands();
            return false;
        }
        string strHardware = (m_HostType == HOST_LOCAL) ? "HOST" : "REMOTEHOST";
        if(!m_bConfigJustOnce)
        {
            vector<presetMetaData> prestatsConfigHostVector = 
                                                        m_pPresetHandle.getPrestatsCommands("TYPE", "CONFIG", strHardware);
            bSignalStatus = ProcessHostCommands(prestatsConfigHostVector);
            if(!m_pCLIHandle->getConfigAllFlag())
            {
                m_bConfigJustOnce = true;
            }
        }
        // All CONFIG Commands join at the same time
        if(serThreadBar) {
            (*serThreadBar).wait();
        }
        m_pCommonOutputHandle->writeDataToLogFile("INFO",m_strHostName, "Finished processing of PRESTATS CONFIG commands");
        //m_pSeqController->startPreStatsCommands();
        vector<presetMetaData> prestatsPerfHostVector = 
                                                m_pPresetHandle.getPrestatsCommands("TYPE", "PERF",strHardware);
        bSignalStatus = ProcessHostCommands(prestatsPerfHostVector);
        if(m_pCLIHandle->getAppFlag())
        {
            string strSqlTest = "which sqlplus 2>/dev/null";
            vector<string> vec_SqlTest;
			if(!m_pCLIHandle->getAppName().compare("oracle"))
            {
                if(ProcessCommand(strSqlTest, false, NULL, &vec_SqlTest))
				{
					string strTest = (vec_SqlTest.size() > 0) ? vec_SqlTest.at(0) : "";
					if(strTest.find("no sqlplus") != string::npos || strTest.empty() ||
						strTest.find("sqlplus: Command not found") != string::npos )
					{
						m_bOraclePresent = false;
					}
					else
					{
						m_bOraclePresent = true;
					}
				}
				if(m_bOraclePresent)
				{
					ProcessOraclePrestats();
				}
            }
        }

        m_pOutputHandle->writeSTATSToHostFile(STR_END_PRESTATS, m_strHostName);
        // All PERF Commands join at the same time
        if(serThreadBar) {
            (*serThreadBar).wait();
        }
        m_pCommonOutputHandle->writeDataToLogFile("INFO",m_strHostName, "Finished processing of PRESTATS PERF commands");

        if(bSignalStatus)
        {
            bquickPoststatsFlag = true;
            return false;
        }
        else
        {
            if(serThreadBar)
            {
                (*serThreadBar).wait();
            }
            m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, STR_FINISH_PRESTAT);
            //m_pSeqController->startPreStatsCmd = false;
        }
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : ProcessPrestatCommands :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, tmp);
    }
	return true;
}

bool host :: ProcessPoststatCommands(boost::barrier *serThreadBar)
{
    try
	{
        bool bSignalStatus = checkSignal();
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, STR_START_POSTSTAT);
        m_pOutputHandle->writeSTATSToHostFile(STR_BEGIN_POSTSTATS, m_strHostName);
        if(bSignalStatus)
        {
            return false;
        }
		string strHardware = (m_HostType == HOST_LOCAL) ? "HOST" : "REMOTEHOST";
        vector<presetMetaData> poststatsVec = m_pPresetHandle.getAllPoststatsCommands(strHardware);
        bSignalStatus = ProcessHostCommands(poststatsVec, bquickPoststatsFlag);

        if(m_pCLIHandle->getAppFlag())
        {
            if(!m_pCLIHandle->getAppName().compare("oracle") && m_bOraclePresent)
            {
                ProcessOraclePoststats();
            }
        }
        (*serThreadBar).wait();         // Added for BURT_562755
        m_pOutputHandle->writeSTATSToHostFile(STR_END_POSTSTATS, m_strHostName);
        if(bSignalStatus)
        {
            return false;
        }
        else
        {
            ProcessDateCommand(STR_POSTSTATS, serThreadBar);
            m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, STR_FINISH_POSTSTAT);
            if(serThreadBar)
            {
                (*serThreadBar).wait();
            }
        }
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : processPoststatsCommands :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, tmp);
    }
    return true;
}
// The extra parameter bool bquickFlag can be removed.. and the check can be done with bquickPoststatsFlag
bool host :: ProcessHostCommands(const vector<presetMetaData>& prestatCommands, bool bquickFlag)
{
    bool bStatus = false;
    for(size_t nIndex = 0; nIndex < prestatCommands.size(); ++nIndex)
    {
        presetMetaData presetInfo= prestatCommands.at(nIndex);
		string strOS = presetInfo.getOS();
        std::transform(strOS.begin(), strOS.end(),
                            strOS.begin(), (int(*)(int))std::toupper);
        if(strOS.compare(m_strHostType) == 0)
        {
            ProcessPresetCommand(presetInfo);
            if(bquickFlag == false) {
                bStatus = checkSignal();
                if(bStatus) {
                    break;
                }
            }
        }
    }
    return bStatus;
}

void host :: GetCommand(string& strCmd, presetMetaData pMetaData)
{
	boost::mutex::scoped_lock lock(host_move_mutex);	
	{
		string temp = "<time>";
		size_t found = strCmd.find(temp);
		if(found!=string::npos)
		{
			strCmd.replace(found, temp.length(), boost::lexical_cast<std::string>(m_pCLIHandle->getSampleTimeBtwIter()-10));
		}
		temp = "<samples>";
		found = strCmd.find(temp);
		if(found!=string::npos)
		{
			strCmd.replace(found, temp.length(), boost::lexical_cast<std::string>(m_pCLIHandle->getSamples() - 2));
		}
		temp = "<sample-interval>";
		found = strCmd.find(temp);
		if(found!=string::npos)
		{
			strCmd.replace(found, temp.length(), boost::lexical_cast<std::string>(m_pCLIHandle->getSampleInterval()));
		}

    //strCmd = pMetaData.getCommand();
    if(strCmd.find('<') != string::npos)
    {
        string strToFind[NUM_HOST_SPECIFIC_PATHS] = 
                           { "<SANLUN_PATH>", "<NFSSTAT_PATH>", 
                            "<ISCSI_PATH>", "<SAR_PATH>", 
                            "<IOSTAT_PATH>" 
                            };

        for(int nIndex = 0; nIndex < NUM_HOST_SPECIFIC_PATHS; ++nIndex)
        {
            size_t found = strCmd.find(strToFind[nIndex]);
            if(found != string::npos)
            {
                strCmd.replace(found, strToFind[nIndex].length(), 
                            boost::lexical_cast<std::string>(m_pStrHostSpecificPaths[nIndex]));
                break;
            }
        }
    }
	}
}

void host :: ProcessOraclePrestats()
{
    try
    {
        string sqlCommand = "";
        string commandType = "PERF";
        // snap_shot and awr_snap files are generated
        GenerateSnapFiles();

        string temp = "Processing command -- ";
        temp.append(STR_ORACLE_BEGIN);
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, temp);

        time_t cmdStartTime;
        time(&cmdStartTime);
        string totalOutput = "";
        string data = STR_HEADER_DESIGN + commandType + " " + m_strHostName + " " + STR_PRESTATS;
        data.append(STR_HEADER_DESIGN);
        data.append(STR_ORACLE_BEGIN);
        totalOutput.append(STR_PERF_EPOCH);
        totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
		totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
		totalOutput.append("\n");
        m_pOutputHandle->writeDataToHostFile(data, totalOutput);
        bool bFlag = RunScriptAndGetSnapID(m_nBeginID);
        time_t cmdEndTime;
        time(&cmdEndTime);
        string comdata = "";
        if(bFlag)
        {
            comdata = "The Begin SnapShot ID for AWR report is: ";
            comdata = comdata + boost::lexical_cast<std::string>(m_nBeginID);
        }
        else
        {
            comdata = "Failed to connect to Oracle or execute SQL procedure, please check the Oracle user and its connectivity with database";
        }
        m_pOutputHandle->writeDataToHostFile(comdata);
        data = "\n--- EXE-TIME of : " ;
        data = data + STR_ORACLE_BEGIN + " : ";
        data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
        m_pOutputHandle->writeDataToHostFile(data);
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : prestatOracle :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName, tmp);
    }
}

bool host :: RunScriptAndGetSnapID(int& nID)
{
    string sqlCommand = GetSQLQuery();     // Get the SQL Command
    sqlCommand = sqlCommand + " @" + m_strAwrSnapFileName;
    if(m_strRunAsUser.compare("") != 0)
    {
        sqlCommand += " \"";
    }
#ifdef WIN32
    if(m_HostType == HOST_LOCAL)
    {
        char win_proc_cmd[4096];
        sprintf(win_proc_cmd,"cmd /C \"%s \"", sqlCommand.c_str());
        sqlCommand.clear();
        sqlCommand = boost::lexical_cast<std::string>(win_proc_cmd);
    }
#endif
    bool bRes  = ExecCommand(sqlCommand);
    if(bRes == true)
    {
        nID = GetSnapID();
    }
    return bRes;

}
string host :: GetSQLQuery()
{
    string command = "";

#ifndef WIN32
    if(m_bSysDBAFlag)
    {
        m_strOracleLogin = "/nolog";
    }
    if(!m_strRunAsUser.compare(""))
    {
        command = m_strSqlPlus;
        command = command + " /nolog " + " ";
    }
    else
    {
        command = "su - " + m_strRunAsUser;
        command = command + " -c \"" + m_strSqlPlus + " " + m_strOracleLogin ;
    }

#else

    command = m_strSqlPlus;
    command = command + " /nolog " +  " ";

#endif
    return command;
}

int host :: GetSnapID(void)
{
    int  tmpSnap = 0;
    try
    {
        ofstream tmpOutFile;
        string sqlCommand = "";
        vector<string> tmpSnapID;
        sqlCommand = GetSQLQuery();
        sqlCommand = sqlCommand + " @" + m_strSnapShotFileName;
        if(m_strRunAsUser.compare("") != 0)
        {
            sqlCommand += " \"";
        }
#ifdef WIN32
        if(m_HostType == HOST_LOCAL)            // As we are supporting remote data only for Linux
        {
            char win_proc_cmd[4096];
            sprintf(win_proc_cmd,"cmd /C \"%s \"", sqlCommand.c_str());
            sqlCommand.clear();
            sqlCommand = boost::lexical_cast<std::string>(win_proc_cmd);
        }
#endif
        m_pTempFilePtr = m_pOutputHandle->createTempFile("tmpSnapId");
        ProcessCommand(sqlCommand, true, m_pTempFilePtr);
        m_pOutputHandle->closeTempFile(m_pTempFilePtr);
        //m_pOutputHandle)>MoveFromTempToHostFile("tmpSnapId");  // didnt write the data to Host file

        ifstream inputFile;
        string fileName = m_pOutputHandle->getNodeDataDir();
        fileName.append("/output.tmpSnapId");
        inputFile.open(fileName.c_str(),ios::in);
        if(inputFile.is_open())
        {
            string dataline;
            while(!inputFile.eof())
            {
                getline(inputFile, dataline);
                tmpSnapID.push_back(dataline);
            }
            int sizevec = tmpSnapID.size();
            int k = sizevec - 1;
            while(k > 0 )
            {
                if(strstr(tmpSnapID[k].c_str(),"SNAP_ID"))
                {
                    int j = k;
                    while( j < sizevec - 1)
                    {
						bool bcheck = false;
						if(m_HostType == HOST_LOCAL && (tmpSnapID[j].size() == 0))
						{
							bcheck = true;
						}
						if(m_HostType == HOST_REMOTE && ((tmpSnapID[j].size() == 1) && (tmpSnapID[j].compare("\r") == 0)))
						{
							bcheck = true;
						}
                        if(bcheck) 
                        {
                            break;
                        }
                        tmpSnap = atoi(tmpSnapID[j].c_str());
                        j++;
                    }
                    break;
                }
                k--;
            }
        }
        inputFile.close();
        m_pOutputHandle->removeTempFile("tmpSnapId");
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : getSnapID:";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName, tmp);
    }
    return tmpSnap;
}

void host :: ProcessOraclePoststats()
{
    try
    {
        vector<string> tmpSnapID;
        int systemRetVal;
        string errorMsg = "";
        string sqlCommand = "";
        string commandType = "PERF";

        string temp = "Processing command -- ";
        temp.append(STR_ORACLE_END);
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, temp);

        time_t cmdStartTime;
        time(&cmdStartTime);
        string totalOutput = "";
        string data = STR_HEADER_DESIGN + commandType + " " + m_strHostName + " " + STR_POSTSTATS;
        data.append(STR_HEADER_DESIGN);
        data.append(STR_ORACLE_END);
        totalOutput.append(STR_PERF_EPOCH);
        totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
		totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
		totalOutput.append("\n");
        m_pOutputHandle->writeDataToHostFile(data, totalOutput);
        bool bFlag = RunScriptAndGetSnapID(m_nEndID);
		string comdata = "";
        if(bFlag)
        {
            comdata = "The End SnapShot ID for AWR report is: ";
            comdata = comdata + boost::lexical_cast<std::string>(m_nEndID);
        }
        else
        {
            comdata = "Failed to connect to Oracle or execute SQL procedure, please check the Oracle user and its connectivity with database";
        }
        m_pOutputHandle->writeDataToHostFile(comdata);
        RemoveFileFromHost(m_strAwrSnapFileName);
        RemoveFileFromHost(m_strSnapShotFileName);
        if(bFlag)
        {
            //Now prepare the SQL script to get the AWR report for the last two snapshots
            // string fileName = "AWR_report.sql";
            //string reportName = "./";
            string reportName_complete = m_pOutputHandle->getNodeDataDir() + "/";
            string reportName = "AWR_Report_" + boost::lexical_cast<std::string>(m_nIterationNumber);
            reportName = reportName + "_" + boost::lexical_cast<std::string>(m_nBeginID) + "_";
            reportName = reportName + boost::lexical_cast<std::string>(m_nEndID) + ".html";
			reportName_complete += reportName;
            GenerateAwrReportFile(reportName);
            sqlCommand = GetSQLQuery();
            sqlCommand = sqlCommand + " @" + m_strAwrSnapFileName;
            if(m_strRunAsUser.compare("") != 0)
            {
                sqlCommand += " \"";
            }
            //for Linux, the oracle user might face problem while spooling the AWR report file.
            //sqlCommand = sqlCommand + " > " + reportName;

        #ifdef WIN32
            if(m_HostType == HOST_LOCAL)            // As we are supporting remote data only for Linux
            {
                char win_proc_cmd[4096];
                sprintf(win_proc_cmd,"cmd /C \"%s \"", sqlCommand.c_str());
                sqlCommand.clear();
                sqlCommand = boost::lexical_cast<std::string>(win_proc_cmd);
            }
        #endif
            ofstream* tempFile = new ofstream(reportName_complete.c_str(), ios::out);
            ProcessCommand(sqlCommand, true, tempFile);
            m_pOutputHandle->closeTempFile(tempFile);
            RemoveFileFromHost(m_strAwrSnapFileName);
			RemoveFileFromHost(reportName);	
        }
        else
        {
            errorMsg = "Failed to connect to Oracle or execute SQL procedure, please check the Oracle user and its connectivity with database";
            m_pOutputHandle->writeDataToHostFile(errorMsg);
        }
        time_t cmdEndTime;
        time(&cmdEndTime);
        data = "\n--- EXE-TIME of : ";
        data = data + STR_ORACLE_END + " : ";
        data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
        m_pOutputHandle->writeDataToHostFile(data);
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : poststatOracle :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, tmp);
    }

}


bool host :: StartParallelThread(boost::barrier *serThreadBar)
{
	try
	{
        boost::thread *timerThread=NULL;
        m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, 
                                        "Starting processing of PARALLEL commands for the Host.");

        string strHardware = (m_HostType == HOST_LOCAL) ? "HOST" : "REMOTEHOST";

        vector<presetMetaData> vec_PresetTotalParallelInfo = 
                                        m_pPresetHandle.getAllParallelCommands(strHardware);
        vector<presetMetaData> vec_PresetParallelInfo;
        vec_PresetParallelInfo.clear();
        for(size_t index = 0; index < vec_PresetTotalParallelInfo.size(); ++index)
        {
            presetMetaData presetInfo = vec_PresetTotalParallelInfo.at(index);
             string strType = presetInfo.getOS();
             std::transform(strType.begin(), strType.end(),
                            strType.begin(), (int(*)(int))std::toupper);
             if(strType.compare(m_strHostType) == 0)
             {
                 vec_PresetParallelInfo.push_back(presetInfo);
             }
        }
        int nNumOfParallelHostCommands = vec_PresetParallelInfo.size();
        if(nNumOfParallelHostCommands > 0 )
        {
            int nNumOfParallelHostCommands = (int)vec_PresetParallelInfo.size();
            boost::barrier parThreadBar(nNumOfParallelHostCommands);
            boost::thread_group parallelHostThreadGrp;
            m_pParallelHost = new CParallelHost*[nNumOfParallelHostCommands];
            // Get the Interface Informaation here
            //GetInterfaceInformation();
            for(int i = 0; i < nNumOfParallelHostCommands; i++)
            {
                if( (i+1)% MAX_PARALLEL_THREAD_HOST == 0) {
                    sleepBtwIter(1); //sleep for 1 second
                }
                //generate thread id
                presetMetaData presetInfo = vec_PresetParallelInfo.at(i);
                string threadId = "thread_" + boost::lexical_cast<std::string>(i);
                if(m_pConnectionHandle != NULL && m_HostType == HOST_REMOTE)
                {
                    m_pParallelHost[i] = new CParallelHost(m_pCLIHandle, m_pOutputHandle, m_strHostName, 
                                m_pCommonOutputHandle, m_pConnectionHandle->getNodePrompt(), 
                                threadId, m_nIterationNumber);
                }
                else
                {
                    m_pParallelHost[i] = new  CParallelHost(m_pCLIHandle, m_pOutputHandle, m_strHostName,
                                    m_pCommonOutputHandle, threadId, m_nIterationNumber);
                }
                string temp = "Processing command -- " + presetInfo.toString();
                m_pCommonOutputHandle->writeDataToLogFile("INFO", m_strHostName, temp);
				m_pParallelHost[i]->SetHostPtr(this);
                parallelHostThreadGrp.create_thread(boost::bind(&host::ProcessParallelDataBind,
                                dynamic_cast<host*>(this), m_pParallelHost[i],&parThreadBar,
                                &vec_PresetParallelInfo[i], threadId));
            }
	    //Now create the timer thread to ensure that all parallel commands return within the "-t" time
	    int maxTime=m_pCLIHandle->getSampleTime();
           //timerThread = new thread(boost::bind(&host::ProcessTimer,*this, &maxTime));
	  //parallelHostThreadGrp.add_thread(timerThread);
	   parallelHostThreadGrp.create_thread(boost::bind(&host::ProcessTimer,dynamic_cast<host*>(this),
								&maxTime));
            if(serThreadBar) {
                (*serThreadBar).wait();
            }
            parallelHostThreadGrp.join_all();

			for(size_t index = 0; index < nNumOfParallelHostCommands; ++index)
			{
				SAFE_DELETE(m_pParallelHost[index]);
			}
			SAFE_ARRAY_DELETE(m_pParallelHost);
        }
		else {
            if(serThreadBar) {
                (*serThreadBar).wait();
            }
        }
#if 0
	//Now cleanup the timer thread
	if( timerThread != NULL ) {
	timerThread->join();
        delete timerThread;
        timerThread = NULL;
	}
#endif
        if(m_HostType == HOST_LOCAL) {
            m_pCommonOutputHandle->writeDataToLogFile("INFO", m_strHostName, 
                                "Finished processing of PARALLEL commands for the Local Host.");
        }
        else {
            m_pCommonOutputHandle->writeDataToLogFile("INFO", m_strHostName, 
                                "Finished processing of PARALLEL commands for the Remote Host.");
        }
        //m_pSeqController->parallelCmdThreadFinish();

        //Now delete all the temp files for parallel commands
#ifdef WIN32
        if(m_HostType == HOST_LOCAL) {
            //Now delete all the temp files for parallel commands
            for(size_t i = 0; i < (int)vec_PresetParallelInfo.size(); i++) {
                string fileName = "thread_" + boost::lexical_cast<std::string>(i);
                m_pOutputHandle->removeTempFile(fileName);
        #ifdef WIN32
                fileName = "tmpResult_thread_" + boost::lexical_cast<std::string>(i);
                if(isTempHostFile(fileName)) {
                    std::remove(fileName.c_str());
                }
                fileName += "_a";
                if(isTempHostFile(fileName)) {
                    std::remove(fileName.c_str());
                }
        #endif
            }
        }
#endif
	}
    catch(std::exception& e)
    {
        string tmp = "Exception : Host : startParallelThread :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName, tmp);
    }

    return true;
}

void host :: ProcessParallelData( boost::barrier *parThreadBar, presetMetaData *metaData, string threadId )
{
    return;
}
void host :: ProcessParallelDataBind(CParallelHost *pParallelHost, 
                                boost::barrier *parThreadBar, 
                                presetMetaData * metaData, string threadID)
{
#ifdef WIN32
    if(m_HostType == HOST_LOCAL)
    {
        ProcessParallelData(parThreadBar, metaData, threadID);
    }
	else
	{
    	pParallelHost->ProcessParallelCommands(parThreadBar, metaData);
	}
#else 
    pParallelHost->ProcessParallelCommands(parThreadBar, metaData);

#endif
	
}

void host :: setAppParams()
{
    vector<string> tmpArg;
	 string tmpArgStr = "";
	char *token = NULL;
    if(m_pCLIHandle->getAppName() == "oracle")
    {
        tmpArgStr = m_pCLIHandle->getAppArgs();
#if 0
        char *token = strtok(const_cast<char*>(tmpArgStr.c_str()), ",");
        while (token != NULL)
        {
            tmpArg.push_back(string(token));
            token = strtok (NULL, ",");
        }
#endif
	tmpArg=tokenizeString(tmpArgStr,",");
        //Now parse the arguments and values
        vector<string> tmpArgVec;
        for(int i = 0; i < tmpArg.size();i++)
        {
            token = strtok(const_cast<char*>(tmpArg[i].c_str()), "=");
            while (token != NULL)
            {
	            tmpArgVec.push_back(string(token));
	            token = strtok (NULL, "=");
            }
        }
        int i=0;
        while (i < tmpArgVec.size())
        {
            if(!tmpArgVec[i].compare("oracle_login"))
            {
                m_strOracleLogin = tmpArgVec[i+1];
            }
            if(!tmpArgVec[i].compare("runas"))
            {
                m_strRunAsUser = tmpArgVec[i+1];
            }
            if(!tmpArgVec[i].compare("sqlplus"))
            {
                m_strSqlPlus = tmpArgVec[i+1];
            }
            if(!tmpArgVec[i].compare("sysdba"))
            {
                if(!tmpArgVec[i+1].compare("true"))
                {
                    m_bSysDBAFlag = true;
                }
                else
                {
                    m_bSysDBAFlag = false;
                }
            }
            i=i+2;
        }
    }
}


bool host :: IsSSHSupported()
{
    return m_bIsSSHSupported;
}

string host :: printHeader(string column1, string column2, string column3)
{
    int eachColumnLen = 20;
    string data;
    std::transform(column1.begin(), column1.end(), column1.begin(), (int(*)(int))std::toupper);
    data.append(column1);
    data.append(",");
    int spaceLen = eachColumnLen - (int)column1.length();
    for(int i=0; i<spaceLen; i++)
    {
        data.append(" ");
    }
    std::transform(column2.begin(), column2.end(), column2.begin(), (int(*)(int))std::toupper);
    data.append(column2);
    if(column3.compare("") !=0)
    {
        data.append(",");
        spaceLen = eachColumnLen - (int)column2.length();
        for(int i=0; i<spaceLen; i++)
        {
            data.append(" ");
        }
        data.append("\"" + column3 + "\"");
    }
    data.append("\n");
    return data;
}

void host :: sleepBtwIter(int sampleTime)
{
    boost::xtime xt;
    boost::xtime_get(&xt, boost::TIME_UTC_);
    xt.sec += sampleTime;
    boost::thread::sleep(xt);
}

string* host :: GetHostSpecificString()
{
    return m_pStrHostSpecificPaths;
}

void host :: ProcessParallelTimer(int* maxTime)
{
    ProcessTimer(maxTime);
}

void host :: closeHostFile()
{
    m_pOutputHandle->closeHostFile();
}

bool host::checkSignal()
{
    bool status = perfstat::signalStatus();
    if(status)
    {
            m_pCommonOutputHandle->writeDataToLogFile("INFO", m_strHostName, "Received interrupt. Please wait...\n");
    }
    return status;
}

string host :: GetOSType()
{
    return m_strHostType;
}

bool host :: GetOutputFromFile(string fileName, bool bWriteToTemp, ofstream* pFilePtr, vector<string>* vec_strRes)
{
    ifstream inFile;
    inFile.open(fileName.c_str());
    if(inFile.is_open())
    {
        string dataLine;
        while (!inFile.eof() )
        {
            getline(inFile,dataLine);
            if(bWriteToTemp)
            {
                (*pFilePtr) << dataLine << "\n" << flush;
            }
            else if(vec_strRes != NULL)
            {
                vec_strRes->push_back(dataLine);
            }
            else
            {
                m_pOutputHandle->writeDataToHostFile(dataLine);
            }
        }
        inFile.close();
    }
    else
    {
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName,
                                "Failed to  open the file " + fileName);
        return false;
    }

    return true;
}

int host :: execCommand(string command)
{
	int status;
#ifdef WIN32
    _flushall();
    status = std::system(command.c_str());
#else

        pid_t pid;
        pid = fork ();
        if (pid == 0) {
                execl ("/bin/sh","/bin/sh", "-c",command.c_str(), NULL);
                _exit (EXIT_FAILURE);
                }
        else if (pid < 0) {
                status = -1;
                }
        else {
                if (waitpid (pid, &status, 0) != pid) {
                        status = -1;
                        }
                }
#endif

	return status;
	//return ((nRes == 0) ? true : false);
}

bool host :: isTempHostFile(string fileName)
{

    struct stat tmpFileInfo;
    bool status;
    int returnVal;

    //Lets check the existence of the file before attempting to delete it.
    //Try to get the file attributes
    returnVal = stat(fileName.c_str(),&tmpFileInfo);
    if( returnVal == 0)
    {
        //Stat managed to get the file attributes that means the file exists
        status = true;
    }
    else
    {
        //stat failed to get the file attributes which could mean the file doesnt exist, insufficient privilages
        status = false;
     }
    return status;
}

void host :: getOSVersion()
{
    int version = 2421;                         // Default value of test machine
    if(m_strHostType.compare("LINUX") == 0) {
        //string command = "uname -r | cut -d'.' -f1,2,3 | sed 's/-.*//g' | sed 's/\\.//g' | awk '{printf \"%d%d%02d\n\", $1,$2,$3}'";
        string command = "uname -r";
        vector<string> info;
        ProcessCommand(command, false, NULL, &info);
        if(info.size() != 0) {
            string hostVersion = info.at(0);
            boost::algorithm::trim(hostVersion);
            string strVersion = "";
            int position = hostVersion.find("-");
            if(position != string::npos) {
                strVersion = hostVersion.substr(0,position);
                vector<string> verNumbers = m_pCLIHandle->tokenizeString(strVersion, ".");
                // If size is 3, then only we calculate the version, else we go with default version
                if(verNumbers.size() == 3) {
                    int thirdPart = atoi((verNumbers.at(2)).c_str());
                    string finalVersion = verNumbers.at(0) + verNumbers.at(1);
                    if(thirdPart <= 9) {
                        finalVersion += "0";
                        finalVersion += verNumbers.at(2);
                    }
                    else {
                        finalVersion += verNumbers.at(2);
                    }
                    version = atoi(finalVersion.c_str());
                }
            }
        }
    }
    bRHEL5 = (version >= 2617) ? true : false;
}

bool host :: isRHEL5()
{
    return bRHEL5;
}

int host :: getNumberOfParallelCommands()
{
    string strHardware = (m_HostType == HOST_LOCAL) ? "HOST" : "REMOTEHOST";

    vector<presetMetaData> vec_PresetTotalParallelInfo = 
                                    m_pPresetHandle.getAllParallelCommands(strHardware);
    vector<presetMetaData> vec_PresetParallelInfo;
    vec_PresetParallelInfo.clear();
    for(size_t index = 0; index < vec_PresetTotalParallelInfo.size(); ++index) {
        presetMetaData presetInfo = vec_PresetTotalParallelInfo.at(index);
         string strType = presetInfo.getOS();
         std::transform(strType.begin(), strType.end(), strType.begin(), (int(*)(int))std::toupper);
         if(strType.compare(m_strHostType) == 0) {
             vec_PresetParallelInfo.push_back(presetInfo);
         }
    }

    return vec_PresetParallelInfo.size();
}

bool host :: processPoststats(boost::barrier *serThreadBar, int niterationNumber)
{
    bool status = ProcessPoststatCommands(serThreadBar);
    string dateStr = ProcessDateCommand(serThreadBar);
    if(!status) {
        m_pCommonOutputHandle->writeDataToLogFile(STR_ERROR, m_strHostName, "Failed to execute processPoststatsCommands. ");
    }
    int nMaxNumOfIterations = m_pCLIHandle->getNumberOfIter();
    time_t cmdEndTime;
    time(&cmdEndTime);
    string data="--- EXE-TIME of : Iteration number: ";
    data.append(boost::lexical_cast<std::string>(niterationNumber) + " : ");
    data.append(boost::lexical_cast<std::string>(cmdEndTime - startTime) + " seconds");
    m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, data);
    m_pOutputHandle->writeIterToHostFile(niterationNumber, STR_END_ITER, dateStr);
    string temp = STR_END_ITER_NUM + boost::lexical_cast<std::string>(niterationNumber);
    m_pCommonOutputHandle->writeDataToLogFile(STR_INFO, m_strHostName, temp);
    //check for long runtime commands
    if(longerRuntimeCmd.size() != 0) {
        for(int k = 0; k < (int)longerRuntimeCmd.size(); k++) {
            string tmp = "Execution time for command \'" + longerRuntimeCmd[k];
            tmp.append("\' was more than 2 mins");
            m_pCommonOutputHandle->writeDataToLogFile(STR_WARNING, m_strHostName, tmp);
        }
    }
    if( niterationNumber == nMaxNumOfIterations ) {
        m_pOutputHandle->closeHostFile();
        if(m_HostType == HOST_REMOTE && m_pConnectionHandle != NULL) {
            m_pConnectionHandle->disconnectToFiler();
        }
    }
    return status;
}
void host :: setQuickPoststatsRunFlag(bool val)
{
    bquickPoststatsFlag = val;
}

bool host :: getQuickPoststatsRunFlag()
{
    return bquickPoststatsFlag;
}
void host :: ProcessTimer(int* maxTime)
{
    try
    {
        boost::xtime currTime;
        boost::xtime_get(&currTime, boost::TIME_UTC_);
        currTime.sec += ((*maxTime)*60);
        boost::thread::sleep(currTime);

        m_pCommonOutputHandle->writeDataToLogFile("STATUS", m_strHostName, "Timed OUT !! for parallel commands . ");
        killRshOrSshProcess();
    }
    catch(std::exception& e)
    {
        string tmp = "Exception : LocalHost : killProcess :";
        tmp.append(e.what());
        m_pCommonOutputHandle->writeDataToLogFile("ERROR", m_strHostName, tmp);
    }
}

void host :: killRshOrSshProcess()
{
//kill rsh process or ssh process used for RSH/SSH parallel commands.Both rsh and ssh commands uses tmpResult_<nodeIP>_threadID
//file to store the temporary result
    char command[] = "for i in `ps -ef |grep -e err_res_thread |awk '{print $2}'`;do  kill -9 $i ; done;";
    std::system(command);
}