/* $Id$ */
#include <perfstat.hpp>
#include <node.hpp>
#include <exception>
#define SHELL "/bin/sh"

/**This is required to keep avoid linking errors for
error LNK2001: unresolved external symbol _GetModuleBaseNameA@16
error LNK2001: unresolved external symbol _EnumProcessModules@16
error LNK2001: unresolved external symbol _EnumProcesses@12
*/

#ifdef WIN32
#pragma comment(lib, "Psapi")
#endif

#include <RemoteHost.hpp>
#include <LocalHost.hpp>

#define MAX_PARALLEL_THREAD 5 //Most of the known SSH configurations in C-mode has CPS rate 10.
#define LEGACY_MODE_COMMAND_TIME 70000
//const int cmdRunTime = 120; // 2mins
string fileID = "temp";
// Just a temporary place, need to make this as a member or ??
//bool bQuickPoststatRunFlag = false;

node::node(presetHandler pHandle, CLIHandler * cHandle,
	outputHandler* oHandle, string IP, string nodePrompt, string spasswd,
	bool hostflag, bool switchflag, bool clusterFlag, bool legacyFlag)
{
	parallelStatFlag = false;
	quickPostStatFlag = false;
	presetHandle = pHandle;
	cliHandle = cHandle;
	commonOutputHandle = oHandle;
	nodeIP = IP;
	systemShellPasswd = spasswd;
	currentIteration = 0;
	outputHandle = new outputHandler();
	boost::algorithm::trim(nodePrompt);
	if (!(cliHandle->getFilerMode().compare("10-mode"))) {
		(*outputHandle).createNodeDataHandler(cliHandle->getOutputFileName(), nodeIP, cliHandle->findNodeCluster(nodeIP));
	}
	else {
		(*outputHandle).createNodeDataHandler(cliHandle->getOutputFileName(), nodeIP);
	}
	string nodeDirPath = (*outputHandle).getNodeDataDir();
	cliHandle->setNodeDirectory(nodeIP,nodeDirPath);
	//Added  CLIHandler in the constructor
	connectionHandle = new connectionHandler(cHandle->getSSHKey(), nodeIP,
		cHandle->getRequestTimeoutSecs(), commonOutputHandle, cHandle, nodePrompt);
	statsConnectionHandle = new connectionHandler(cliHandle->getSSHKey(), nodeIP,
		cliHandle->getRequestTimeoutSecs(), commonOutputHandle, cHandle, connectionHandle->getNodePrompt(),false);
	systemShellLoginFlag = true;
	configJustOnce = false;
	systemShellLoginJustOnce = false;
	seqController = new controller();
	//Make sure we collect host data only with one controller
	hostFlag=hostflag;
	//Make sure we collect switch data only with one controller
	switchFlag = switchflag;
	// Added for cluster mode commands
	bstatisticsShow = clusterFlag;

	// Added for BURT_562755
	remoteHostThreadBar = NULL;
	localHostThreadBar = NULL;
	remoteHostThreadGroup = NULL;
	localHostThreadGroup = NULL;

	// BURT_562755
	if(!cliHandle->getHostOrFilerFlag()) {
		if(hostFlag) {
			localHostThreadBar = new boost::barrier(1);
			localHostThreadGroup = new boost::thread_group();
			localHostObj = new LocalHost(presetHandle, cliHandle, commonOutputHandle);
		}
	}
	if(cliHandle->GetRemoteHostFlag()) {
		vector<string> tmpvec = cliHandle->GetRemoteHosts();
		if(hostflag) {
			if(remoteHostThreadBar == NULL && tmpvec.size() > 0) {
				remoteHostThreadBar = new boost::barrier(tmpvec.size());
				remoteHostThreadGroup = new boost::thread_group();
			}
			pRemoteHost = new host*[(int)tmpvec.size()];
			for(int i = 0; i < (int)tmpvec.size(); i++) {
				pRemoteHost[i] = new RemoteHost(presetHandle, cliHandle, commonOutputHandle, tmpvec[i]);
			}
		}
	}
	numberOfProcessors = 1;                 // Default processor count
	nosVersion = 8100;                      // Default is RR.0 i.e; 8.1.0
	statsStartTime = 0;                     // Default time         // BURT 543517, 546794
	//664426 Perfstat disconnect ssh for high value of option t
	statsIdentifierTime = 0;
	//Commands added for SN
	userspaceIdentifierTime = 0;
	nbladeIdentifierTime = 0;
	dbladeIdentifierTime = 0;
	protocolIdentifierTime = 0;
	legacyCmd = "";    
	//string user = "root";
	string user = cliHandle->getFilerLoginUser();
	string passwd = "";
	nodeDetails.ip = IP;
	vector<string> nodeCreds = cliHandle->getFilerCreds(IP);
	if(cliHandle->getSSHKeyProvidedFlag() == false) {
		if(cliHandle->getLegacyMode() == true) {
#ifdef WIN32
			if(cliHandle->getSSHFlag() == true) {
				if(nodeCreds.size() == 2) {
					user =  nodeCreds.at(0);
					passwd = nodeCreds.at(1);            
				}
			}
#endif
		}

		else {					
			if(nodeCreds.size() == 2) {
				user =  nodeCreds.at(0);
				passwd = nodeCreds.at(1);            
			}
		}
	}
	nodeDetails.userName = user;
	nodeDetails.ngPasswd = passwd;
	nodeDetails.systemShellPasswd = spasswd;
	setLegacyCommand(user, passwd);        
	legacyFilePtr = NULL;		// for Legacy Mode	
	legacyModeFlag = legacyFlag;		
	if(legacyModeFlag == true) {
		cliHandle->setMapData("LEGACY_MODE", nodeIP);
	}
}
//This piece of code is repeated in node.cpp, perfstat.cpp, threadHandler.cpp and parallelNode.cpp
void node :: setLegacyCommand(string user, string passwd)
{
	if(cliHandle->getFilerMode().compare("10-mode") == 0) 
	{
		return;
	}
#ifdef WIN32
	// If --ssh-privatekey option is not present
	if(cliHandle->getSSHKeyProvidedFlag() == false) {				
		//if(cliHandle->getSSHFlag() == false) {
			legacyCmd = "rsh.exe " + nodeIP;
			legacyCmd = legacyCmd + " -l  " + user + " ";
		//}
		/* We would have failed earlier because with Legacy mode OpenSSH is compulsory from Perfstat v8.3*/
		/*
		else {
			legacyCmd = "plink.exe -ssh -x -a -batch -pw  ";
			//legacyCmd = "plink.exe -ssh -pw  ";
			legacyCmd = legacyCmd + passwd + " -l " + user;
			legacyCmd = legacyCmd + " " + nodeIP;
			legacyCmd = legacyCmd + "  ";
			commonOutputHandle->writeDataToLogFile("STATUS","This is a Bug. Please file a defect");
			std::ostringstream error; 
			error << "File " << __FILE__ << "Line " << __LINE__;
			commonOutputHandle->writeDataToLogFile("STATUS",error.str());
			exit(0);
		}
		*/
	}
	else
	{	
		if(cliHandle->getOPenSSHFlag() == true) {
			string strPrivKeyPath = cliHandle->getSSHPrivateKeyPath();
			string strSSHKnownHostsFilePath = cliHandle->getSSHKnownHostsFilePath();
			string temp = "known_hosts";
			if(strSSHKnownHostsFilePath.empty())
			{
				strSSHKnownHostsFilePath = strPrivKeyPath;
				strSSHKnownHostsFilePath.replace(strSSHKnownHostsFilePath.find_last_of("\\") + 1, temp.length(), temp);
			}
			strSSHKnownHostsFilePath.insert(0,"UserKnownHostsFile=");
			legacyCmd = "ssh.exe -l ";
			legacyCmd = legacyCmd + user + " -i ";
			legacyCmd = legacyCmd + "\"" + strPrivKeyPath + "\"" + " -o " + "\"" + strSSHKnownHostsFilePath + "\"" + " ";
			legacyCmd = legacyCmd + nodeIP + " ";
		}
		else {
			// This code is not needed,as the control wont come here.
			// Need to check this out and Remove this if case
			//if(cliHandle->getSSHFlag() == false) {
				legacyCmd = "rsh.exe " + nodeIP;
				legacyCmd = legacyCmd + " -l  " + user + " ";
			//}
			/*
			else {
				// In-case of Legacy mode always consider OpenSSH. plink deprecated.
				string privKeyPath = cliHandle->getSSHPrivateKeyPath();
				legacyCmd = "plink.exe -ssh -x -a  ";
				legacyCmd = legacyCmd +  nodeIP + " -l  " + user + " -i ";
				legacyCmd = legacyCmd + "\"" + privKeyPath + "\"" +" ";
			}
			*/
		}
	}

#else

	if(cliHandle->getSSHKeyProvidedFlag() == false) {		
		// If --ssh-privatekey is not provided run with RSH
		legacyCmd = "rsh  " + nodeIP;
		legacyCmd = legacyCmd + " -l  " + user + " ";		
	}
	else {		
		if( cliHandle->getSSHFlag() == true) {
			string privKeyPath = cliHandle->getSSHPrivateKeyPath();
			legacyCmd = "ssh -l ";
			legacyCmd = legacyCmd + user + "  -i  ";
			legacyCmd = legacyCmd + privKeyPath;
			legacyCmd.append(" ");
			legacyCmd.append(nodeIP);
			legacyCmd.append(" ");
		}
		else {
			legacyCmd = "rsh  " + nodeIP;
			legacyCmd = legacyCmd + " -l  " + user + " ";
		}
	}

#endif
}


string node::getNodeIP()
{
	return nodeIP;
}

void node::processCommands(boost::barrier *serThreadBar)
{
	try {
		int numOfIter = cliHandle->getNumberOfIter();
		string startIter = "BEGIN Iteration";
		string endIter = "END Iteration";
		bool syslog = false;
		if(legacyModeFlag == false) {
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Connecting to node.");
		}
		if(cliHandle->getSystemShellExcludedFlag() == true || !cliHandle->getSystemShellLoginFlag()) {
#ifndef WIN32
			sleep(1);
#else
			boost::xtime currTime;
			boost::xtime_get(&currTime, boost::TIME_UTC_);
			currTime.sec += 5;
			boost::thread::sleep(currTime);
#endif
		}
		perfstat::setNodeEntered(true);
		string autosupportCmd = "";
		bool bAutoSupport = false;
		string outFileName = cliHandle->getOutputFileName();			
		if(legacyModeFlag == true) {
			//legacyFilePtr = outputHandle->createTempFile("Legacy_Output");
		}
		// Handling Legacy Mode		
		if(legacyModeFlag == false) {
			if((cliHandle->getFilerMode()).compare("10-mode") != 0 && cliHandle->getSSHKeyProvidedFlag() == false) {
				connectionStatus = (*connectionHandle).connectToFiler(nodeDetails.ngPasswd);
			}
			else {
				connectionStatus = (*connectionHandle).connectToFiler();
			}

			if(connectionStatus) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Connected to node.");
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Gathering config data from the node.");
			}
			else {
				commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, "Error while Connecting to node.");
			}
		}
		// If 7-Mode ASUP should work for all the nodes..else it will work for the whole cluster in case of cluster mode
		if((cliHandle->getFilerMode()).compare("10-mode") != 0) {
			bstatisticsShow = true;
		}
		if(bstatisticsShow == true) {
			// As AUTOSUPPORT is a cluster command, we run it only once per perfstat run for the entire cluster.
			// AUTO SUPPORT
			// Keep the dependency of the AUTOSUPPORT in preset file			
			// Check whether ASUP command is present in the preset file or not ?
			vector<presetMetaData> poststatsVec = presetHandle.getAllPoststatsCommands("NODE");
			for(int nIndex = 0; nIndex < poststatsVec.size(); ++nIndex) {
				string poststatCmd = poststatsVec[nIndex].getCommand();
				if(poststatCmd.compare("AUTOSUPPORT") == 0) {
					bAutoSupport = true;
					break;
				}
			}
			// Check whether the health of all the Nodes in the cluster is true or not ?
			if(bAutoSupport == true && ((cliHandle->getFilerMode()).compare("10-mode") == 0)) {
				bAutoSupport = checkClusterHealth();
				if(bAutoSupport == false) {
					commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "AUTOSUPPORT command cannot be executed, as the health of the node in the cluster is false");
				}
			}
			if(bAutoSupport == true) {
				if((cliHandle->getFilerMode()).compare("10-mode")) {
					autosupportCmd = "priv set -q diag;options autosupport.doit \"Starting perfstat whose ouput file is \"" + outFileName;
				}
				else {
					//autosupportCmd = "autosupport invoke -node local -type all -message <file-name>";
					autosupportCmd = "options autosupport.doit \"Starting perfstat whose ouput file is \"" + outFileName;
				}
				if(legacyModeFlag == false) {
					connectionHandle->sendCommandToFiler(autosupportCmd);
				}
				else {
					sendLegacyCommand(autosupportCmd);
				}
			}
		}
		if(legacyModeFlag == false) {
			if((cliHandle->getFilerMode()).compare("10-mode") != 0 && cliHandle->getSSHKeyProvidedFlag() == false) {
				statConnectionStatus = (*statsConnectionHandle).connectToFiler(nodeDetails.ngPasswd);
			}
			else {
				statConnectionStatus = (*statsConnectionHandle).connectToFiler();
			}
		}
		// Added to check whether CTRL+C is used
		bool bcheckSignal = checkSignal();
		//setup connection for parallel stat commands
		//We will not have Parallel_Prestats and Parallel_Poststats commands
		collectConfigData(serThreadBar);
		// Added to check whether CTRL+C is used
		bcheckSignal = checkSignal();
		getValidFilerCommands();
		generateHeader(serThreadBar);
		//Lets get the vfiler data for vfiler commands. We collect it only for 7-mode.
		if((cliHandle->getFilerMode()).compare("10-mode")) {
			bool status = getVfilerData(serThreadBar);
			if(!status) {
				commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, "Error while collecting the vfiler config data");
			}
		} else {
			// For cmode, make sure to stop any stats start sessions in flight to avoid burt 832289
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Stopping any background stats samples");
			stopStatsSamples();
		}

		//start iter loop
		for(int i=0; i<numOfIter; i++) 
		{
			time_t cmdStartTime;
			time(&cmdStartTime);
			//set the current iteration number
			currentIteration = i+1;
			string dateStr = processDateCommand(serThreadBar);
			string temp = "Iteration: " + boost::lexical_cast<std::string>(i + 1) + "/" +
				boost::lexical_cast<std::string>(numOfIter) + ":\n";
			commonOutputHandle->writeDataToLogFile("STATUS", nodeIP, temp);
			temp = "Begin Iteration number: ";
			temp.append(boost::lexical_cast<std::string>(i + 1));
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, temp);
			//start iter stmt
			(*outputHandle).writeIterToNodeFile(i, startIter, dateStr);
			//clear the long run command vector
			longerRuntimeCmd.clear();
			if(legacyModeFlag == false) {
				(*connectionHandle).setIterationChanged(true);
				if(!(cliHandle->getFilerMode()).compare("10-mode")) {
					(*statsConnectionHandle).setIterationChanged(true);
				}
			}
			bool status = processPrestatsCommands(serThreadBar);
			if(!status) {
				break;
			}
			// Added for BURT_562755
			else {
				bool blocalFlag = false;
				bool bremoteFlag = false;
				bool bQuickPoststatRunFlag = false;
				status = runHostPrestats(serThreadBar, i + 1, blocalFlag, bremoteFlag, bQuickPoststatRunFlag);
				// Added BURT_562755, Wait for the Host and Node Prestats to complete
				(*serThreadBar).wait();
				if(bQuickPoststatRunFlag == true) {
					quickPostStatFlag = true;
					if(!(cliHandle->getFilerMode()).compare("10-mode")) {
						seqController->parallelCmdThreadFinish();               // Added to handle interrupt at prestat stage
						seqController->waitParallelStatsCmdThread();
					}
					processPoststatsCommands(serThreadBar);
					(*serThreadBar).wait();
					if(hostFlag && !cliHandle->getHostOrFilerFlag() && blocalFlag) {
						localHostThreadGroup->create_thread(boost::bind(&node::processHostPoststats, *this, localHostObj, localHostThreadBar, i + 1));
						//localHostThreadBar->wait();
						localHostThreadGroup->join_all();
					}
					// REMOTE HOST COLLECTION 
					if(cliHandle->GetRemoteHostFlag() && hostFlag && bremoteFlag) {
						int remoteHostSize = (cliHandle->GetRemoteHosts()).size();
						for(int remoteIndex = 0; remoteIndex < remoteHostSize; ++remoteIndex) {
							remoteHostThreadGroup->create_thread(boost::bind(&node::processHostPoststats, *this, pRemoteHost[remoteIndex], remoteHostThreadBar, i + 1));
							//remoteHostThreadBar->wait();
						}
						remoteHostThreadGroup->join_all();
					}
					// (*serThreadBar).wait();
					break;
				}
			}
			//For 7-mode, we need to ensure that all parallel commands return within maxTime period
			//If they dont finish, we kill them
			startParallelThread(serThreadBar, i+1);
			//waitForParallelThread();
			//664426 Perfstat disconnect ssh for high value of option t
			//checkConnection() not to be run with Legacy mode
			if(cliHandle->getLegacyMode() == false) {
				connectionHandle->checkConnection(true);
			}
			(*serThreadBar).wait();
			status = processPoststatsCommands(serThreadBar);
			if(!status) {
				break;
			}
			dateStr = processDateCommand(serThreadBar);
			if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
				localHostThreadGroup->create_thread(boost::bind(&node::processHostPoststats, *this, localHostObj, localHostThreadBar, i + 1));
				//localHostThreadBar->wait();
				localHostThreadGroup->join_all();
			}
			// REMOTE HOST COLLECTION 
			if(cliHandle->GetRemoteHostFlag() && hostFlag) {
				int remoteHostSize = (cliHandle->GetRemoteHosts()).size();
				for(int remoteIndex = 0; remoteIndex < remoteHostSize; ++remoteIndex) {
					remoteHostThreadGroup->create_thread(boost::bind(&node::processHostPoststats, *this, pRemoteHost[remoteIndex], remoteHostThreadBar, i + 1));
					//remoteHostThreadBar->wait();
				}
				remoteHostThreadGroup->join_all();
			}
			time_t cmdEndTime;
			time(&cmdEndTime);
			string data="--- EXE-TIME of : Iteration number: ";
			data.append(boost::lexical_cast<std::string>(i + 1) + " : ");
			data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, data);
			(*outputHandle).writeIterToNodeFile(i, endIter, dateStr);
			temp = "End Iteration number: " + boost::lexical_cast<std::string>(i + 1);
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, 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");
					commonOutputHandle->writeDataToLogFile("WARNING", nodeIP, tmp);
				}
			}
			//sleep between iter
			if(i+1 != numOfIter) {
				sleepBtwIter(cliHandle->getSampleTimeBtwIter());
				temp = "Sleeping for: ";
				temp.append(boost::lexical_cast<std::string>(cliHandle->getSampleTimeBtwIter()) + " seconds.");
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, temp);
			}
			else {
				// To keep the dependency of the AUTOSUPPORT in preset file
				if(bAutoSupport == true) {
					if((cliHandle->getFilerMode()).compare("10-mode")) {
						autosupportCmd = "priv set -q diag;options autosupport.doit \"Ending perfstat whose ouput file is \"" + outFileName;
					}
					else {
						//autosupportCmd = "autosupport invoke -node local -type all -message <file-name>";
						autosupportCmd = "options autosupport.doit \"Ending perfstat whose ouput file is \"" + outFileName;
					}
					if(legacyModeFlag == false) {
						connectionHandle->sendCommandToFiler(autosupportCmd);
					}
					else {
						sendLegacyCommand(autosupportCmd);
					}
				}
			}
			(*serThreadBar).wait();
		}
		// vol_db for each node.
		//check if vol_db lookup for waffi_id has to be collected
		if(cliHandle->getVol_dbFlag()) {
			getVol_dbLookupInfo(serThreadBar);
		}
		
		/* In-case of 7-mode revert back the syslog.conf file BURT - 679978*/
		if ((cliHandle->getFilerMode()).compare("10-mode"))
		{
			syslog = syslogRvertChanges(serThreadBar);
		}
		// This is made false again.So that,perfstat.cpp will now handle the case of ctrl+C
		perfstat::setNodeEntered(false);

		// Added to Extract Files from controller
		if(cliHandle->getProfileFlag() == true || cliHandle->getModuleInstFlag() == true ||
			cliHandle->getSKTraceFlag() == true || cliHandle->getBackUpLogFlag() == true) {
				getFilesFromFiler();
				(*serThreadBar).wait();             // Make sure all download happens at same time
		}
		// Delete the allocated local host object
		if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
			SAFE_DELETE(localHostObj);
		}
		// Delete the allocated remote host objects
		if(cliHandle->GetRemoteHostFlag() && hostFlag) {
			vector<string> tmpvec = cliHandle->GetRemoteHosts();
			for(int nIndex = 0; nIndex < tmpvec.size(); ++nIndex) {
				SAFE_DELETE(pRemoteHost[nIndex]);
			}
			SAFE_ARRAY_DELETE(pRemoteHost);
		}
		(*outputHandle).closeNodeFile();
		if(legacyModeFlag == false) {
			(*connectionHandle).disconnectToFiler();
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				//this statsConnection is again the overlapped connection to the connectionHandle. So once we have disconnected with
				//connectionHandle, the ssh connection is already terminated and hence we dont close statsConnection.
				(*statsConnectionHandle).disconnectToFiler();
			}
		}
		// remove the Legacy file
		if(legacyModeFlag == true) {
			outputHandle->removeTempFile("Legacy_Output");
			outputHandle->removeTempFile("error");
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : processCommands :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}
bool node::processPrestatsCommands(boost::barrier *serThreadBar)
{
	try {
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of PRESTATS commands.");
		string startStats = "BEGIN PRESTATS";
		string endStats = "END PRESTATS";
		processDateCommand("PRESTATS", serThreadBar);
		(*outputHandle).writeSTATSToNodeFile(startStats, nodeIP);
		bool sigStat = checkSignal();
		if(sigStat) {
			seqController->startPreStatsCommands();
			return false;
		}
		//process config commands
		if(!configJustOnce) {
			// Check whether to collect CONFIG information in all the iterations !!!
			if(!cliHandle->getConfigAllFlag()) {
				configJustOnce = true;
			}
			//added NODE hardware, Get all the NODE related CONFIG commands
			vector<presetMetaData> prestatsconfigVec = presetHandle.getPrestatsCommands("TYPE", "CONFIG", "NODE");
			for(int i = 0; i < (int)prestatsconfigVec.size(); i++) {
				//As systemshell commands in 7-mode triggers disconnect/connect sequence after every command
				//due to the uncertainity of the next command's SHELL. So to minimize this penalty in case
				//the next command's SHELL is systemshell, we would not trigger disconnect/connect.
				if(!(cliHandle->getFilerMode()).compare("10-mode")) {
					processOneCommand(prestatsconfigVec[i]);
				}
				else {
					//Get the SHELL type of the next command
					bool systemShellPresentFlag = false;
					if(i < (int)prestatsconfigVec.size() && (i + 1) != (int)prestatsconfigVec.size() ) {
						string currshell,nextShell;
						currshell = prestatsconfigVec[i].getShell();
						nextShell = prestatsconfigVec[i+1].getShell();
						if(currshell.compare("SYSTEMSHELL") == 0 && nextShell.compare("SYSTEMSHELL") == 0) {
							systemShellPresentFlag = true;
						}
					}
					processOneCommand(prestatsconfigVec[i], systemShellPresentFlag);
				}
				//reach the bar
				// Commented, to make sure that all the prestat commands wait at the last of the prestats.
				//(*serThreadBar).wait();               // BURT_562755
				sigStat = checkSignal();
				//Logout only in case NON-LEGACY MODE				
				if(sigStat) {
					if((cliHandle->getFilerMode()).compare("10-mode") != 0 &&
						(prestatsconfigVec[i].getShell()).compare("SYSTEMSHELL") == 0 &&
						connectionHandle != NULL) {
							if(legacyModeFlag == false) {
								connectionHandle->logoutSystemShell();
							}
					}
					break;
				}				
			}
		}
		// Wait for all CONFIG commands to join at the same time
		(*serThreadBar).wait();
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PRESTATS CONFIG commands");
		seqController->startPreStatsCommands();
		//added NODE hardware, Get all the NODE related PERF commands
		vector<presetMetaData> prestatsVec = presetHandle.getPrestatsCommands("TYPE", "PERF","NODE");
		for(int i=0; i<(int)prestatsVec.size(); i++) {
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				processOneCommand(prestatsVec[i]);
				// Added to make sure that all the statistic show wait and procede from same place
				if((prestatsVec[i].getShortname()).compare("statistics show") == 0) {
					(*serThreadBar).wait();
				}
			}
			else {
				//Get the SHELL type of the next command
				bool systemShellPresentFlag = false;
				if(i < (int)prestatsVec.size() && (i + 1) != (int)prestatsVec.size()) {
					string currshell,nextShell;
					currshell = prestatsVec[i].getShell();
					nextShell = prestatsVec[i+1].getShell();
					if(currshell.compare("SYSTEMSHELL") == 0 && nextShell.compare("SYSTEMSHELL") == 0) {
						systemShellPresentFlag = true;
					}
				}
				// we need to consider the case when sktrace collection is enabled.
				// As sktrace would be the last Systemshell command to be executed in Prestats,
				// we need to set the systemShellPresentFlag flag.
				if((((i + 1) == (int)prestatsVec.size()) && ((prestatsVec[i].getShell()).compare("SYSTEMSHELL") == 0)) &&  cliHandle->getSKTraceFlag()) {
					systemShellPresentFlag = true;
				}
				processOneCommand(prestatsVec[i], systemShellPresentFlag);
			}
			//reach the bar
			// Commented, to make sure that all the prestat perf commands wait at the last of the prestats.
			//(*serThreadBar).wait();           // BURT_562755
			sigStat = checkSignal();
			// Logout only in case of NON-LEGACY MODE			
			if(sigStat) {
				if((cliHandle->getFilerMode()).compare("10-mode") != 0 &&
					(prestatsVec[i].getShell()).compare("SYSTEMSHELL") == 0 &&
					connectionHandle != NULL) {
						if(legacyModeFlag == false) {
							connectionHandle->logoutSystemShell();
						}
				}
				break;
			}			
		}
		//check If SKtrace need to be collected
		//SKTRACE collection is done in the case of NON-LEGACY MODE
		if(legacyModeFlag == false) {
			if(cliHandle->getSKTraceFlag()) {
				prestatsSKtrace();
			}
		}

		// Added to make sure that all the PERF Commands join at the same time
		(*serThreadBar).wait();             // BURT_562755, Added
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PRESTATS PERF commands");
		// If there is an interrupt signal, quickly process POSTSTATS
		if(sigStat) {
			//We run Parallel_Prestat/Parallel_Poststat commands only for 10-mode. Hence we dont require to collect the temp stat data
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				seqController->parallelCmdThreadFinish();               // Added to handle interrupt at prestat stage
				seqController->waitParallelStatsCmdThread();
				//move data from temp file to main data file
				(*outputHandle).MoveFromTempToDataFile(fileID);
				//Delete the temp file
				(*outputHandle).removeTempFile(fileID);
				(*outputHandle).writeSTATSToNodeFile(endStats, nodeIP);
			}
			commonOutputHandle->writeDataToLogFile("STATUS", nodeIP, "Lets quickly run the POSTSTAT before exiting..");
			//set the quickPostStatFlag
			quickPostStatFlag = true;
			// Quickly run the POSTSTATS
			bool result = processPoststatsCommands(serThreadBar);
			if(!result) {
				commonOutputHandle->writeDataToLogFile("ERROR",nodeIP, "Failed to execute the poststat commands: ");
			}
			return false;
		}
		else {
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, \
					"Finished processing of PRESTATS commands. Waiting for PARALLEL_PRESTATS commands to finish");
				// Wait for remaing threads to join here. 
				(*serThreadBar).wait();
				seqController->waitParallelStatsCmdThread();
				//move data from temp file to main data file
				(*outputHandle).MoveFromTempToDataFile(fileID);
				//Delete the temp file
				(*outputHandle).removeTempFile(fileID);
				(*outputHandle).writeSTATSToNodeFile(endStats, nodeIP);
				//to make sure all the stats threads for all nodes are done too
			}
			(*serThreadBar).wait();
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PRESTATS commands.");
			//seqController->startPreStatsCmd = false;
			seqController->resetPrestatVariable();
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : processPrestatsCommands :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
	return true;
}

bool node::processPoststatsCommands(boost::barrier *serThreadBar)
{
	try {
		bool sigStat = checkSignal();
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of POSTSTATS commands.");
		string startStats = "BEGIN POSTSTATS";
		string endStats = "END POSTSTATS";
		(*outputHandle).writeSTATSToNodeFile(startStats, nodeIP);
		if(sigStat) {
			//(*parStatThreadBar).wait();
			// We return only in non emergancy situations.
			// We might have come to process poststats commands as we have recieved timeout or interrupt
			//during the prestat phase
			if(!quickPostStatFlag) {
				return false;
			}
		}
		//(*parStatThreadBar).wait();
		vector<presetMetaData> poststatsVec = presetHandle.getAllPoststatsCommands("NODE");
		for(int i=0; i<(int)poststatsVec.size(); i++) {
			//processOneCommand(poststatsVec[i]);
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				processOneCommand(poststatsVec[i]);
				// Added to make sure that commands after statistics show start at same time
				if((poststatsVec[i].getShortname()).compare("statistics show") == 0) {
					(*serThreadBar).wait();
				}
			}
			else {
				//Get the SHELL type of the next command
				bool systemShellPresentFlag = false;
				if(i < (int)poststatsVec.size() && (i+1) != (int)poststatsVec.size()) {
					string currshell,nextShell;
					currshell = poststatsVec[i].getShell();
					nextShell = poststatsVec[i+1].getShell();
					if(currshell.compare("SYSTEMSHELL")==0 && nextShell.compare("SYSTEMSHELL")==0) {
						systemShellPresentFlag = true;
					}
				}
				processOneCommand(poststatsVec[i], systemShellPresentFlag);
			}
			//reach the bar
			//(*serThreadBar).wait();           // Commented for BURT_562755
			//We have received the interrupt during prestat so logically we should execute all the poststat commands and then return
			sigStat = checkSignal();
			if(!quickPostStatFlag) {				
				//sigStat = checkSignal();
				if(sigStat) {
					if((cliHandle->getFilerMode()).compare("10-mode") != 0 &&
						(poststatsVec[i].getShell()).compare("SYSTEMSHELL") == 0 &&
						connectionHandle != NULL) {
							// Logout only in the case of NON-LEGACY Mode
							if(legacyModeFlag == false) {
								connectionHandle->logoutSystemShell();
							}
					}
					break;
				}
			}
		}
		(*serThreadBar).wait();         // Added for BURT_562755
		if(sigStat) {
			//We run Parallel_Prestat/Parallel_Poststat commands only for 10-mode. Hence we dont require to collect the temp stat data
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				seqController->waitParallelStatsCmdThread();
				if(!parallelStatFlag) {
					//move data from temp file to main data file
					(*outputHandle).MoveFromTempToDataFile(fileID);
					//Delete the temp file
					(*outputHandle).removeTempFile(fileID);
				}
				(*outputHandle).writeSTATSToNodeFile(endStats, nodeIP);
			}
			return false;
		}
		else {
			//We run Parallel_Prestat/Parallel_Poststat commands only for 10-mode. Hence we dont require to collect the temp stat data
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of POSTSTATS commands. Waiting for PARALLEL_POSTSTATS commands to finish");
				seqController->waitParallelStatsCmdThread();
				//move data from temp file to main data file
				(*outputHandle).MoveFromTempToDataFile(fileID);
				//Delete the temp file
				(*outputHandle).removeTempFile(fileID);
				(*outputHandle).writeSTATSToNodeFile(endStats, nodeIP);
			}
			processDateCommand("POSTSTATS", serThreadBar);
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of POSTSTATS commands.");
			//to make sure all the stats threads for all nodes are done too
			(*serThreadBar).wait();
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : processPoststatsCommands :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
	return true;
}

void node::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("NODERUN");
	data.push_back("");
	data.push_back("");
	data.push_back("date");
	data.push_back("true");
	presetMetaData dateCmd = presetMetaData(data);
	processOneCommand(dateCmd);
	(*serThreadBar).wait();
}
string node::processDateCommand(boost::barrier *serThreadBar)
{
	string command;
	if(!(cliHandle->getFilerMode()).compare("10-mode"))

	{
		command = "node run -node local -command \"priv set -q diag;date\"";
	}
	else
	{
		// string command = "\"priv set -q diag;date\"";
		command = "priv set -q diag;date";
		command=command+'\r';
	}
	string output = "";
	if(legacyModeFlag == false) {
		connectionStatus = (*connectionHandle).sendCommandToFiler(command);
		if(connectionStatus)
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
	}
	else {
		sendLegacyCommand(command);		
		output = collectLegacyData(false);
	}
	(*serThreadBar).wait();
	return output;
}
string node :: nodeIPint(string tempnodeIP){
	string dot = ".";
	int dotposition = tempnodeIP.find(dot);
	while(dotposition != string::npos) {
		tempnodeIP.replace(dotposition, dot.length(), "");
		dotposition = tempnodeIP.find(dot);
	}
	return(tempnodeIP);
}

void node::processOneCommand(presetMetaData oneCmd, bool nextSystemShellCommand)
{
	try {
		string::size_type pos;
		bool bDisplaySystemShellForLegacy = true;
		//burt 662532 "wafl_bufstats" need to be removed
		if((cliHandle->getWaflBufstatsFlag() == false) && (oneCmd.getCommand().find("wafl bufstats") != string::npos)){
			return;
		}
		if(legacyModeFlag == true) {
			string shell = oneCmd.getShell();
			if(shell.find("SYSTEMSHELL") != string::npos) {
				bDisplaySystemShellForLegacy = false;
			}
		}
		if(bDisplaySystemShellForLegacy == true) {
			string temp = "Processing command -- ";
			temp.append(oneCmd.toString());
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, temp);		
		}
		/*
		string temp = "Processing command -- ";
		temp.append(oneCmd.toString());
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, temp);
		*/

		string command = generateFullCommand(oneCmd,nextSystemShellCommand);
		string prepareCommand;
		//664426 Perfstat disconnect ssh for high value of option t
		string temp = "stats start";
		size_t found = command.find(temp);
		if(found!=string::npos) {
			time ( &statsIdentifierTime );
			command.replace(found, temp.length(), "stats start -I Perfstat_" +  boost::lexical_cast<std::string>(statsIdentifierTime));
		}
		temp = "stats stop";
		found = command.find(temp);
		if(found!=string::npos) {
			command.replace(found, temp.length(), "stats stop -I Perfstat_" + boost::lexical_cast<std::string>(statsIdentifierTime));
		}
		//Commands added for SN
		temp = "statistics start -sample userspace";
		found = command.find(temp);
		if(found != string::npos) {
			time ( &userspaceIdentifierTime);
			string UserspaceIdentifierString = "statistics start -sample userspace_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(userspaceIdentifierTime);
			command.replace(found, temp.length(), UserspaceIdentifierString);
		}
		temp = "statistics show -sample userspace";
		found = command.find(temp);
		if(found != string::npos) {
			string UserspaceIdentifierString = "statistics show -sample userspace_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(userspaceIdentifierTime);
			command.replace(found, temp.length(), UserspaceIdentifierString);
		}
		temp = "statistics samples delete -sample userspace";
		found = command.find(temp);
		if(found != string::npos) {
			string UserspaceIdentifierString = "statistics samples delete -sample userspace_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(userspaceIdentifierTime);
			command.replace(found, temp.length(), UserspaceIdentifierString);
		}
		/*
		temp = "statistics start -sample dblade";
		found = command.find(temp);
		if(found != string::npos) {
			time ( &dbladeIdentifierTime);
			string dbladeIdentifierString = "statistics start -sample dblade_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(dbladeIdentifierTime);
			command.replace(found, temp.length(), dbladeIdentifierString);
		}
		temp = "statistics show -sample dblade";
		found = command.find(temp);
		if(found != string::npos) {
			string dbladeIdentifierString = "statistics show -sample dblade_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(dbladeIdentifierTime);
			command.replace(found, temp.length(), dbladeIdentifierString);
		}
		temp = "statistics samples delete -sample dblade";
		found = command.find(temp);
		if(found != string::npos) {
			string dbladeIdentifierString = "statistics samples delete -sample dblade_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(dbladeIdentifierTime);
			command.replace(found, temp.length(), dbladeIdentifierString);
		}
		temp = "statistics start -sample nblade";
		found = command.find(temp);
		if(found != string::npos) {
			time ( &nbladeIdentifierTime);
			string nbladeIdentifierString = "statistics start -sample nblade_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(nbladeIdentifierTime);
			command.replace(found, temp.length(), nbladeIdentifierString);
		}
		temp = "statistics show -sample nblade";
		found = command.find(temp);
		if(found != string::npos) {
			string nbladeIdentifierString = "statistics show -sample nblade_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(nbladeIdentifierTime);
			command.replace(found, temp.length(), nbladeIdentifierString);
		}
		temp = "statistics samples delete -sample nblade";
		found = command.find(temp);
		if(found != string::npos) {
			string nbladeIdentifierString = "statistics samples delete -sample nblade_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(nbladeIdentifierTime);
			command.replace(found, temp.length(), nbladeIdentifierString);
		}
		*/
		//
		temp = "statistics start -sample protocol";
		found = command.find(temp);
		if(found != string::npos) {
			time ( &protocolIdentifierTime);
			string protocolIdentifierString = "statistics start -sample protocol_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(protocolIdentifierTime);
			command.replace(found, temp.length(), protocolIdentifierString);
		}
		temp = "statistics show -sample protocol";
		found = command.find(temp);
		if(found != string::npos) {
			string protocolIdentifierString = "statistics show -sample protocol_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(protocolIdentifierTime);
			command.replace(found, temp.length(), protocolIdentifierString);
		}
		temp = "statistics samples delete -sample protocol";
		found = command.find(temp);
		if(found != string::npos) {
			string protocolIdentifierString = "statistics samples delete -sample protocol_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(protocolIdentifierTime);
			command.replace(found, temp.length(), protocolIdentifierString);
		}

		temp = "statistics start -sample aggregated";
		found = command.find(temp);
		if(found != string::npos) {
			time (&aggregatedIdentifierTime);
			string aggregatedIdentifierString = "statistics start -sample aggregated_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(aggregatedIdentifierTime);
			command.replace(found, temp.length(), aggregatedIdentifierString);
		}
		temp = "statistics show -sample aggregated";
		found = command.find(temp);
		if(found != string::npos) {
			string aggregatedIdentifierString = "statistics show -sample aggregated_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(aggregatedIdentifierTime);
			command.replace(found, temp.length(), aggregatedIdentifierString);
		}
		temp = "statistics samples delete -sample aggregated";
		found = command.find(temp);
		if(found != string::npos) {
			string aggregatedIdentifierString = "statistics samples delete -sample aggregated_" + nodeIPint(nodeIP) + "_" + boost::lexical_cast<std::string>(aggregatedIdentifierTime);
			command.replace(found, temp.length(), aggregatedIdentifierString);
		}
		temp = "statistics show";
		found = command.find(temp);
		if(found != string::npos) {
			temp = "statistics";
		}
		if(command != "") {
			time_t cmdStartTime;
			time(&cmdStartTime);
			// Adding this case for cluster Commands
			string clusterCmd = oneCmd.getCommand();
			if(clusterCmd.compare("statistics show -sample aggregated") == 0) {
				if(bstatisticsShow == true) {
					commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Execution of statistics show command takes some time.please wait...");
					connectionStatus = (*connectionHandle).sendCommandToFiler(command);
					if(connectionStatus) {
						processStatisticsShow(oneCmd);
					}
				}
			}
			else if(clusterCmd.find("statistics show -sample userspace") != string::npos) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Execution of statistics show command takes some time.please wait...");
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
				if(connectionStatus) {
					processStatisticsShow(oneCmd);
				}
			}
			/*
			else if(clusterCmd.find("statistics show -sample dblade") != string::npos) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Execution of statistics show command takes some time.please wait...");
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
				if(connectionStatus) {
					processStatisticsShow(oneCmd);
				}
			}
			else if(clusterCmd.find("statistics show -sample nblade") != string::npos) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Execution of statistics show command takes some time.please wait...");
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
				if(connectionStatus) {
					processStatisticsShow(oneCmd);
				}
			}
			*/
			else if(clusterCmd.find("statistics show -sample protocol") != string::npos) {
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Execution of statistics show command takes some time.please wait...");
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
				if(connectionStatus) {
					processStatisticsShow(oneCmd);
				}
			}
			else if((oneCmd.getShortname().compare("statistics start -sample AGGREGATED") == 0) || (oneCmd.getShortname().compare("statistics samples delete -sample AGGREGATED") == 0)) {
				if(bstatisticsShow == true) {
					commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Execution of statistics start cluster commands");
					connectionStatus = (*connectionHandle).sendCommandToFiler(command);
					if(connectionStatus) {
						string data = "";
						string totalOutput = "";
						data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
						data.append(oneCmd.getSection() + " =-=-=-=-=-= ");
						string nameToAppend = oneCmd.getShortname();
						if(nameToAppend.compare("") == 0) {
							nameToAppend = oneCmd.getCommand();
						}
						data += nameToAppend;
						totalOutput = "\nPERFSTAT_EPOCH: ";
						totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
						totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
						totalOutput.append("\n");
						(*outputHandle).writeDataToNodeFile(data, totalOutput);
						(*connectionHandle).readResponseFromFilerWithPoll(outputHandle);
						time_t cmdEndTime;
						time(&cmdEndTime);
						data = "\n--- EXE-TIME of : " + oneCmd.getCommand() + " : ";
						data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
						outputHandle->writeDataToNodeFile(data);
					}
				}
			}
			//check if the command is a RAS tracing command
			else if(strstr(command.c_str(),"rastrace enable" )|| strstr(command.c_str(),"rastrace disable")) {
				// Added to ensure that MODULE_INST is used at the command line
				if(cliHandle->getModuleInstFlag() == false) {
					return;
				}
				string moduleNumber;
				vector<string> tmpInstanceIds;
				command.erase(command.end()-1); //erase the '\r' character coming with the command string
				string temp1 = "<module_id>";
				int moduleid = 5;
				int position = command.find(temp1);
				if(position != string::npos) {
					command.replace(position, temp1.length(), boost::lexical_cast<std::string>(moduleid));
				}

				//Check if the target instances have been provided for the given module
				if(cliHandle->getModuleInstFlag()) {
					tmpInstanceIds = cliHandle->getModuleInstances();
				}

				//lets handle ras trace enable and disable seperately
				if(strstr(command.c_str(),"rastrace enable")) {
					time ( &statsStartTime );
					if(tmpInstanceIds.size() == 0) {
						//this is the dafult case so we collect ras trace for instance '1' only
						command = command + " " + "-i 1";
						if(!(cliHandle->getFilerMode()).compare("10-mode")) {
							command = command + "\"";
						}
						//Now send the command to the controller
						// LEGACY MODE check
						if(legacyModeFlag == false) {
							connectionStatus = (*connectionHandle).sendCommandToFiler(command);
						}
						else {
							sendLegacyCommand(command);
						}
						prepareCommand = command;
					}
					else {
						string tmpCommand;
						for(int i=0; i<tmpInstanceIds.size(); i++) {
							tmpCommand = command;
							tmpCommand = tmpCommand + " " + "-i " + tmpInstanceIds[i];
							if(!(cliHandle->getFilerMode()).compare("10-mode")) {
								tmpCommand = tmpCommand + "\"";
							}
							//Now send the command to the controller
							if(legacyModeFlag == false) {
								connectionStatus = (*connectionHandle).sendCommandToFiler(tmpCommand);
							}
							else {
								sendLegacyCommand(tmpCommand);
							}
							prepareCommand = tmpCommand;
						}
					}
				}
				if(strstr(command.c_str(),"rastrace disable")) {
					string dumpRasCommand;
					if(!(cliHandle->getFilerMode()).compare("10-mode")) {
						dumpRasCommand = "node run -node local -command \"priv set -q diag;rastrace dump -m " ;
					}
					else {
						dumpRasCommand = "priv set -q diag;rastrace dump -m ";
					}
					//get the moduleNumber from the command
					pos = command.find("-m");
					moduleNumber = command.substr(pos+2);
					time ( &statsStartTime );
					if(tmpInstanceIds.size() == 0) {
						//this is the dafult case so we collect ras trace for instance '1' only
						dumpRasCommand = dumpRasCommand + " " +  moduleNumber;
						dumpRasCommand = dumpRasCommand + " -i 1 ";
						if(!(cliHandle->getFilerMode()).compare("10-mode")) {
							dumpRasCommand = dumpRasCommand + "\"";
						}
						command = command + " " + "-i 1";
						if(!(cliHandle->getFilerMode()).compare("10-mode")) {
							command = command + "\"";
						}
						//Now send the command to the controller
						if(legacyModeFlag == false) {
							connectionStatus = (*connectionHandle).sendCommandToFiler(dumpRasCommand);
							connectionStatus = (*connectionHandle).sendCommandToFiler(command);
						}
						else {
							sendLegacyCommand(dumpRasCommand);
							sendLegacyCommand(command);
						}
						prepareCommand = command;
					}
					else {
						string tmpCommand;
						string tmpDumpCommand;
						for(int i=0; i<tmpInstanceIds.size(); i++) {
							tmpDumpCommand = dumpRasCommand;
							tmpDumpCommand = tmpDumpCommand + " " + moduleNumber;
							tmpDumpCommand = tmpDumpCommand + " " + "-i " + tmpInstanceIds[i];

							if(!(cliHandle->getFilerMode()).compare("10-mode")) {
								tmpDumpCommand = tmpDumpCommand + "\"";
							}

							tmpCommand = command;
							tmpCommand = tmpCommand + " " + "-i " + tmpInstanceIds[i];
							if(!(cliHandle->getFilerMode()).compare("10-mode")) {
								tmpCommand = tmpCommand + "\"";
							}
							//Now send the command to the controller
							if(legacyModeFlag == false) {
								connectionStatus = (*connectionHandle).sendCommandToFiler(tmpDumpCommand);
								connectionStatus = (*connectionHandle).sendCommandToFiler(tmpCommand);
							}
							else {
								sendLegacyCommand(tmpDumpCommand);
								sendLegacyCommand(tmpCommand);
							}
						}
						prepareCommand = tmpCommand;
					}
				}
				// As the default value of the Module inst is used..This should be set to true
				// if rastrace command is executed
				cliHandle->setModuleInstFlag(true);
				//Write the stuff into node output file
				string data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
				data.append(oneCmd.getSection() + " =-=-=-=-=-= ");
				pos=prepareCommand.find(";");
				//string tmpCommand=prepareCommand.substr(pos+1);
				data.append(prepareCommand.substr(pos+1));

				string totalOutput ;
				totalOutput.append("\nPERFSTAT_EPOCH: ");
				totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
				totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
				totalOutput.append("\n");
				(*outputHandle).writeDataToNodeFile(data, totalOutput);

				if(legacyModeFlag == false) {
					if(connectionStatus) {
						(*connectionHandle).readResponseFromFilerWithPoll(outputHandle);
					}
				}
				else {
					collectLegacyData();
				}
				time_t cmdEndTime;
				time(&cmdEndTime);
				data="\n--- EXE-TIME of : " + prepareCommand + " : ";
				data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
				(*outputHandle).writeDataToNodeFile(data);
			}
			//Check if the command is a Vfiler template command.
			else if(strstr(command.c_str(),"VFPATH") || strstr(command.c_str(),"VFNAME")) {

				//Now loop thru Vfilers data and execute this command for all the Vfilers existing on the controller
				map<string,string>::const_iterator myMapIter = vfileData.begin();
				while(myMapIter != vfileData.end()) {
					string tmpCommand = command;
					if(strstr(tmpCommand.c_str(),"VFPATH")) {
						pos=tmpCommand.find("VFPATH");
						tmpCommand.replace(pos,6,myMapIter->second);
					}
					else {
						pos=tmpCommand.find("VFNAME");
						tmpCommand.replace(pos,6,myMapIter->first);
					}
					//Now send the command to the controller
					if(legacyModeFlag == false) {
						connectionStatus = (*connectionHandle).sendCommandToFiler(tmpCommand);
					}
					else {
						sendLegacyCommand(tmpCommand);
					}
					//set stats start time
					string data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
					data.append(oneCmd.getSection() + " =-=-=-=-=-= ");
					pos=tmpCommand.find(";");
					string tmpComm=tmpCommand.substr(pos+1);
					data.append(tmpComm);

					string totalOutput;
					totalOutput.append("\nPERFSTAT_EPOCH: ");
					totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
					totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
					totalOutput.append("\n");
					(*outputHandle).writeDataToNodeFile(data, totalOutput);

					if(legacyModeFlag == false) {
						if(connectionStatus) {
							(*connectionHandle).readResponseFromFilerWithPoll(outputHandle);
						}
					}
					else {
						collectLegacyData();
					}

					time_t cmdEndTime;
					time(&cmdEndTime);
					data="\n--- EXE-TIME of : " + tmpComm + " : ";
					data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
					(*outputHandle).writeDataToNodeFile(data);

					if((int)(cmdEndTime - cmdStartTime) > cmdRunTime) {
						longerRuntimeCmd.push_back(tmpComm);
					}
					++myMapIter;
				}
			}
			else if(command.compare("AUTOSUPPORT") == 0) {
				// If Command is AUTOSUPPORT...Do nothing
			}
			else {				
				time_t cmdEndTime;
				string data = "";
				string totalOutput = "";
				string delta = "";
				ofstream* pfilePtr = NULL;
				bool bstatsStop = false;

				if(legacyModeFlag == false) {
					connectionStatus = (*connectionHandle).sendCommandToFiler(command);
				}
				else {
					sendLegacyCommand(command);
					connectionStatus= true;
				}
				if(connectionStatus) {
					// Check for stats start/wafl start
					/*
					if((oneCmd.getCommand().compare("stats start") == 0) ||
					(oneCmd.getCommand().compare("wafltop start") == 0) ) {
					time ( &statsStartTime );
					}
					*/
					//BURT 542949
					if((oneCmd.getCommand()).find("stats start") != string::npos ||
						(oneCmd.getCommand()).find("wafltop start") != string::npos) {
							time ( &statsStartTime );
					}
					// Check for stats stop/wafl stop
					if(((oneCmd.getCommand()).find("stats stop") != string::npos) ||
						((oneCmd.getCommand()).find("wafltop stop") != string::npos) ) {
							delta = getStatsTimeDelta();
							if(legacyModeFlag == false) {
								pfilePtr = outputHandle->createTempFile("tmp_stats");
							}
							bstatsStop = true;
					}
					// Generic case for all except stats/wafl stop
					if(bstatsStop == false) {
						data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
						data.append(oneCmd.getSection() + " =-=-=-=-=-= ");
						string nameToAppend = oneCmd.getShortname();
						if(nameToAppend.compare("") == 0) {
							nameToAppend = oneCmd.getCommand();
						}
						data += nameToAppend;
						totalOutput = "\nPERFSTAT_EPOCH: ";
						totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
						totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
						totalOutput.append("\n");
						(*outputHandle).writeDataToNodeFile(data, totalOutput);
					}
					if(legacyModeFlag == false) {
						(*connectionHandle).readResponseFromFilerWithPoll(outputHandle, pfilePtr);
					}
					else {						
						collectLegacyData(true, bstatsStop);
					}
					time(&cmdEndTime);
					if(bstatsStop == true) {
						//(*connectionHandle).
						//put_StderrToStdout(false);
						map<string, vector<string> > statsInformation;
						bool bstart = false;
						string fileName = outputHandle->getNodeDataDir();
						if(legacyModeFlag == false) {
							fileName.append("/output.tmp_stats");
						}
						else {
							fileName.append("/output.Legacy_Output");
						}
						// Write the output of the file to the node output
						data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
						data.append(oneCmd.getSection());
						data += " =-=-=-=-=-= stats.out";
						totalOutput = "\nPERFSTAT_EPOCH: ";
						totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
						totalOutput.append(boost::lexical_cast<std::string>(delta));
						totalOutput.append("\n");
						(*outputHandle).writeDataToNodeFile(data, totalOutput);
						//outputHandle->MoveFromTempToDataFile("tmp_stats");
						// The following piece of code can be replaced with MoveFromTempToDataFile
						ifstream inFile;
						inFile.open(fileName.c_str());
						if(inFile.is_open()) {
							string dataLine;
							while (!inFile.eof() ) {
								getline(inFile,dataLine);
								outputHandle->writeDataToNodeFile(dataLine);
							}
							inFile.close();
						}
						else {
							commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, "Failed to  open the file " + fileName);
						}
						data = "\n--- EXE-TIME of : " + oneCmd.getCommand() + " : ";
						data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
						outputHandle->writeDataToNodeFile(data);
						//663869 perfstat8 crashed: double free or corruption !prev: 0xd95504e8
						if(cliHandle->getstatformatflag()) {
							format_stats_output(cmdStartTime,
								boost::lexical_cast<std::string>(delta),
								fileName,
								oneCmd.getType(),
								oneCmd.getSection());
						}
						// BURT 535443
						if(legacyModeFlag == false) {
							outputHandle->closeTempFile(pfilePtr);
							outputHandle->removeTempFile("tmp_stats");
						}						
					}
					else {
						//time(&cmdEndTime);
						data = "\n--- EXE-TIME of : " + oneCmd.getCommand() + " : ";
						data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
						outputHandle->writeDataToNodeFile(data);
					}
					if((int)(cmdEndTime - cmdStartTime) > cmdRunTime) {
						longerRuntimeCmd.push_back(oneCmd.toString());
					}
				}
			}
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : processOneCommand :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}


string node::getStatsTimeDelta()
{
	time_t rawtime;
	struct tm * timeinfo;
	char buffer [80];
	string timeStr;
	time ( &rawtime );
	timeinfo = gmtime ( &rawtime );
	strftime (buffer,80,"%a %b %d %H:%M:%S GMT %Y",timeinfo);
	timeStr = buffer;
	string data = "\nTIME: " + timeStr + "\nTIME_DELTA: ";
	if(statsStartTime < 0) {
		statsStartTime = 0;
	}
	time_t tmp = rawtime - statsStartTime;
	timeinfo = gmtime ( &tmp );
	char nbuffer [80];
	strftime (nbuffer,80,"%H:%M:%S",timeinfo);
	timeStr = nbuffer;
	data.append(timeStr + " (" + boost::lexical_cast<std::string>(tmp) + "s)\n\n");
	return data;
}

string node::generateFullCommand(presetMetaData presetCmd, bool nextSystemShellCommand)
{
	string shell = presetCmd.getShell();
	string command = presetCmd.getCommand();
	string temp = "<time>";
	size_t found = command.find(temp);
	if(found != string::npos) {
		command.replace(found, temp.length(), boost::lexical_cast<std::string>(cliHandle->getSampleTimeBtwIter()-10));
	}
	temp = "<samples>";
	found = command.find(temp);
	if(found!=string::npos) {
		command.replace(found, temp.length(), boost::lexical_cast<std::string>(cliHandle->getSamples()));
	}
	temp = "<sample-interval>";
	found = command.find(temp);
	if(found!=string::npos) {
		command.replace(found, temp.length(), boost::lexical_cast<std::string>(cliHandle->getSampleInterval()));
	}
	temp = "<module_id>";
	int moduleid = 5;
	found = command.find(temp);
	if(found!=string::npos) {
		command.replace(found, temp.length(), boost::lexical_cast<std::string>(moduleid));
	}
	if(shell.compare("NODERUN") == 0 || shell.compare("NODESHELL") == 0) {
		if(!(cliHandle->getFilerMode()).compare("10-mode")) {
			command = "node run -node local -command \"priv set -q diag;" + presetCmd.getCommand() + "\"";
		}
		else {
			//command = "\"priv set -q diag;" + presetCmd.getCommand() + "\"";
			if(legacyModeFlag == false) {
				command = "priv set -q diag;" + presetCmd.getCommand();
				command=command+'\r';
			}
			else {
				command = "priv set -q diag;" + presetCmd.getCommand();
			}
			/*
			if(legacyModeFlag == true) {
			systemShellLoginFlag = false;
			}
			*/
			//turn off the flag after executing the last systemshell commmand.
			systemShellLoginJustOnce = false;
		}
	}
	else if(shell.compare("SYSTEMSHELL") == 0) {
		//Burt744483: change the systemshell command execution string according to oneShell command for fullsteam
		if(!(cliHandle->getFilerMode()).compare("10-mode") && !cliHandle->getSystemShellLoginFlag()) {
			command = "system node systemshell -node local -command \"" + presetCmd.getCommand() + "\"";
			return command;
		}
		// Added to support systemshell for 7-mode.
		// If diag user is locked, we dont execute SystemShell command, so return from here.
		// SYSTEMSHELL commands won't run for LEGACY Mode
		if(legacyModeFlag == true) {
			systemShellLoginFlag = false;
			command = "";
			return command;
		}
		if (cliHandle->getSystemShellExcludedFlag()) {
			systemShellLoginFlag = false;
			command = "";
			return command;
		}
		if(systemShellPasswd.compare("") == 0 && (cliHandle->getFilerMode()).compare("10-mode") != 0) {
			systemShellLoginFlag = false;
			command = "";
			return command;
		}		
		//if(!systemShellLoginJustOnce) {
		if(!systemShellLoginJustOnce || (systemShellLoginFlag == false)) {          // Added BURT_553763
			bool status;
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				status =(*connectionHandle).loginSystemShell(systemShellPasswd);//connectToSystemShell();
			}
			else {
				status =(*connectionHandle).loginSystemShell(systemShellPasswd,true); // To make 7-mode systemshell clean exit
			}
			if(!status) {
				systemShellLoginFlag = false;
			}
			// Added BURT_553763
			else {
				systemShellLoginFlag = true;
			}
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				systemShellLoginJustOnce = true;
			}
			else {
				//for 7-mode we need to switch the same channel between NODESHELL and SYSTEMSHELL and hence need to login each time if the next coming command is not SystemShell command
				if(nextSystemShellCommand) {
					systemShellLoginJustOnce = true;
				}
			}
		}
		if(systemShellLoginFlag) {
			processSystemShellCmd(presetCmd,nextSystemShellCommand);
		}
		else {
			commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, "Error in system shell login.");
		}

		command = "";
	}
	return command;
}

void node::processSystemShellCmd(presetMetaData presetCmd, bool nextSystemShellCommand)
{
	try
	{
		time_t cmdStartTime;
		time(&cmdStartTime);
		bool status = (*connectionHandle).sendSystemShellCommand(presetCmd.getCommand());
		if (status)
		{
			string data = "=-=-=-=-=-= " + presetCmd.getType() + " " + nodeIP + " ";
			data.append(presetCmd.getSection() + " =-=-=-=-=-= ");
			if(presetCmd.getShortname().compare("")!=0)
				data.append(presetCmd.getShortname());
			else
				data.append(presetCmd.getCommand());

			string totalOutput = "\nPERFSTAT_EPOCH: " + boost::lexical_cast<std::string>(cmdStartTime);
			totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
			totalOutput.append("\n");
			(*outputHandle).writeDataToNodeFile(data, totalOutput);
			totalOutput = "";
			(*connectionHandle).readSystemShellResponseWithPoll(outputHandle);
			time_t cmdEndTime;
			time(&cmdEndTime);
			totalOutput.append("\n--- EXE-TIME of : " + presetCmd.getCommand() + " : ");
			totalOutput.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
			(*outputHandle).writeDataToNodeFile(totalOutput);
			if((int)(cmdEndTime - cmdStartTime) > cmdRunTime)
			{
				longerRuntimeCmd.push_back(presetCmd.toString());
			}
		}
		else
		{
			if(!(cliHandle->getFilerMode()).compare("10-mode")) {
				status =(*connectionHandle).loginSystemShell(systemShellPasswd);//connectToSystemShell();
			}
			else
			{
				status =(*connectionHandle).loginSystemShell(systemShellPasswd,true);
			}
			if(!status)
			{
				systemShellLoginFlag = false;
			}
			else {
				systemShellLoginFlag = true;
			}
		}
		//Come out of the systemShell to execute the next NODESHELL command. Due to the limitation of 7-mode, we cant have more than one shell opened over a SSH channel, 
		// If the next command is happend to be Systemshell command, we dont logout from systemshell after executing the current command
		if((cliHandle->getFilerMode()).compare("10-mode")) {

			if(!nextSystemShellCommand) {
				status = (*connectionHandle).logoutSystemShell();
				if(!status)
					commonOutputHandle->writeDataToLogFile("ERROR", nodeIP,"Failed to logout from SystemShell");
			}
		}
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : processFreeBSDShellCmd :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}

void node::stopStatsSamples() 
{
	string command = "node run -node local -command \"priv set -q diag; stats stop -a\"";
	if (connectionHandle->sendCommandToFiler(command)) {
		string response = connectionHandle->readResponseBufferWithPoll(outputHandle);
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "stats stop -a output: " + response);
		if (response.find("No background stats are currently running") == string::npos) {
			commonOutputHandle->writeDataToLogFile("WARNING", nodeIP, "Failed to stop stats samples");
		}
	} else {
		commonOutputHandle->writeDataToLogFile("WARNING", nodeIP, "Connection error during stop stats samples");
	}
}

void node::collectConfigData(boost::barrier *serThreadBar)
{
	try
	{
		getLicenses();
		//enabledOptions();

		if(!(cliHandle->getFilerMode()).compare("10-mode")){
			size_t start = 0;
			string strTemp;
			string tok;
			size_t end;
			string output;
			int index = 0;
			bool firstOccur = true;
			string command = "system show -node local";
			connectionStatus = (*connectionHandle).sendCommandToFiler(command);
			if(connectionStatus)
			{
				string output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
				string tokens[6] = {"Node", "Model", "Serial Number", "Uptime", "System ID", "Health"};
				if(output.compare("")!=0)
				{
					end = output.find("\n", start);
					while (end!= string::npos)
					{
						strTemp = output.substr(start, (end - start));
						size_t found = string::npos;
						if(!strTemp.empty())
							found=strTemp.find(tokens[index]);
						//there are 2 tokens in ouput that can statisfy for system id
						//lets skip "NVRAM System ID"
						if(index == 4 && firstOccur)
						{
							found = string::npos;
							firstOccur = false;
						}
						if (found!=string::npos)
						{
							string dataRes= "";
							size_t colon = strTemp.find(":");
							if(colon != string::npos)
								dataRes = strTemp.substr(colon+1);
							if(index ==0)
								nodeName = dataRes;
							else if(index ==1)
								model = dataRes;
							else if(index ==2)
								serialNumber = dataRes;
							else if(index == 3)
								uptime = dataRes;
							else if(index ==4)
								systemID = dataRes;
							else
								health = dataRes;
							if(index <5)
								index = index + 1;
						}

						start = end + 1;
						if(start < output.length())
							end = output.find("\n", start);
						else
							end = string::npos;
					}
					boost::algorithm::trim(nodeName);
					boost::algorithm::trim(model);
					boost::algorithm::trim(health);
					boost::algorithm::trim(uptime);
					boost::algorithm::trim(systemID);
					boost::algorithm::trim(serialNumber);
				}
			}
			command = "system node image show -node local";
			connectionStatus = (*connectionHandle).sendCommandToFiler(command);
			if(connectionStatus)
			{
				output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
				if(output.compare("")!=0)
				{
					start = 0;
					size_t found;
					do
					{
						end = output.find("\n", start);
						strTemp = output.substr(start, (end - start));
						found = strTemp.find("----");
						start = end + 1;
					}while(found==string::npos);
					end = output.find("\n", start);
					start = end + 1;
					end = output.find("\n", start);

					bool is_current = false;
					while(!is_current)
					{
						strTemp = output.substr(start, (end - start));
						if(!strTemp.empty())
						{
							typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
							boost::char_separator<char> sep(" ");
							tokenizer tokens(strTemp, sep);
							index =0;
							for (tokenizer::iterator tok_iter = tokens.begin();
								tok_iter != tokens.end(); ++tok_iter)
							{
								if(index ==2)
								{
									string imageStr =  *tok_iter;
									boost::algorithm::trim(imageStr);
									if(imageStr.compare("true")==0)
										is_current = true;
								}
								if(index ==3)
									osversion =  *tok_iter;
								index = index + 1;
							}
						}
						start = end + 1;
						if(start < output.length())
							end = output.find("\n", start);
						else
							is_current = true;
					}
					boost::algorithm::trim(osversion);
				}
			}
			command = "node run -node local -command \"priv set -q diag; sysconfig -av\"";
			connectionStatus = (*connectionHandle).sendCommandToFiler(command);
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
			if(output.compare("")!=0) {
				string processors = "";
				char *tok = strtok (const_cast<char*>(output.c_str()),"\n");
				while (tok != NULL) {
					if(strstr(tok, "Processors")) {
						processors = tokenizeString(string(tok), 2);
						boost::algorithm::trim(processors);
						numberOfProcessors = atoi(processors.c_str());
						break;
					}
					tok = strtok (NULL, "\n");
				}
			}

			(*serThreadBar).wait();
		}
		else
		{
			//We shall collect the config data for 7-mode from the output of 'sysconfig -av' command
			string command = "priv set -q diag;sysconfig -av";
			if(legacyModeFlag == false) {
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
			}
			else {
				sendLegacyCommand(command);
				connectionStatus = true;
			}
			if(connectionStatus) {
				char *token;
				string output = "";
				if(legacyModeFlag == false) {
					output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
				}
				else {
					output = collectLegacyData(false);
				}
				if(output.compare("")!=0) {
					int globalReadCounter = 0;
					vector<string> tokenInput;
					token = strtok (const_cast<char*>(output.c_str()),"\n");
					while (token != NULL) {
						/*
						if(globalReadCounter == 4) {
						break;
						}
						*/
						// changed from 4 to 5, to parse for Processors
						if(globalReadCounter == 5) {
							break;
						}
						if(strstr(token, "NetApp Release")) {
							tokenInput.push_back(string(token));
							globalReadCounter++;
						}
						else if(strstr(token, "System ID")) {
							tokenInput.push_back(string(token));
							globalReadCounter++;
						}
						else if(strstr(token, "System Serial Number")) {
							tokenInput.push_back(string(token));
							globalReadCounter++;
						}
						else if(strstr(token, "Model Name")) {
							tokenInput.push_back(string(token));
							globalReadCounter++;
						}
						else if(strstr(token, "Processors")) {
							tokenInput.push_back(string(token));
							globalReadCounter++;
						}
						else
						{
							//do nothing
						}
						token = strtok (NULL, "\n");
					}
					osversion = tokenizeString(tokenInput[0],3);
					systemID  = tokenizeString(tokenInput[1],3);
					serialNumber = tokenizeString(tokenInput[2],4);
					model = tokenizeString(tokenInput[3],3);
					string processors = tokenizeString(tokenInput[4],2);
					boost::algorithm::trim(processors);
					numberOfProcessors = atoi(processors.c_str());
				}
			}
			//Now get the node name
			command = "priv set -q diag; hostname";
			if(legacyModeFlag == false) {
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
			}
			else {
				sendLegacyCommand(command);
			}
			if(connectionStatus) {
				string output = "";
				if(legacyModeFlag == false) {
					output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
				}
				else {
					output = collectLegacyData(false);
				}
				if(output.compare("")!=0) {
					nodeName = output;
					boost::algorithm::trim(nodeName);
				}
			}
			(*serThreadBar).wait();
		}
		getOSVersion();
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : collectConfigData :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}

}
void node::sleepBtwIter(int sampleTime)
{
	boost::xtime xt;
	boost::xtime_get(&xt, boost::TIME_UTC_);
	xt.sec += sampleTime;
	boost::thread::sleep(xt);
}
void node::generateHeader(boost::barrier *serThreadBar)
{
	try
	{
		string headerNote = ("*------------- ");
		headerNote.append(cliHandle->getVersion());
		headerNote.append(" -------------*");
		string header;
		header.append(" \n");
		//print user inputs:
		map<string, vector<string> > dataMap = cliHandle->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");
		//All the below information is meant only for 10-mode
		//if(!(cliHandle->getFilerMode()).compare("10-mode")){
		//Check if the hostname is provided at commandline instead of  IP address
		header.append(printHeader("node-ip", nodeIP, ""));
		header.append(printHeader("node-name", nodeName, ""));
		header.append(printHeader("ONTAP version", osversion, ""));
		header.append(printHeader("model", model, ""));
		//All the below information is meant only for 10-mode
		if(!(cliHandle->getFilerMode()).compare("10-mode")){
			header.append(printHeader("health", health, ""));
			header.append(printHeader("uptime", uptime, ""));
		}
		header.append(printHeader("system id", systemID, ""));
		header.append(printHeader("serial number", serialNumber, ""));
		header.append(printHeader("Number of Processors", boost::lexical_cast<std::string>(numberOfProcessors), ""));
		header.append("\n");
		//}

		(*outputHandle).writeDataToNodeFile(headerNote, header);

		(*serThreadBar).wait();
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : generateHeader :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}

string node::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 node::checkCommandOutput(string command, string cmdOutput)
{
	bool emptyStr = false;
	if(!cmdOutput.empty() && cmdOutput.length() >0)
	{
		size_t start = 0;
		int index = 1;
		size_t end = cmdOutput.find("\n", start);
		while (end!= string::npos && index <= 5)
		{
			start = end + 1;
			end = cmdOutput.find("\n", start);
			index = index + 1;
		}
		if(index < 5)
			emptyStr = true;
	}
	else
		emptyStr = true;

	if(emptyStr)
	{
		string tmp = "Output for command \"" + command + "\" might be empty. It's not necessarily a problem. ";
		commonOutputHandle->writeDataToLogFile("WARNING", nodeIP, tmp);
	}
}

bool node::checkSignal()
{
	/*
	bool status = perfstat::signalStatus();
	if(status)
	{
	commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Received interrupt. Please wait...\n");
	}
	return status;
	*/
	bool status = perfstat::signalStatus();
	int interrupCount = perfstat::getSigCount();	
	if(status)
	{
		// The condition should be changed to if(interrupCount > 2)
		if(interrupCount <= 2) {
			//commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Received interrupt. Please wait...\n");
		}
		else {
			if(legacyModeFlag == false && ((cliHandle->getFilerMode()).compare("10-mode") != 0)) {
				if(systemShellLoginJustOnce == true) {
					connectionHandle->logoutSystemShell();
				}
				connectionHandle->disconnectToFiler();				
			}
			exit(0);
		}
	}	
	return status;
}
void node::processParData(parallelNode *pnode, boost::barrier *parThreadBar, presetMetaData * metaData)
{
	pnode->processParallelCommands(parThreadBar, metaData);
}
void node::startParallelThread(boost::barrier *serThreadBar, int iter)
{
	try {
		boost::thread *timerThread = NULL;
		int numOfParallelThreads = 0;
		/*
		if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
		int localHostParallelCount = localHostObj->getNumberOfParallelCommands();
		numOfParallelThreads += localHostParallelCount;
		}
		// REMOTE HOST COLLECTION 
		if(cliHandle->GetRemoteHostFlag() && hostFlag) {
		int remoteHostCount = (cliHandle->GetRemoteHosts()).size();
		for(int remoteIndex = 0; remoteIndex < remoteHostCount; ++remoteIndex) {
		int remoteHostParallelCount = pRemoteHost[remoteIndex]->getNumberOfParallelCommands();
		numOfParallelThreads += remoteHostParallelCount;
		}
		}
		*/

		vector<presetMetaData> prestatParallelVec = presetHandle.getAllParallelCommands("NODE");
		int numOfParallelCmds = prestatParallelVec.size();
		numOfParallelThreads += numOfParallelCmds;

		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of PARALLEL commands.");

		if(numOfParallelThreads > 0) {
			// Threads for Parallel commands
			boost::barrier parThreadBar(numOfParallelThreads);
			boost::thread_group parallelThreadGroup;
			// NODE Parallel Commands 
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of PARALLEL commands on node.");
			pnode = new parallelNode[numOfParallelCmds];
			for(int i=0; i < numOfParallelCmds; i++) {
				//Workaround to make sure that all the parallel command do not start at the same time to avoid hitting
				//the ceiling of max number of SSH connections per second configuration for C-mode controller
				// Burt 499295
				if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
					if( (i+1)% MAX_PARALLEL_THREAD == 0) {
						sleepBtwIter(1); //sleep for 1 second
					}
				}
				//generate thread id
				string threadId = "thread_" + boost::lexical_cast<std::string>(i);
				pnode[i] = parallelNode(cliHandle, outputHandle, nodeIP, commonOutputHandle,
					connectionHandle->getNodePrompt(), threadId, iter);
				string temp = "Processing command -- " + prestatParallelVec[i].toString();
				commonOutputHandle->writeDataToLogFile("INFO", nodeIP, temp);
				parallelThreadGroup.create_thread(boost::bind(&node::processParData, *this, &pnode[i],
					&parThreadBar, &prestatParallelVec[i]));
			}
			if((cliHandle->getFilerMode()).compare("10-mode")) {
				int maxTime=cliHandle->getSampleTime();
				timerThread = new thread(boost::bind(&node::processParallelTimerData,*this, &maxTime, &parallelThreadGroup));
			}

			if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
				localHostThreadGroup->create_thread(boost::bind(&node::processHostParallels, *this, localHostObj,
					localHostThreadBar));
				// localHostThreadBar->wait();
				// localHostObj->startParallelThread(localHostThreadBar, &parThreadBar, &parallelThreadGroup);
			}
			// REMOTE HOST COLLECTION 
			if(cliHandle->GetRemoteHostFlag() && hostFlag) {
				int remoteHostCount = (cliHandle->GetRemoteHosts()).size();
				for(int remoteIndex = 0; remoteIndex < remoteHostCount; ++remoteIndex) {
					remoteHostThreadGroup->create_thread(boost::bind(&node::processHostParallels, *this, pRemoteHost[remoteIndex],
						remoteHostThreadBar));
					//pRemoteHost[remoteIndex]->startParallelThread(remoteHostThreadBar, &parThreadBar, &parallelThreadGroup);
				}
			}
			parallelThreadGroup.join_all();
			if(cliHandle->GetRemoteHostFlag() && hostFlag) {
				remoteHostThreadGroup->join_all();
			}
			if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
				localHostThreadGroup->join_all();
			}
			if((cliHandle->getFilerMode()).compare("10-mode") && (timerThread != NULL)) {
				timerThread->join();
				delete timerThread;
				timerThread = NULL;
			}
			if(pnode != NULL) {
				delete [] pnode;
			}
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PARALLEL commands.");
			(*serThreadBar).wait();
		}
		else {
			if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
				localHostThreadGroup->create_thread(boost::bind(&node::processHostParallels, *this, localHostObj,
					localHostThreadBar));
				localHostThreadBar->wait();
			}
			// REMOTE HOST COLLECTION 
			if(cliHandle->GetRemoteHostFlag() && hostFlag) {
				int remoteHostCount = (cliHandle->GetRemoteHosts()).size();
				for(int remoteIndex = 0; remoteIndex < remoteHostCount; ++remoteIndex) {
					remoteHostThreadGroup->create_thread(boost::bind(&node::processHostParallels, *this, pRemoteHost[remoteIndex],
						remoteHostThreadBar));
				}
			}
			if(cliHandle->GetRemoteHostFlag() && hostFlag) {
				remoteHostThreadGroup->join_all();
			}
			if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
				localHostThreadGroup->join_all();
			}
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PARALLEL commands.");
			(*serThreadBar).wait(); //just wait in case of no parallel commands.
		}
		seqController->parallelCmdThreadFinish();
		//Now delete all the temp files for parallel commands
		for(int i=0; i<(int)prestatParallelVec.size(); i++) {
			string threadId = "thread_" + boost::lexical_cast<std::string>(i);
			(*outputHandle).removeTempFile(threadId);
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : startParallelThread :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}

void node::processParallelStatsCommands()
{
	try
	{
		bool status = true;
		int numOfIter = cliHandle->getNumberOfIter();
		for(int i=0; i<numOfIter; i++)
		{
			seqController->waitForPreStatsCommands();
			seqController->finishedParallelStats = false;
			//process prestat commands
			status = processParallelPrestatsCommands();
			//check if other prestats commands are done
			seqController->parallelStatsCmdThreadFinish();
			if(!status)
				return;
			seqController->waitParallelCmdThread();
			status = checkSignal();
			if(status)
			{
				return;
			}
			seqController->finishedParallelStats = false;

			//process poststats command
			//We need to set "parallelStatFlag" to true because if we have a situation when the max-run-time/CTRL-C intrrupt occurs during the prestat phase
			//we move the data from the parallelStat temporary file (output.temp) and delete it. As now we are introducing the quick poststat command execution in case of interrupt during prestat,
			//we need to take care of the "availability" of the 'output.temp' file. So now in poststat phase, during the signal check true, we check one more condition i.e. if the processParallelPoststat was already called or not. We achieve this by setting
			//the parallelStatFlag flag.

			parallelStatFlag = true;
			status = processParallelPoststatsCommands();
			seqController->parallelStatsCmdThreadFinish();
			if(!status)
				return;
			//check if other poststats commands are done
			seqController->parallelCmdDone = false;
			//sleep between iter.
			sleepBtwIter(cliHandle->getSampleTimeBtwIter());
		}
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : processParallelStatsData :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}

bool node::processParallelPrestatsCommands()
{
	bool status = true;
	parallelStatFlag = true;
	tempFilePtr = (*outputHandle).createTempFile(fileID);
	vector<presetMetaData> prestatsVec = presetHandle.getAllParallelPrestatsCommands();
	for(int i=0; i<(int)prestatsVec.size(); i++)
	{
		bool sigStat = checkSignal();
		if(sigStat)
			return false;
		status = processParallelStatsData(prestatsVec[i], "PRESTATS");
	}
	(*outputHandle).closeTempFile(tempFilePtr);
	commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PARALLEL_PRESTATS commands.");
	return status;
}
bool node::processParallelPoststatsCommands()
{
	bool status = true;
	parallelStatFlag = true;
	tempFilePtr = (*outputHandle).createTempFile(fileID);
	vector<presetMetaData> poststatsVec = presetHandle.getAllParallelPoststatsCommands();
	for(int i=0; i<(int)poststatsVec.size(); i++)
	{
		bool sigStat = checkSignal();
		if(sigStat)
			return false;
		status = processParallelStatsData(poststatsVec[i], "POSTSTATS");
	}
	(*outputHandle).closeTempFile(tempFilePtr);
	commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of PARALLEL_POSTSTATS commands.");
	return status;
}
bool node::processParallelStatsData(presetMetaData oneCmd, string outputDisplayType)
{
	bool status = true;
	try
	{

		string temp = "Processing command -- ";
		temp.append(oneCmd.toString());
		commonOutputHandle->writeDataToLogFile("INFO", nodeIP, temp);
		string command = oneCmd.getCommand();//generateFullCommand(oneCmd);
		if(command != "" && statConnectionStatus )
		{
			time_t cmdStartTime;
			time(&cmdStartTime);			
			(*statsConnectionHandle).sendCommandToFiler(command);
			string output;
			string data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
			data.append(outputDisplayType + " =-=-=-=-=-= ");
			if(oneCmd.getShortname().compare("")!=0)
				data.append(oneCmd.getShortname());
			else
				data.append(oneCmd.getCommand());

			string totalOutput = data;
			totalOutput.append("\nPERFSTAT_EPOCH: ");
			totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
			totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
			totalOutput.append("\n");
			(*outputHandle).writeDataToTempFile(tempFilePtr, totalOutput);
			status = (*statsConnectionHandle).readResponseFromFilerWithPoll(outputHandle, tempFilePtr);


			//set stats start time
			time_t cmdEndTime;
			time(&cmdEndTime);
			data="\n--- EXE-TIME of : " + oneCmd.getCommand() + " : ";
			data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds\n\n");
			(*outputHandle).writeDataToTempFile(tempFilePtr, data);
			if((int)(cmdEndTime - cmdStartTime) > cmdRunTime)
			{
				longerRuntimeCmd.push_back(oneCmd.toString());
			}
		}
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : processParallelStatsData :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
	return status;
}
bool node::getVfilerData(boost::barrier *serThreadBar)
{
	try
	{
		size_t start = 0;
		string strTemp;
		string tok;
		size_t end;
		string output;
		int index = 0;
		bool firstOccur = true;
		vector<string> vfilerName;
		vector<string> tokenName;
		char *token;
		char *tk;
		string command = "priv set -q diag;vfiler status";
		command = command + "\r";
		if(legacyModeFlag == false) {
			connectionStatus = (*connectionHandle).sendCommandToFiler(command);
		}
		else {
			sendLegacyCommand(command);
			connectionStatus = true;
		}
		if(connectionStatus)
		{
			string output = "";
			if(legacyModeFlag == false) {
				output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
			}
			else {
				output = collectLegacyData(false);
			}

			if(output.compare("")!=0)
			{
				string tmpPrompt = connectionHandle->getNodePrompt(); //need to avoid node prompt to be treated as vfiler name
				token = strtok (const_cast<char*>(output.c_str()),"\n");

				while (token != NULL)
				{

					if(strstr(token, "not licensed"))
					{
						break;
						return false;
					}
					if(!strstr(token,"vfiler0") && !strstr(token,tmpPrompt.c_str()))
					{

						tokenName.push_back(string(token));

					}

					token = strtok (NULL, "\n");

				}
				for(int i=0; i<tokenName.size();i++)
				{
					vfilerName.push_back(tokenizeString(tokenName[i],1));
					boost::algorithm::trim(vfilerName[i]);
				}
			}
		}
		//Now get the vfiler Path for each vfiler
		vector<string> tokenPath;
		for(int i=0;i<vfilerName.size();i++)
		{

			command = "priv set -q diag; vfiler status -r ";
			if(legacyModeFlag == false) {
				command = command + vfilerName[i];
				command = command + "\r";
				connectionStatus = (*connectionHandle).sendCommandToFiler(command);
			}
			else {
				sendLegacyCommand(command);
				connectionStatus = true;
			}				

			if(connectionStatus)
			{
				if(legacyModeFlag == false) {
					output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
				}
				else {
					output = collectLegacyData(false);
				}
				if(output.compare("")!=0)
				{
					token = strtok (const_cast<char*>(output.c_str()),"\n");

					while (token != NULL)
					{

						if(strstr(token,"Path:") && strstr(token,"etc"))

						{

							tokenPath.push_back(string(token));

						}
						token = strtok (NULL, "\n");
					}
				}
			}
		}

		for(int i=0; i< tokenPath.size();i++)
		{

			vfileData[vfilerName[i]] = tokenizeString(tokenPath[i],2);
			boost::algorithm::trim(vfileData[vfilerName[i]]);
		}

		//(*serThreadBar).wait();       // Commented, BURT_562755
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : collectConfigData :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
	return true;
}
#ifdef WIN32
int node::killProcess(char *proc_name)
{

	int pid=0;
	try
	{
		DWORD processes[1024],num_processes,i;
		TCHAR name[1024];
		/* get process list */
		EnumProcesses(processes,sizeof(processes),&num_processes);
		num_processes/=sizeof(DWORD);
		for (i=0;i<num_processes;i++){
			HMODULE module;
			/* get process handle */
			HANDLE hd=OpenProcess(PROCESS_TERMINATE|PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,processes[i]);
			DWORD mod_size;
			if (!hd) {
				continue;
			}
			/* get process name */
			EnumProcessModules(hd,&module,sizeof(module),&mod_size);
			GetModuleBaseName(hd,module,name,sizeof(name)/sizeof(TCHAR));

			/* check if this was an rsh? if so, attempt to kill */
			if (!strncmp(name,proc_name,strlen(proc_name))){
				pid=processes[i];
				cout<<"Terminating the process: "<<name<< " with PID: "<<pid<<endl;
				TerminateProcess(hd,1);
			}
			CloseHandle(hd);
		}
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : killProcess :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
	return pid;
}
void node::killRshOrSshProcess()
{
	if( !cliHandle->getSSHFlag())
	{
		//kill rsh.exe used for RSH parallel commands
		killProcess("rsh.exe");
	}
	else
	{
		//kill plink.exe used for SSH parallel commands
		killProcess("plink.exe");
	}
}
#else
void node::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 tmpResult_ |awk '{print $2}'`;do  kill -9 $i ; done;";
	std::system(command);
}
#endif
void node::processParallelTimerData(int* maxTime, boost::thread_group *thrdGroup)
{
	try
	{
		boost::xtime currTime;
		boost::xtime_get(&currTime, boost::TIME_UTC_);
		if(*maxTime < 4)
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "The timeout for parallel commands is too less. Gmon profile command might not execute completely");
		currTime.sec += ((*maxTime)*60);
		boost::thread::sleep(currTime);

		commonOutputHandle->writeDataToLogFile("STATUS", nodeIP, "Timed OUT !! for parallel commands . ");
		killRshOrSshProcess();
	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : killProcess :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}
string node::tokenizeString(string tmpstr, int pos)
{
	int tmpCount=1;
	char *tk;
	string result;
	tk = strtok (const_cast<char*>(tmpstr.c_str())," ");
	while(tk != NULL)
	{
		if(tmpCount == pos){
			result = string(tk);
		}
		tk = strtok (NULL, " ");
		tmpCount++;
	}
	return result;
}

void node::startSwitchThread(boost::barrier *serThreadBar, int iter)
{
	try
	{
		//We collect switch data only for the one controller whichever comes first in the nodes list
		if(switchFlag && cliHandle->getSwitchFlag())
		{
			vector<string> tmpvec = cliHandle->getTargetSwitches();
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of SWITCH commands.");
			boost::barrier parThreadBar((int)tmpvec.size());
			boost::thread_group switchThreadGrp;

			for(int i=0; i< (int)tmpvec.size(); i++)
			{
				switchThreadGrp.create_thread(boost::bind(&node::processSwitchData, *this, &tswitch[i],
					&parThreadBar, iter));
			}

			switchThreadGrp.join_all();

			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of SWITCH commands.");
		}
		//(*serThreadBar).wait();

	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : startSwitchThread :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}
void node::processSwitchData(targetSwitch *tswitch, boost::barrier *parThreadBar, int iterNum)
{
	// Commenting, as it is called from the threadHandler as a seperate thread
	// (*tswitch).processCommands(parThreadBar,iterNum);
}
void node::startRemoteHostThread(int iter)
{
	try {
		//We collect Remote Host data only for the one controller whichever comes first in the nodes list
		if(hostFlag && cliHandle->GetRemoteHostFlag()) {
			vector<string> tmpvec = cliHandle->GetRemoteHosts();
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of Remote Host Commands.");
			for(int i=0; i< (int)tmpvec.size(); i++) {
				remoteHostThreadGroup->create_thread(boost::bind(&node::processHostData, *this, pRemoteHost[i], remoteHostThreadBar, iter));
			}
			//hostThreadGroup.join_all();
			//commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of Remote Host commands.");
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : startRemoteHostThread :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}
void node::startLocalHostThread(int iter)
{
	try {
		//We collect Remote Host data only for the one controller whichever comes first in the nodes list
		if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
			commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Starting processing of Local Host Commands.");
			localHostThreadGroup->create_thread(boost::bind(&node::processHostData, *this, localHostObj, localHostThreadBar, iter));
			//localHostThreadGroup.join_all();
			//commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Finished processing of Local Host commands.");
		}
	}
	catch(std::exception& e) {
		string tmp = "Exception : node : startLocalHostThread :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}
void node :: processHostData(host* pHost, boost::barrier *parThreadBar, int iterNum)
{
	(*pHost).ProcessCommands(iterNum, parThreadBar);
}

void node :: prestatsSKtrace()
{
	try
	{

		string tmpCommand;
		string fileName;
		int iter = currentIteration; //set the iteration number
		vector <string> commandAttributes;
		commandAttributes.push_back("PRESTATS");
		commandAttributes.push_back("PERF");
		commandAttributes.push_back("NODE");
		commandAttributes.push_back("*");
		commandAttributes.push_back("*");
		commandAttributes.push_back("SYSTEMSHELL");
		commandAttributes.push_back("");
		commandAttributes.push_back("");
		commandAttributes.push_back("sktrace enable");
		commandAttributes.push_back("true");

		//To make sure the sktrace buffers contain the first set of data, traces should not be wrapped on
		tmpCommand = "sudo sysctl sysvar.sktrace.nowrap=1";
		commandAttributes[7] = "sktrace nowrap on";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_(commandAttributes);
		//process the command
		processOneCommand(sktraceCommand_,true);

		//Disable the sktlogd so that the traces are collected without any gaps
		tmpCommand = "sudo sysctl sysvar.sktrace.mlog=0";
		commandAttributes[7] = "sktrace mlog off";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_0(commandAttributes);
		//process the command
		processOneCommand(sktraceCommand_0,true);

		//presetMetaData sktraceCommand(commandAttributes);
		//Enable traces for all the modules provided at commandline
		map<string,int> tmpSKpointMap = cliHandle->getAllSktracePoints();
		map<string,int>::const_iterator myMapIter = tmpSKpointMap.begin();

		while(myMapIter != tmpSKpointMap.end())
		{
			tmpCommand = "sudo sysctl sysvar.sktrace." + myMapIter->first + "_enable=" + boost::lexical_cast<std::string>(myMapIter->second);
			//Now prepare sysctl command to enable tracing
			commandAttributes[7] = "sktrace enable " + myMapIter->first;
			commandAttributes[8] = tmpCommand;
			presetMetaData sktraceCommand_1(commandAttributes);
			//process the command
			processOneCommand(sktraceCommand_1,true);

			myMapIter++;
		}

		//Now sleep for max 60 seconds before stopping the sktrace collection
		sleepBtwIter(cliHandle->getSampleTimeBtwIter());
		//Now prepare the sktrace file and send the command to the controller
		fileName = "/mroot/etc/log/sktrace_perfstat_Iter_";
		fileName = fileName + boost::lexical_cast<std::string>(iter);
		tmpCommand = "sudo sysctl sysvar.sktrace.filename=" + fileName;
		commandAttributes[7] = "sktrace file rename";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_2(commandAttributes);
		processOneCommand(sktraceCommand_2,true);
		//Now disable the sktrace and flush the buffers onto the trace files.
		myMapIter = tmpSKpointMap.begin();

		while(myMapIter != tmpSKpointMap.end())
		{
			tmpCommand = "sudo sysctl sysvar.sktrace." + myMapIter->first + "_enable=0 " ;
			//Now prepare sysctl command to enable tracing
			commandAttributes[7] = "sktrace disable "+ myMapIter->first;
			commandAttributes[8] = tmpCommand;
			presetMetaData sktraceCommand_3(commandAttributes);
			//process the command
			processOneCommand(sktraceCommand_3,true);

			myMapIter++;
		}
		tmpCommand = "sudo sysctl sysvar.sktrace.dump=1";
		commandAttributes[7] = "sktrace dump";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_4(commandAttributes);
		processOneCommand(sktraceCommand_4,true);

		//Revert back the nowrap settings
		tmpCommand = "sudo sysctl sysvar.sktrace.nowrap=0";
		commandAttributes[7] = "sktrace nowrap off";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_5(commandAttributes);
		//process the command
		processOneCommand(sktraceCommand_5,true);

		//Enable the sktlogd 
		tmpCommand = "sudo sysctl sysvar.sktrace.mlog=1";
		commandAttributes[7] = "sktrace mlog off";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_6(commandAttributes);
		//process the command
		processOneCommand(sktraceCommand_6,true);

		//Now finall collect the 'kldstat' output as well.
		tmpCommand = "kldstat";
		commandAttributes[7] = "kldstat";
		commandAttributes[8] = tmpCommand;
		presetMetaData sktraceCommand_7(commandAttributes);
		processOneCommand(sktraceCommand_7,false);

	}
	catch(std::exception& e)
	{
		string tmp = "Exception : node : prestatsSKtrace :";
		tmp.append(e.what());
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, tmp);
	}
}

void node :: getLicenses()
{
	licenses["FCP"] = false;
	licenses["ISCSI"] = false;
	licenses["FLEX_CACHE"] = false;
	licenses["CLUSTER"] = false;
	licenses["CF"] = false;
	licenses["CIFS"] = false;
	licenses["NETCACHE"] = false;
	licenses["SNAPVAULT"] = false;
	licenses["SNAPMIRROR"] = false;
	licenses["VFILER"] = false;
	licenses["A_SIS"] = false;
	licenses["NFS"] = false;
	licenses["LIGHT_RUN"] = false;

	string command = "";
	bool bcmode = false;
	if(!(cliHandle->getFilerMode()).compare("10-mode")) {
		bcmode = true;
	}
	if(bcmode == true) {
		command = "system license show";
	}
	else {
		command = "priv set -q diag;license";
	}
	if(legacyModeFlag == false) {
		connectionStatus = connectionHandle->sendCommandToFiler(command);
	}
	else {
		connectionStatus = true;
		sendLegacyCommand(command);
	}
	if(connectionStatus) {
		string output = "";
		if(legacyModeFlag == false) {
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
		}
		else {
			output = collectLegacyData(false);
		}
		if(!output.empty()) {
			vector<string> allLicenses = cliHandle->tokenizeString(output, "\n");
			bool bcmodeStart = false;
			for(vector<string>::iterator it = allLicenses.begin(); it < allLicenses.end(); ++it) {
				string currLicense = *it;
				boost::algorithm::trim(currLicense);
				if(currLicense.find(command) != string::npos ||
					currLicense.find("entries were displayed") != string::npos) {
						continue;
				}
				if(bcmode == false) {
					if(currLicense.find("not licensed") != string::npos) {
						continue;
					}
				}
				else {
					if(currLicense.find("-----") != string::npos) {
						bcmodeStart = true;
						continue;
					}
					if(bcmodeStart == false) {
						continue;
					}
				}
				vector<string> licenseString = cliHandle->tokenizeString(currLicense, " ");
				if(licenseString.size() > 1) {
					string licenseName = licenseString[0];
					boost::algorithm::trim(licenseName);
					std::transform(licenseName.begin(), licenseName.end(), licenseName.begin(), (int(*)(int))std::toupper);
					if(licenseName.compare("FLEXCACHE_NFS") == 0 || licenseName.compare("FLEX_CACHE") == 0) {
						licenseName = "FLEX_CACHE";
					}
					else if(licenseName.compare("SV_ONTAP_PRI") == 0 || licenseName.compare("SV_ONTAP_SEC") == 0) {
						licenseName = "SNAPVAULT";
					}
					else if(licenseName.compare("MULTISTORE") == 0 || licenseName.compare("VFILER") == 0) {
						licenseName = "VFILER";
					}
					else if(licenseName.compare("SNAPMIRROR") == 0 || licenseName.compare("SNAPMIRROR_DP") == 0) {
						licenseName = "SNAPMIRROR";
					}
					else {
						// for future 
					}
					licenses[licenseName] = true;
				}
			}
			if(licenses["FLEX_CACHE"] != true) {
				licenses["FLEX_CACHE"] = enabledOptions("flexcache");
			}
			if(licenses["SNAPMIRROR"] == true) {
				//vector<string> safeVols;
				safeVols.clear();
				registryWalk("snapmirrored", safeVols);
			}
		}
	}
}

bool node :: enabledOptions(string opt)
{
	bool bresult = false;
	string command = "";
	string optionCommand = opt + ".enable";
	if(!(cliHandle->getFilerMode()).compare("10-mode")) {
		command = "node run -node local -command \"priv set -q diag;options " + optionCommand + "\"";
	}
	else {
		command = "priv set -q diag;options " + optionCommand;
		command = command+'\r';
	}
	if(legacyModeFlag == false) {
		connectionStatus = (*connectionHandle).sendCommandToFiler(command);
	}
	else{
		sendLegacyCommand(command);
		connectionStatus = true;
	}
	if(connectionStatus) {
		string output = "";
		if(legacyModeFlag == false) {
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
		}
		else {
			output = collectLegacyData(false);
		}
		if(!output.empty()) {
			char *token = strtok (const_cast<char*>(output.c_str()),"\n");
			while (token != NULL) {
				if(strstr(token, optionCommand.c_str())) {
					if(string(token).find("No such option") != string::npos ||
						string(token).find("There are no entries") != string::npos) {
							bresult = false;
					}
					else {
						string value = tokenizeString(string(token), 2);
						boost::algorithm::trim(value);
						bresult = (value.compare("on") == 0) ? true: false;
					}
					break;
				}
				token = strtok (NULL, "\n");
			}
		}
	}
	return bresult;
}

/*
cases need to be checked.
1. All, (test for *)
2. >= 8.0 && <= 8.0P4
3. >= 8.0P5 && <= 8.0x		???
4. >= 8.0P5 && < 8.1x
5. >= 8.0 && < 8.1x
6. >= 8.1x
*/
// map functions to help with os verison checking
bool node::os_gt(int a, int b) { return(a > b); }
bool node::os_gte(int a, int b) { return(a >= b); }
bool node::os_lt(int a, int b) { return(a < b); }
bool node::os_lte(int a, int b) { return(a <= b); }
bool node::os_eq(int a, int b) { return(a == b); }
bool node::os_neq(int a, int b) { return(a != b); }

// run some version check operators dynamically
bool node::dynamicVersionCheck(string cmdVersion) {
	typedef bool (node::*os_check)(int, int);
	map<string, os_check> os_functions;
	os_functions[">"] = &node::os_gt;
	os_functions[">="] = &node::os_gte;
	os_functions["<"] = &node::os_lt;
	os_functions["<="] = &node::os_lte;
	os_functions["="] = &node::os_eq;
	os_functions["!="] = &node::os_neq;
	string versionOp = getCmdVersionOperator(cmdVersion);
	if (os_functions.find(versionOp) != os_functions.end()) {
		os_check f = os_functions[versionOp];
		return (this->*f)(nosVersion, getCmdVersionNum(cmdVersion));
	} else {
		string msg = "unknown version operator '" + versionOp + "'' in preset entry: " + cmdVersion;
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, msg);
		commonOutputHandle->writeDataToConsole("ERROR", nodeIP, msg);
		return false;
	}
}

bool node :: isFilerVersionJustified(presetMetaData metaData)
{
	// Newly added
	// >=8.1 and <8.1.1
	// <=8.1
	// >=8.1.1
	// >=8.1.1 and <8.2.0
	// >=8.2.0
	string filerVersions[] = {"*",                                                                  // ALL
		">=8.0 AND <=8.0P4", ">=8.0P5 AND <8.1X", ">=8.0P5 AND <=8.0X",         //BR Patches
		">=8.0 AND <8.1X",                                                      // BR
		">=8.1", ">=8.1 AND <8.1.1", "<8.1.1", ">=8.1.1", ">=8.1.1 AND <8.2.0",           // RR
		">=8.2.0", "<8.1X"};				//SN

	bool bfilerVersion = false;
	string cmdVersion = metaData.getOS();
	std::transform(cmdVersion.begin(), cmdVersion.end(), cmdVersion.begin(), (int(*)(int))std::toupper);
	int nchoice = -1;

	if(cmdVersion.compare(filerVersions[0]) == 0) {
		nchoice = 0;
	}
	else if(cmdVersion.compare(filerVersions[1]) == 0) {
		nchoice = 1;
	}
	else if(cmdVersion.compare(filerVersions[2]) == 0) {
		nchoice = 2;
	}
	else if(cmdVersion.compare(filerVersions[3]) == 0) {
		nchoice = 3;
	}
	else if(cmdVersion.compare(filerVersions[4]) == 0) {
		nchoice = 4;
	}
	else if(cmdVersion.compare(filerVersions[5]) == 0) {
		nchoice = 5;
	}
	else if(cmdVersion.compare(filerVersions[6]) == 0) {
		nchoice = 6;
	}
	else if(cmdVersion.compare(filerVersions[7]) == 0) {
		nchoice = 7;
	}
	else if(cmdVersion.compare(filerVersions[8]) == 0) {
		nchoice = 8;
	}
	else if(cmdVersion.compare(filerVersions[9]) == 0) {
		nchoice = 9;
	}
	else if(cmdVersion.compare(filerVersions[10]) == 0) {
		nchoice = 10;
	}
	else if(cmdVersion.compare(filerVersions[11]) == 0) {
		nchoice = 11;
	}
	else {
		nchoice = -1;
	}
	switch(nchoice) {
		// ALL FILERS
		case 0: {
			bfilerVersion = true;
			break;
				}
				//>=8.0 and <=8.0p4
		case 1: {
			if(nosVersion >= 8000 && nosVersion <= 8004) {
				bfilerVersion = true;
			}
			break;
				}
				//>=8.0p5 and <8.1x
		case 2: {
			if(nosVersion >= 8005 && nosVersion < 8100) {
				bfilerVersion = true;
			}
			break;
				}
				//>=8.0p5 and <=8.0x, not clear with this case
		case 3: {
			if(nosVersion >= 8005 && nosVersion <= 8020) {
				bfilerVersion = true;
			}
			break;
				}
				//>=8.0 and <8.1x
		case 4: {
			if(nosVersion >= 8000 && nosVersion < 8100) {
				bfilerVersion = true;
			}
			break;
				}
				//>=8.1
		case 5: {
			if(nosVersion >= 8100) {
				bfilerVersion = true;
			}
			break;
				}
				// >=8.1 AND <8.1.1, RR.0
		case 6: {
			if((nosVersion >= 8100) && (nosVersion < 8110)) {
				bfilerVersion = true;
			}
			break;
				}
				// <8.1.1, BR and RR.0
		case 7: {
			if(nosVersion < 8110) {
				bfilerVersion = true;
			}
			break;
				}
				// >=8.1.1
		case 8: {
			if(nosVersion >= 8110) {
				bfilerVersion = true;
			}
			break;
				}
				// >=8.1.1 AND <8.2.0
		case 9: {
			if((nosVersion >= 8110) && (nosVersion < 8200)) {
				bfilerVersion = true;
			}
			break;
				}
				// >=8.2.0
		case 10: {
			if(nosVersion >= 8200) {
				bfilerVersion = true;
			}
			break;
				 }
				 // <8.1
		case 11: {
			if(nosVersion < 8100) {
				bfilerVersion = true;
			}
			break;
		}
		default: {
			bfilerVersion = dynamicVersionCheck(cmdVersion);
			break;
		}
	}
	return bfilerVersion;
}

string node::getCmdVersionOperator(string cmdVersion)
{
	std::size_t start = cmdVersion.find_first_of("0123456789");
	return(cmdVersion.substr(0, start));
}

int node::getCmdVersionNum(string cmdVersion)
{
	// Remove last . char if applicable
	size_t num_periods = count(cmdVersion.begin(), cmdVersion.end(), '.');
	if (num_periods > 1) {
		cmdVersion.erase(cmdVersion.find_last_of('.'), 1);
	}
	// Now convert the str to float, multiply X 1000 and return as int
	std::size_t start = cmdVersion.find_first_of("0123456789");
	size_t end = cmdVersion.size() - start;
	return (atof(cmdVersion.substr(start, end).c_str()) * 1000);
}

int node::getNumericalOSValue(string version)
{
	// Convert the dotted string into an integer value
	int osVal = 0;
	for(size_t index = 0; index < version.size(); ++index) {
		string ch = version.substr(index, 1);
		if(ch.compare(".") == 0) {
			continue;
		} else if (isalpha(ch[0])) {
			break;
		}
		int nVal = atoi(ch.c_str());
		osVal = (osVal * 10) + nVal;
	}
	if(osVal != 0) {
		// Version matching logic is expecting to get a numerical val in the thousands
		if (osVal < 100) {
			return osVal * 100;
		} else if (osVal < 1000) {
			return osVal * 10;
		} else {
			return osVal;
		}
	} else {
		// TODO: this is an error
		return 0;
	}
}


// BURT 488816
void node::getOSVersion()
{
	string tempOSVersion = osversion;
	boost::algorithm::trim(tempOSVersion);
	string version = "";
	const int lengthOfVersion = 7;
	int position = tempOSVersion.find("8.");
	// check for ONTAP9
	if (position == string::npos) {
		position = tempOSVersion.find("9.");
	}
	if(position != string::npos) {
		// Get the ONTAP version 
		// Read 7 characters from the string starting from the first 8 or 9
		version = tempOSVersion.substr(position, lengthOfVersion);
		std::transform(version.begin(), version.end(), version.begin(), (int(*)(int))std::toupper);
		nosVersion = getNumericalOSValue(version);
	}
	else {
		std::transform(tempOSVersion.begin(), tempOSVersion.end(), tempOSVersion.begin(), (int(*)(int))std::toupper);
		if(tempOSVersion.find("ROLLINGROCK") != string::npos) {
			nosVersion = 8100;          // RR.0
		} else if(tempOSVersion.find("SIERRANEVADA") != string::npos) {
			nosVersion = 8200;          // SN.0
		} else if (tempOSVersion.find("FULLSTEAM") != string::npos) {
			nosVersion = 8300;          // FS.0
		} else if (tempOSVersion.find("LONGBOARD") != string::npos) {
			nosVersion = 9000;          // LB.0
		}
	}
	ostringstream convert;
	convert << nosVersion;
	string debug_msg = "Numerical ONTAP version=" + convert.str();
	commonOutputHandle->writeDataToLogFile("DEBUG", nodeIP, debug_msg);
}

bool node :: isCommandValid(presetMetaData metaData)
{
	// TODO: update to handle MODE
	// TODO: make sure this gets called for custom preset
	bool bvalidCommand = false;
	if(metaData.getHardware() == "NODE" && isFilerVersionJustified(metaData) && isLicenseVerified(metaData)) {
		bvalidCommand = true;
	}
	return bvalidCommand;
}

void node :: getValidFilerCommands()
{
	vector<presetMetaData> presetCmds = presetHandle.getAllPresetCommands();
	vector<presetMetaData> presetCmdsTmp;
	presetCmdsTmp.clear();
	for(vector<presetMetaData>::iterator iter = presetCmds.begin(); iter != presetCmds.end(); ++iter) {
		bool brunStatus = true;
		presetMetaData metaData = (*iter);
		string command = metaData.getCommand();
		commonOutputHandle->writeDataToLogFile("DEBUG", nodeIP, "Checking validity of cmd=" + command);
		// BURT 534546
		if((command.find("sysstat -M") != string::npos ||
			command.find("profile") != string::npos) && numberOfProcessors <= 1) {
				brunStatus = false;
		}
		string cmdRunStatus = metaData.getCmdRunStatus();
		commonOutputHandle->writeDataToLogFile("DEBUG", nodeIP, command + " run cmdRunStatus=" + cmdRunStatus);
		std::transform(cmdRunStatus.begin(), cmdRunStatus.end(), cmdRunStatus.begin(), (int(*)(int))std::toupper);
		if(cmdRunStatus.compare("TRUE") == 0) {
			if(brunStatus == true) {
				commonOutputHandle->writeDataToLogFile("DEBUG", nodeIP, command + " calling isCommandValid");
				brunStatus = isCommandValid(metaData);
			}
			string status = (brunStatus == false) ? "false" : "true";
			commonOutputHandle->writeDataToLogFile("DEBUG", nodeIP, command + " final status=" + status);
			metaData.setCmdRunStatus(status);
		} 
		string lic = metaData.getLicense();
		commonOutputHandle->writeDataToLogFile("DEBUG", nodeIP, command + " lic=" + lic);
		if(brunStatus == true && licenses["SNAPMIRROR"] == true && 
			safeVols.size() > 0 && lic.compare("SNAPMIRROR") == 0) {
				if(command.compare("qtree stats") == 0 || command.compare("qtree stats -z") == 0) {
					for(size_t index = 0; index < safeVols.size(); ++index) {
						string statCommand = command + " ";
						statCommand = statCommand + safeVols.at(index);
						vector<string> data;
						data.push_back(metaData.getSection());
						data.push_back("PERF");
						data.push_back("NODE");
						data.push_back("*");
						data.push_back("SNAPMIRROR");
						data.push_back(metaData.getShell());
						data.push_back("");
						data.push_back("");
						data.push_back(statCommand);
						data.push_back("true");
						presetMetaData metaCommand = presetMetaData(data);
						presetCmdsTmp.push_back(metaCommand);
					}
					metaData.setCmdRunStatus("false");
				}
		}
		presetCmdsTmp.push_back(metaData);
	}
	presetHandle.setAllPresetCommands(presetCmdsTmp);
}

void node :: registryWalk(string strToFind, vector<string>& safeVols)
{
	string command = "";
	if(!(cliHandle->getFilerMode()).compare("10-mode")) {
		command = "node run -node local -command \"priv set -q diag; registry walk options.vols\"";
	}
	else {
		command = "priv set -q diag; registry walk options.vols";
		command = command + '\r';
	}
	if(legacyModeFlag == false) {
		connectionStatus = connectionHandle->sendCommandToFiler(command);
	}
	else {
		sendLegacyCommand(command);
		connectionStatus = true;
	}
	if(connectionStatus) {
		string output = "";
		if(legacyModeFlag == false) {
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
		}
		else {
			output = collectLegacyData(false);
		}
		if(!output.empty()) {
			char *token = strtok (const_cast<char*>(output.c_str()),"\n");
			while (token != NULL) {
				if(string(token).find(strToFind) != string::npos) {
					string strToIncl = strToFind + "=on";
					if(string(token).find(strToIncl) == string::npos) {
						vector<string> safevols = cliHandle->tokenizeString(string(token), ".");
						if(safevols.size() >= 3) {
							safeVols.push_back(safevols[2]);
						}
					}
				}
				token = strtok (NULL, "\n");
			}
		}
	}
}

bool node :: isLicenseVerified(presetMetaData metaData)
{
	// Handling only the cases of either union or intersection not both
	vector<string> licensesInCmd;
	bool blicense = true;
	string cmdLicense = metaData.getLicense();
	if(cmdLicense.compare("*") == 0) {
		blicense = true;
	}
	else {
		// A&&B || C&&D
		// A||B && C||D
		std::transform(cmdLicense.begin(), cmdLicense.end(), cmdLicense.begin(), (int(*)(int))std::toupper);
		if(cmdLicense.find("||") != string::npos) {
			vector<string> licenseList = cliHandle->tokenizeString(cmdLicense, "||");
			// A&&B||C&&D   AND A||B
			if(licenseList.size() == 2) {
				for(vector<string> :: iterator it = licenseList.begin(); it != licenseList.end(); ++it) {
					string info = *it;
					boost::algorithm::trim(info);
					if(info.find("&&") != string::npos) {
						vector<string> data = cliHandle->tokenizeString(info, "&&");
						string lic = "";
						for(int i = 0; i < data.size(); ++i) {
							string trimData = data.at(i);
							boost::algorithm::trim(trimData);
							if(i != data.size() - 1) {
								lic = lic + trimData + ",";
							}
							else {
								lic = lic + trimData;
							}
						}
						if(!lic.empty()) {
							licensesInCmd.push_back(lic);
						}
					}
					else {
						licensesInCmd.push_back(info);
					}
				}
			}
			// A||B&&C||D
			if(licenseList.size() == 3) {
				string secondVal = licenseList.at(1);
				if(secondVal.find("&&") != string::npos) {
					vector<string> vals = cliHandle->tokenizeString(secondVal, "&&");
					if(vals.size() == 2) {
						string first = vals.at(0);
						string second = vals.at(1);
						boost::algorithm::trim(first);
						boost::algorithm::trim(second);
						string res = licenseList[0] + ",";
						res += second;
						licensesInCmd.push_back(res);  //A&&C
						res = first + ",";
						res += licenseList[2];
						licensesInCmd.push_back(res); //B&&D
						res = licenseList[0] + ",";
						res += licenseList[2];
						licensesInCmd.push_back(res); //A&&D
						res = first + ",";
						res += second;
						licensesInCmd.push_back(res); //B&&C
					}
				}
			}
		}
		else if(cmdLicense.find("&&") != string::npos) {
			vector<string> data = cliHandle->tokenizeString(cmdLicense, "&&");
			string lic = "";
			for(int i = 0; i < data.size(); ++i) {
				string trimData = data.at(i);
				boost::algorithm::trim(trimData);
				if(i != data.size() - 1) {
					lic = lic + trimData + ",";
				}
				else {
					lic = lic + trimData;
				}
			}
			if(!lic.empty()) {
				licensesInCmd.push_back(lic);
			}
		}
		/*else if(cmdLicense.find("!") != string::npos) {
		}*/
		else {
			licensesInCmd.push_back(cmdLicense);
		}

		for(int index = 0; index < licensesInCmd.size(); ++index) {
			string lic = licensesInCmd.at(index);
			int pos = 0;
			if((pos = lic.find(",")) != string::npos) {
				vector<string> lics = cliHandle->tokenizeString(lic, ",");
				for(int i = 0; i < lics.size(); ++i) {
					string startVal = (lics.at(i)).substr(0, 1);
					// Check for negation to see whether the license is present or not.
					// If the license is present, then exit as the condition is violated
					// dont include this command in the list of commands to be executed...
					if(startVal.compare("!") == 0) {
						startVal = (lics.at(i)).substr(1);
						if(licenses[startVal] == true) {
							blicense = false;
							break;
						}
						else {
							blicense = true;
						}
					}
					else if(licenses[lics[i]] != true) {
						blicense = false;
						// We are breaking of this coz any of the one license is not present
						// as we are checking the case of AND for licenses
						break;
					}
					else {
						blicense = true;
					}
				}
			}
			else {
				string startVal = lic.substr(0, 1);
				// Check for negation to see whether the license is present or not.
				// If the license is present, then exit as the condition is violated
				// dont include this command in the list of commands to be executed...
				if(startVal.compare("!") == 0) {
					startVal = lic.substr(1);
					if(licenses[startVal] == true) {
						blicense = false;
					}
					else {
						blicense = true;
						break;
					}
				}
				else if(licenses[lic] == true) {
					blicense = true;
					// We are breaking of this coz any of the one license is present
					// as we are checking the case of OR for licenses
					break;
				}
				else {
					blicense = false;
				}
			}
		}
	}

	return blicense;
}

bool node :: is7ModeSystemShell()
{
	bool bres = false;
	if((cliHandle->getFilerMode()).compare("10-mode") != 0) {
		// bres = (systemShellLoginJustOnce == true) ? true : false;
		bres = (systemShellLoginFlag == true) ? true : false;
	}
	return bres;
}

connectionHandler* node :: getConnectionHandle() const
{
	return connectionHandle;
}

bool node :: runHostPrestats(boost::barrier *serThreadBar, int iterNum,
	bool &blocal, bool &bremote, bool& quickFlag)
{
	if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
		startLocalHostThread(iterNum);
		localHostThreadGroup->join_all();
		if(localHostObj->getQuickPoststatsRunFlag() == true) {
			quickFlag = true;
			blocal = true;
			bremote = false;
			//localHostObj->setQuickPoststatsRunFlag(true);
			return false;
		}
	}
	// REMOTE HOST COLLECTION 
	if(cliHandle->GetRemoteHostFlag() && hostFlag) {
		startRemoteHostThread(iterNum);
		remoteHostThreadGroup->join_all();
		int remoteHostSize = (cliHandle->GetRemoteHosts()).size();
		bool bres = false;
		for(int index = 0; index < remoteHostSize; ++index) {
			bres = pRemoteHost[index]->getQuickPoststatsRunFlag();
			if(bres == true) {
				break;
			}
		}
		if(bres == true) {
			quickFlag = true;
			blocal = true;
			bremote = true;
			if(hostFlag && !cliHandle->getHostOrFilerFlag()) {
				localHostObj->setQuickPoststatsRunFlag(true);
			}
			// No need to do this check.. But, for clarity
			for(int remoteIndex = 0; remoteIndex < remoteHostSize; ++remoteIndex) {
				pRemoteHost[remoteIndex]->setQuickPoststatsRunFlag(true);
			}
			return false;
		}
	}
	return true;
}

void node :: processHostPoststats(host* hostObj, boost::barrier *threadBar, int iterNum)
{
	hostObj->processPoststats(threadBar, iterNum);
}

void node :: processHostParallels(host* hostObj, boost::barrier *threadBar)
{
	hostObj->StartParallelThread(threadBar);
}

void node :: parseStatisticsShowOutput(map<string, vector<string> > &statisticsShowMap)
{
	string fileName = outputHandle->getNodeDataDir();
	fileName.append("/output.cluster_stats_show");
	ifstream inFile;
	inFile.open(fileName.c_str());
	if(inFile.is_open()) {
		bool bstartParsing = false;
		bool bheaderPart = false;
		bool bfirst = true;
		string currDataLine = "";
		string tempData = "";
		string currObject = "";
		string prevObject = "";
		string prevDataLine = "";
		while (!inFile.eof() ) {
			getline(inFile,currDataLine);
			// Check if the Node data arrives
			if(currDataLine.find("Node:") != string::npos) {
				break;
			}
			// Check to start the parsing
			if(bstartParsing == false) {
				currDataLine += "\n";
				tempData += currDataLine;
				if(currDataLine.find("------") != string::npos) {
					bstartParsing = true;
				}
			}
			else {
				string statInfo = currDataLine;
				// Check for the header part in the output
				if(bheaderPart == true) {
					statInfo += "\n";
					tempData += statInfo;
					if(statInfo.find("------") != string::npos) {
						bheaderPart = false;
					}
					continue;
				}
				if(statInfo.find("Cluster:") != string::npos) {
					bheaderPart = true;
					statInfo += "\n";
					tempData += statInfo;
					continue;
				}
				if(currDataLine.find(".") == string::npos) {
					currDataLine += "\n";
					tempData = tempData + currDataLine;
					continue;
				}
				prevObject = currObject;
				vector<string> statsData = cliHandle->tokenizeString(statInfo, ".");
				if(statsData.size() > 0) {
					currObject = statsData.at(0);               // Object Name
					boost::algorithm::trim(currObject);
				}
				if(bfirst == true) {
					prevObject = currObject;
					bfirst = false;
				}
				if(prevObject.compare(currObject) == 0) {
					if(!tempData.empty()) {
						statisticsShowMap[currObject].push_back(tempData);
						tempData = "";
					}
					statisticsShowMap[currObject].push_back(currDataLine);
					prevDataLine = currDataLine;
				}
				else {
					if(tempData.empty()) {
						tempData = currDataLine;
					}
					else {
						string tempObj = "";
						string prevObj = "";
						string currObj = "";
						vector<string> currInfo = cliHandle->tokenizeString(statInfo, ".");
						if(currInfo.size() > 0) {
							currObj = currInfo.at(0);
							boost::algorithm::trim(currObj);
						}
						vector<string> prevInfo = cliHandle->tokenizeString(prevDataLine, ".");
						if(prevInfo.size() > 0) {
							prevObj = prevInfo.at(0);
							boost::algorithm::trim(prevObj);
						}
						vector<string> tempInfo = cliHandle->tokenizeString(tempData, ".");
						if(tempInfo.size() > 0) {
							tempObj = tempInfo.at(0);
							boost::algorithm::trim(tempObj);
						}
						if(tempObj.compare(currObj) == 0) {
							statisticsShowMap[currObj].push_back(tempData);
							tempData = "";
							statisticsShowMap[currObj].push_back(currDataLine);
							prevDataLine = currDataLine;
						}
						else if(prevObj.compare(currObj) == 0) {
							string correctData = prevDataLine + tempData;
							tempData = "";
							statisticsShowMap[currObj].pop_back();
							statisticsShowMap[currObj].push_back(correctData);
							statisticsShowMap[currObj].push_back(currDataLine);
							prevDataLine = currDataLine;
						}
						else {
							string correctData = prevDataLine + tempData;
							statisticsShowMap[prevObj].pop_back();
							statisticsShowMap[prevObj].push_back(correctData);
							tempData = currDataLine;
						}
					}
				}
			}
		}
		inFile.close();
	}
	else {
		// Failure case to open the file
	}
}
void node::processStatisticsShow(presetMetaData oneCmd)
{
	string data = "";
	string totalOutput = "";
	ofstream *pstatsShowFilePtr = NULL;
	time_t cmdStartTime;
	time(&cmdStartTime);
	string fid = "cluster_stats_show" + nodeIP + boost::lexical_cast<std::string>(cmdStartTime);
	pstatsShowFilePtr = outputHandle->createTempFile(fid);
	if((oneCmd.getSection()).compare("POSTSTATS") == 0) {
		data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
		data.append(oneCmd.getSection() + " =-=-=-=-=-= ");
		string nameToAppend = oneCmd.getShortname();
		if(nameToAppend.compare("") == 0) {
			nameToAppend = oneCmd.getCommand();
		}
		data += nameToAppend;
		totalOutput = "\nPERFSTAT_EPOCH: ";
		totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
		totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
		totalOutput.append("\n");
		(*outputHandle).writeDataToNodeFile(data, totalOutput);
	}
	(*connectionHandle).readResponseFromFilerWithPoll(outputHandle, pstatsShowFilePtr);
	if((oneCmd.getSection()).compare("POSTSTATS") == 0) {
		outputHandle->MoveFromTempToDataFile(fid);
		time_t cmdEndTime;
		time(&cmdEndTime);
		string data = "\n--- EXE-TIME of : " + oneCmd.getCommand() + " : ";
		data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
		outputHandle->writeDataToNodeFile(data);
		map<string, vector<string> > statisticsShowMap;
		parseStatisticsShowOutput(statisticsShowMap);
		// Write the Individual outputs to the Node file  
		for(map<string, vector<string> >::iterator iter = statisticsShowMap.begin();iter != statisticsShowMap.end(); iter++ ) {
			string key = (*iter).first;
			vector<string> value = ((*iter).second);
			data = "=-=-=-=-=-= " + oneCmd.getType() + " " + nodeIP + " ";
			data.append(oneCmd.getSection());
			data += " =-=-=-=-=-= statistics show -object ";
			data += key;
			totalOutput = "\nPERFSTAT_EPOCH: ";
			totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
			totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
			totalOutput.append("\n");
			(*outputHandle).writeDataToNodeFile(data, totalOutput);
			for(int vecIndex = 0; vecIndex < value.size(); ++vecIndex) {
				outputHandle->writeDataToNodeFile(value.at(vecIndex));
			}
			time(&cmdEndTime);
			data = "\n--- EXE-TIME of : statistics show -object " + key + " : ";
			data.append(boost::lexical_cast<std::string>(cmdEndTime - cmdStartTime) + " seconds");
			outputHandle->writeDataToNodeFile(data);
		}                        
	}
	outputHandle->closeTempFile(pstatsShowFilePtr);
	outputHandle->removeTempFile(fid);
}
bool node :: isRunInLegacyMode()
{
	bool bLegacyRun = false;
	if((cliHandle->getFilerMode()).compare("10-mode") == 0 || 
		((cliHandle->getFilerMode()).compare("10-mode") != 0  && cliHandle->getLegacyMode() == false)) {
			bLegacyRun = false;
	}
	else {
		bLegacyRun = true;
	}
	return bLegacyRun;
}

string node :: collectLegacyData(bool bWriteToFile, bool bStatData)
{
	string output = "";

	if(bStatData == true) {
		return output;
	}

	if(bWriteToFile == true) {		
		outputHandle->MoveFromTempToDataFile("Legacy_Output", true);		
	}
	else {
		string fileName = outputHandle->getNodeDataDir();
		fileName += "/output.Legacy_Output";	
		output = outputHandle->readFromFile(fileName);
	}

	// Removing the Legacy_Output file
	// Removing the file after each and every command execution, so that
	// it won't be available if the perfstat gets killed by some way.
	outputHandle->removeTempFile("Legacy_Output");
	outputHandle->removeTempFile("error");
	return output;                	
}

void node :: checkAndRemoveFile(const string& fileName)
{
	struct stat tmpFileInfo;
	bool bfileExists = false;
	int returnVal = stat(fileName.c_str(), &tmpFileInfo);
	if(returnVal == 0) {
		if(tmpFileInfo.st_size < 50) {			
			ifstream inFile;
			inFile.open(fileName.c_str());
			if(inFile.is_open()) {
				string currDataLine = "";
				while (!inFile.eof() ) {
					getline(inFile,currDataLine);
					boost::algorithm::trim(currDataLine);
					if(!currDataLine.empty()) {
						if(currDataLine.find("Is a directory") != string::npos) {
							string errInfo = "Removing File " + fileName;
							errInfo = errInfo + ", As it is a directory";
							commonOutputHandle->writeDataToLogFile("INFO", nodeIP, errInfo);
							std::remove(fileName.c_str());
						}
					}
				}
				inFile.close();
			}				
		}
	}	
}
/*
bool node :: sendLegacyCommand(const string& command, bool copyFiles)
{
string outputFile = outputHandle->getNodeDataDir();
string errorFile = outputFile + "/output.error";
outputFile += "/output.Legacy_Output";
string cmd = "";
if(copyFiles == false) {
//vector<string> filerInfo = cliHandle->getFilerCreds(nodeIP);
cmd = legacyCmd + "\"";
cmd = cmd + command + "\"";
cmd += " > ";
cmd += outputFile;
cmd = cmd + " 2>" + errorFile;
}
else {
cmd = legacyCmd + command;
}
int res = 0;
#ifdef WIN32
_flushall();
res = std::system(cmd.c_str());
#else
pid_t pid;
pid = fork ();
if (pid == 0) {           	
execl ("/bin/sh","/bin/sh", "-c",cmd.c_str(), NULL);
_exit (EXIT_FAILURE);
}
else if (pid < 0) {        	
res = -1;
}
else {        	
if (waitpid (pid, &res, 0) != pid) {
res = -1;
}
}
#endif
if((res != 0) && (copyFiles == false)) {
string fileName = outputHandle->getNodeDataDir();
fileName += "/output.error";
string output = outputHandle->readFromFile(fileName);
commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, output);
}

return ((res == 0) ? true : false);
}
*/
bool node :: checkClusterHealth()
{
	bool bStatus = false;
	bool bclusterHealth = true;
	string command = "cluster show";
	if(legacyModeFlag == false) {
		bStatus = connectionHandle->sendCommandToFiler(command);
	}
	else {
		bStatus = true;
		sendLegacyCommand(command);
	}
	if(bStatus) {
		string output = "";
		if(legacyModeFlag == false) {
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
		}
		else {
			output = collectLegacyData(false);
		}
		if(!output.empty()) {
			vector<string> clusterData = cliHandle->tokenizeString(output, "\n");
			bool bStart = false;
			for(int index = 0; index < clusterData.size(); ++index) {
				vector<string> nodeInfo = cliHandle->tokenizeString(clusterData[index], " ");
				if(nodeInfo.size() == 4) {
					if(nodeInfo[1].find("----") != string::npos) {
						bStart = true;
						continue;
					}
					if(bStart == true) {
						string nodeHealth = nodeInfo[1];
						boost::algorithm::trim(nodeHealth);
						if(nodeHealth.find("false") != string::npos) {
							bclusterHealth = false;
							break;
						}
					}
				}
			}
		}
	}
	else {
		bclusterHealth = false;
	}
	return bclusterHealth;
}

void node :: getFilesFromFiler()
{
	string logFilesPath = outputHandle->getNodeDataDir();
	logFilesPath.append("/Logs");
	boostFileSystem::path logPath = boostFileSystem::complete(boostFileSystem::path(logFilesPath));
	boostFileSystem::create_directory(logPath);
	logFilesPath.append("/");

	// string cmd = legacyCmd;
	string cmd = "";
	string filesInfo = "";
	vector<string> logFiles;
	vector<string> profFiles;
	string errorFile = logFilesPath + "copy_output.error";
	ofstream* pfileCopyPtr = NULL;
	if(cliHandle->getModuleInstFlag() == true || cliHandle->getSKTraceFlag() == true ||
		cliHandle->getBackUpLogFlag() == true) {
			getFiles("/etc/log", logFiles);		
			for(int index = 0; index < logFiles.size(); ++index) {
				bool bCopy = false;
				string outFile = logFilesPath + logFiles[index];
				string copyCmd = "";			
				if(legacyModeFlag == true) {
					if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
						copyCmd = "\"node run -node local -command \"priv set -q diag; rdfile /etc/log/";
					}
					else {
						copyCmd = "\"priv set -q diag; rdfile /etc/log/";
					}				
					copyCmd = copyCmd + logFiles[index] + "\"";
					if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
						copyCmd = copyCmd + "\"";
					}
					copyCmd = copyCmd + " >" + outFile;
					copyCmd = copyCmd + " 2>" + errorFile;
				}
				else {
					if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
						copyCmd = "node run -node local -command \"priv set -q diag; rdfile /etc/log/";
					}
					else {
						copyCmd = "priv set -q diag; rdfile /etc/log/";
					}
					if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
						copyCmd = copyCmd + logFiles[index] + "\"";
					}
					else {
						copyCmd = copyCmd + logFiles[index];
					}
				}

				if(cliHandle->getBackUpLogFlag() == true) {
					if(logFiles[index].compare(".") == 0 || 
						logFiles[index].compare("..") == 0 ||
						logFiles[index].empty()) {
							bCopy = false;
					}
					else {
						bCopy = true;				
					}
				}
				else {
					if(cliHandle->getSKTraceFlag() == true) {
						if(logFiles[index].find("sktrace_perfstat") != string::npos) {
							bCopy = true;
						}
					}
					if(cliHandle->getModuleInstFlag() == true) {
						if(logFiles[index].find(".dmp") != string::npos) {
							bCopy = true;
						}
					}
				}
				if(bCopy == true) {
					if(legacyModeFlag == true) {
						bool bCopyRes = sendLegacyCommand(copyCmd, true);
						if(bCopyRes == true) {
							string copySuccessResult = "Successfully copied ";
							copySuccessResult = copySuccessResult + logFiles[index];
							copySuccessResult = copySuccessResult + " from /etc/log";
							commonOutputHandle->writeDataToLogFile("INFO", nodeIP, copySuccessResult);
						}
					}
					else {
						pfileCopyPtr = outputHandle->createLogsFile(logFiles[index]);
						if(pfileCopyPtr != NULL) {
							bool status = (*connectionHandle).sendCommandToFiler(copyCmd);	
							if(status) {
								(*connectionHandle).readResponseFromFilerWithPoll(outputHandle, pfileCopyPtr);
							}
							outputHandle->closeTempFile(pfileCopyPtr);
						}
					}
					checkAndRemoveFile(outFile);
				}
			}				
	}
	if(cliHandle->getProfileFlag() == true) {		
		getFiles("/etc/gmon", profFiles);
		for(int index = 0; index < profFiles.size(); ++index) {
			bool bCopy = false;
			string copyCmd = "";
			string outFile = logFilesPath + profFiles[index];
			if(legacyModeFlag == true) {
				if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
					copyCmd = "\"node run -node local -command \"priv set -q diag; rdfile /etc/gmon/";
				}
				else {
					copyCmd = "\"priv set -q diag; rdfile /etc/gmon/";
				}				
				copyCmd = copyCmd + profFiles[index] + "\"";
				if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
					copyCmd = copyCmd + "\"";
				}
				copyCmd = copyCmd + " >" + outFile;
				copyCmd = copyCmd + " 2>" + errorFile;
			}
			else if (cliHandle->isDiagPasswdProvided()){
				//copyCmd = "system node systemshell -node local -command \"" + presetCmd.getCommand() + "\""
				copyCmd = "cat /mroot/etc/gmon/";
				copyCmd = copyCmd + profFiles[index];
			}
			else {
				if (profFiles[index].find("gmon_") != string::npos) {
					commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Diag Password required to get domain profiles from controller to Host\n");
					commonOutputHandle->writeDataToConsole("ERROR",nodeIP,"Perfstat failed to copy the Profile");
					commonOutputHandle->writeDataToConsole("INFO", nodeIP, "Profile can be copied from controller location /etc/gmon/ to local host" + profFiles[index]);
					return;
				}
			}

			if(profFiles[index].find("gmon_") != string::npos) {
				if(legacyModeFlag == true) {
					bool bCopyRes = sendLegacyCommand(copyCmd, true);
					if(bCopyRes == true) {
						string copySuccessResult = "Successfully copied ";
						copySuccessResult = copySuccessResult + profFiles[index];
						copySuccessResult = copySuccessResult + " from /etc/gmon";
						commonOutputHandle->writeDataToLogFile("INFO", nodeIP, copySuccessResult);
					}
				}
				else {
					/* 
					* Below might not be a good approach to copy the binary file, as we do not want
					* go with any FTP in our code, coz they need user credentials. We read the file on
					* the controller and file contect then read back from stdout to a host file.
					*/
					pfileCopyPtr = outputHandle->createLogsFile(profFiles[index], ios::binary | ios::app);
					if(pfileCopyPtr != NULL) {
						bool status = false;
						
						//status = (*connectionHandle).loginSystemShell(cliHandle->getSystemShellPasswd(nodeIP, 1),true); // To make 7-mode systemshell clean exit
						int indx = 0;
						if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
							 indx = 1;
						}
						status = (*connectionHandle).sendSystemShellCommand(copyCmd,cliHandle->getSystemShellPasswd(nodeIP, indx));
						if (!status) {
							commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Extracting domain profiles from controller to Host failed\n");
							commonOutputHandle->writeDataToLogFile("INFO", nodeIP, "Profile can be copied from controller location /etc/gmon/" + profFiles[index]);
							commonOutputHandle->writeDataToConsole("INFO", nodeIP, "Profile can be copied from controller location /etc/gmon/" + profFiles[index]);
							return;
						}
						//systemShellLoginFlag = true;
						//status = (*connectionHandle).sendSystemShellCommand(copyCmd, cliHandle->getSystemShellPasswd(nodeIP, 1));

						if(status) {
							(*connectionHandle).readSystemShellResponseWithPoll(outputHandle, pfileCopyPtr, true);
							ifstream *pfileReadptr = outputHandle->ReadLogsFile(profFiles[index], ios::binary);
							if (pfileReadptr != 0 && pfileReadptr->is_open()) {
								// Get the number of bytes in the File.
								pfileReadptr->seekg(0, ios::end);
								ifstream::pos_type fileSize = pfileReadptr->tellg();
								u_int size = fileSize;
								//cout << "filesize " << fileSize << endl;
								/* 
								* We don't need to have two memory pointers it can be done with one pointer.
								* Optimization later
								*/
								char *memblk = 0;
								char *memblk1 = 0;
								try {
									memblk = new char[size];
									memblk1 = new char[size];
									char *find = NULL;
									int nFound = 0;
									int subStrlen = 0;
									pfileReadptr->seekg(0, ios::beg);
									pfileReadptr->read(memblk, size);
									do
									{
										/* 
										* We found binary file got corrupted while copying 
										* ASCII character "LF" replaced with "CRLF". Removing
										* CR if come before LF. We came to this theroy after 
										* discussion. It is correct almost for all the cases but fails 
										* sometimes. If some corruption come in the prfile binary files.
										* Please look this code first.
										*/
										find = (char*)memchr(memblk, 0x0A, size);
										//cout << "pos " << (memblk - find) << endl;
										if(find != 0) 
										{
											/* This is a case when we have found LF where previous 
											* character is CR. We remove the CR in this case
											*/
											if (*(find - 1) == 0x0D)
											{
												// Length of the substring
												subStrlen = find - memblk;
												memcpy(memblk1, memblk, subStrlen);
												// Replace CR to LF
												memblk1[subStrlen -1] = 0x0A;
												// step up the pointer
												memblk1 = memblk1 + subStrlen;
												// Step up the original string pointer
												memblk = find + 1;
												//Reduce the Size
												size -= subStrlen + 1;
												// Number of occurence we found the character
												nFound++;
											}
											/* LF don't come with CR. We just forward the pointers */
											else {
												subStrlen = find - memblk;
												memcpy(memblk1, memblk, subStrlen + 1);
												memblk1 += (subStrlen + 1);
												memblk = find + 1;
												size -= subStrlen + 1;
											}
										} 
										else
											memcpy(memblk1, memblk, size);
									} while (find != NULL);

									// Move the pointer to End.
									memblk1 = memblk1 + size;
									// Move the pointer to start
									memblk1 -= ((u_int)fileSize - nFound);
									//Truncate and Re-write the file.
									outputHandle->closeTempFile(pfileCopyPtr);
									pfileCopyPtr = outputHandle->createLogsFile(profFiles[index], ios::binary | ios::trunc);
									/* 
									* Remove Copycommand and Systemshell prompt from the binary file.
									* Step up the pointer by the length of copycommand.
									*/
									memblk1 += (copyCmd.length() + 2);
									/* 
									* Number of bytes need to be copied are
									* "total bytes - nFoud - systemshell prompt length - copy command lengeth - extra character("CRPLF")
									*/
									pfileCopyPtr->write(memblk1,((u_int)fileSize - nFound - (connectionHandle->getSystemShellPrompt()).length() - copyCmd.length() -3));
									memblk -= ((u_int)fileSize - size);
									memblk1 -= (copyCmd.length() + 2);
								}
								catch(std::bad_alloc &memmoryAllocationException) 
								{
									delete[] memblk;
									delete[] memblk1;
									string tmp = "Exception : Bad allocation caught :";
									tmp.append(memmoryAllocationException.what());
									commonOutputHandle->writeDataToLogFile("INFO", nodeIP, tmp);
									tmp = "Profile File copy failed from controller to host";
									commonOutputHandle->writeDataToLogFile("INFO", nodeIP, tmp);
									tmp = "Profile file might be un-usable.";
									commonOutputHandle->writeDataToLogFile("INFO", nodeIP, tmp);
									std::remove(profFiles[index].c_str());
								}
								delete[] memblk;
								delete[] memblk1;
							}
						}
						if (cliHandle->getFilerMode().compare("10-mode"))
							status = (*connectionHandle).logoutSystemShell();
						/*
						else
							connectionHandle->disconnectToFiler();
						*/
						outputHandle->closeTempFile(pfileCopyPtr);
					}

				}
			}
			checkAndRemoveFile(outFile);
		}

	}						
	if(legacyModeFlag == true) {
		std::remove(errorFile.c_str());
	}
}

void node :: getFiles(const string& filesLocation, vector<string>& files)
{
	string cmd = "";	
	bool status = false;
	string output = "";
	string outputFile = outputHandle->getNodeDataDir();
	string errorFile = outputFile + "/output.error";
	outputFile += "/output.Legacy_Output";		

	if(legacyModeFlag == false) {
		if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
			cmd = "node run -node local -command \"priv set -q diag;ls ";
		}
		else {
			cmd = "priv set -q diag;ls ";
		}
		if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
			cmd = cmd + filesLocation + "\"";
		}
		else {
			cmd = cmd + filesLocation;
		}
		status = (*connectionHandle).sendCommandToFiler(cmd);	
		if(status) {
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
		}
	}
	else {
		if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
			cmd = "\"node run -node local -command \"priv set -q diag;ls ";
		}
		else {
			cmd = "\"priv set -q diag;ls ";
		}
		cmd = cmd + filesLocation + "\"";
		if((cliHandle->getFilerMode()).compare("10-mode") == 0) {
			cmd = cmd + "\"";
		}
		cmd = cmd + " > " + outputFile;
		cmd = cmd + " 2>" + errorFile;
		sendLegacyCommand(cmd, true);
		string fileName = outputHandle->getNodeDataDir();
		fileName += "/output.error";	
		output = outputHandle->readFromFile(fileName);		
	}		
	if(!output.empty()) {
		char *token = strtok (const_cast<char*>(output.c_str()),"\n");
		while (token != NULL) {
			string data =string(token);
			boost::algorithm::trim(data);
			files.push_back(data);
			token = strtok (NULL, "\n");
		}
	}
}

bool node :: sendLegacyCommand(const string& command, bool copyFiles)
{
	string outputFile = outputHandle->getNodeDataDir();
	string errorFile = outputFile + "/output.error";
	outputFile += "/output.Legacy_Output";
	string cmd = "";	
#ifdef WIN32
	cmd = "cmd /C ";
#endif
	if(copyFiles == false) {        
		cmd = cmd + legacyCmd + "\"";
		cmd = cmd + command + "\"";
		cmd += " > ";
		cmd += outputFile;
		cmd = cmd + " 2>" + errorFile;
	}
	else {
		cmd = cmd + legacyCmd + command;
	}	
	int res = 0;
#ifdef WIN32
	_flushall();
	//res = std::system(cmd.c_str());
	do_system(cmd);
#else
	pid_t pid;
	pid = fork ();
	if (pid == 0) {           	
		execl ("/bin/sh","/bin/sh", "-c",cmd.c_str(), NULL);
		_exit (EXIT_FAILURE);
	}
	else if (pid < 0) {        	
		res = -1;
	}
	else {        	
		if (waitpid (pid, &res, 0) != pid) {
			res = -1;
		}
	}
#endif
	if((res != 0) && (copyFiles == false)) {
		string fileName = outputHandle->getNodeDataDir();
		fileName += "/output.error";
		string output = outputHandle->readFromFile(fileName);
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, output);
	}

	return ((res == 0) ? true : false);
}
#ifdef WIN32
int 
	kill_process_tree(PROCESS_INFORMATION * pi)
{
	char cmd[1024];
	char msg[1024];
	unsigned long status = 0;
	int return_val = 1;

	sprintf(cmd, "taskkill /PID %d /T /F", pi->dwProcessId);
	sprintf(msg, "Killing process tree at PID: %d...", pi->dwProcessId);
	printf("%s\n", msg);
	std::system(cmd);
	Sleep(500);
	// Now check to see that we really killed the process
	GetExitCodeProcess(pi->hProcess, &status);
	if (status == STILL_ACTIVE) {
		sprintf(msg, "Unable to kill process tree rooted at PID %d using Windows command: \'taskkill\'", pi->dwProcessId);
		printf("FATAL: %s\n", msg);
		fprintf(stderr, "FATAL: %s\n", msg);
		return_val = 0;
	}
	// At this point we should have our error_log file handle back
	sprintf(msg, "Successfully killed process tree at root PID: %d", pi->dwProcessId);    
	return(return_val);
}
void node :: do_system(string strCommand)
{
	char msg[1024];    
	int i;
	char *cmd = const_cast<char*>(strCommand.c_str());    
	STARTUPINFO si;
	PROCESS_INFORMATION pi;
	ZeroMemory(&si, sizeof(si));
	si.cb = sizeof(si);
	ZeroMemory(&pi, sizeof(pi)); 
	if (!CreateProcess( NULL, cmd, NULL, NULL, FALSE, CREATE_DEFAULT_ERROR_MODE, NULL, NULL, &si, &pi )) {
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, "Failed to create process to execute command" + strCommand);
	} else {        
		if (WaitForSingleObject(pi.hProcess, opt_cmd_timeout) == WAIT_TIMEOUT) {
			string errorInfo = "Timed out on command: " + strCommand;
			errorInfo = errorInfo + ".Terminating the command process...";
			commonOutputHandle->writeDataToLogFile("WARNING", nodeIP, errorInfo);
			if (!kill_process_tree(&pi)) {
				errorInfo = "Unable to kill command process " + strCommand;
				printf("%s\n", msg);                
				CloseHandle(pi.hProcess);
				CloseHandle(pi.hThread);
				exit(1);
			}
		}
		CloseHandle(pi.hProcess);
		CloseHandle(pi.hThread);
	}
}
#endif
void node::format_stats_output(time_t cmdStartTime, string delta,
	string fileName, string type, string section)
{

	ifstream inFile;
	bool bstart = false;
	string prevObject = "$$";
	string currObject = "";
	string currDataLine = "";

	inFile.open(fileName.c_str());

	if(inFile.is_open()) {


		while (!inFile.eof() ) {
			getline(inFile,currDataLine);
			if(bstart == false) {
				int position = currDataLine.find(":");
				if(position != string::npos) {
					currObject = currDataLine.substr(0, position);
					if(currObject.compare("StatisticsID") == 0) {
						bstart = true;
					}
				}
			}
			else {
				vector<string> tokenObj;
				string data;
				string totalOutput;
				tokenObj = cliHandle->tokenizeString(currDataLine, ":");
				size_t n = std::count(currDataLine.begin(), currDataLine.end(), ':');

				if(tokenObj.size() > 0 && n >= 3 ) { //n>=3 should cover the splited stat lines.obj:instance:counter:<fiel>d:value

					currObject.assign(tokenObj[0]);

					//check if this is a new object. compare() would treat a spilitted object name as new, so use find()
					if(prevObject.find(currObject) == string::npos)
					{
						//Write the header part
						data = "=-=-=-=-=-= " + type + " " + nodeIP + " ";
						data.append(section);
						data += " =-=-=-=-=-= stats stop -I ";
						data += currObject;
						totalOutput = "\nPERFSTAT_EPOCH: ";
						totalOutput.append(boost::lexical_cast<std::string>(cmdStartTime));
						totalOutput.append(perfstat::convert_EPOCH_to_gmtime(cmdStartTime));
						totalOutput.append("\n");
						totalOutput.append(boost::lexical_cast<std::string>(delta));
						(*outputHandle).writeDataToNodeFile(data, totalOutput);
						prevObject = currObject;
					}
					//Now write the line in output file
					(*outputHandle).writeDataToNodeFile(currDataLine);


				}
			}
		}
		inFile.close();
	}
	else {
		commonOutputHandle->writeDataToLogFile("ERROR", nodeIP, "Failed to open the temporary stats file");
	}
}

void node :: getVol_dbLookupInfo(boost::barrier *serThreadBar)
{
	string command;
	int i = 0;
	if(!(cliHandle->getFilerMode()).compare("10-mode"))

	{
		command = "node run -node local -command \"priv set -q diag;vol_db list all\"";
	}
	else
		return;

	string output = "";
	//if(legacyModeFlag == false) {
	connectionStatus = (*connectionHandle).sendCommandToFiler(command);
	if(connectionStatus) {
		output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
		std::string::size_type pos = output.find(command);
		if (pos != std::string::npos)
			output.erase(0, (pos + command.length()));
	}
	std::vector<std::string> lookuplist;
	boost::algorithm::trim(output);
	boost::algorithm::split(lookuplist, output, boost::is_any_of("[ \n"));
	command = "node run -node local -command \"priv set -q diag;vol_db print\"";

	(*outputHandle).writeDataToNodeFile("=-=-=-=-=-= PERF " + nodeIP + " PRESTATS =-=-=-=-=-= " + "vol_db ", " ");

	for(std::vector<string>::iterator it = lookuplist.begin(); i < lookuplist.size();) {
		if ((*it).empty())
		{
			it++;
			i++;
			continue;
		}
		command = "node run -node local -command \"priv set -q diag;vol_db print " + *it + "\"";
		connectionStatus = (*connectionHandle).sendCommandToFiler(command);
		if(connectionStatus) 
		{
			string data = "";
			output = (*connectionHandle).readResponseBufferWithPoll(outputHandle);
			//Write the header part
			//data = "=-=-=-=-=-= PERF " + nodeIP + " PRESTATS =-=-=-=-=-= " + "vol_db " + *it;
			data = "vol_db " + *it;
			//output.append("\n--- EXE-TIME of " + command + "0 seconds");
			(*outputHandle).writeDataToNodeFile(data, output);
		}
		it += 2;
		i +=2;
	}
	(*outputHandle).writeDataToNodeFile("", "\n--- EXE-TIME of " + command + "0 seconds");
	(*serThreadBar).wait();
	return;
}

bool node::syslogRvertChanges(boost::barrier *serThreadBar)
{
		string command = "priv set -q diag;mv /etc/syslog.conf_orig /etc/syslog.conf";
		if (!legacyModeFlag)
		{
			bool status = connectionHandle->sendCommandToFiler(command);
			if (status) {
				string output = connectionHandle->readResponseBufferWithPoll(outputHandle);
				if (output.find("rename: No such file or directory") != string::npos)
				{
					status = connectionHandle->sendCommandToFiler("priv set -q diag;rm /etc/syslog.conf");

				}
			}
			else
			{
				string data = "Failed to revert back syslog.conf. Please execute from node prompt mv /etc/syslog.conf_orig /etc/syslog.conf \
						or remove syslog.conf file, priv set diag; rm /etc/syslog.conf";
				commonOutputHandle->writeDataToConsole("STATUS", nodeIP, data, false);
			}
		}
		else
		{
			bool status = sendLegacyCommand(command);
			if (status) {
				string output = collectLegacyData();
				if (output.find("rename: No such file or directory") != string::npos)
				{
					sendLegacyCommand("priv set -q diag;rm /etc/syslog.conf");
				}
			}
			else
			{
				string data = "Failed to revert syslog.conf. Please execute comamnd from node prompt mv /etc/syslog.conf_orig /etc/syslog.conf \
						or remove syslog.conf file, priv set diag; rm /etc/syslog.conf";
				commonOutputHandle->writeDataToConsole("STATUS", nodeIP, data, false);
			}
					

		}
		(*serThreadBar).wait();
		return true;
}