/**
 * Tencent is pleased to support the open source community by making Tars available.
 *
 * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except 
 * in compliance with the License. You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * Unless required by applicable law or agreed to in writing, software distributed 
 * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 * specific language governing permissions and limitations under the License.
 */

#ifndef __START_COMMAND_H_
#define __START_COMMAND_H_

#include "ServerCommand.h"
#include "NodeRollLogger.h"
#include "util/tc_timeprovider.h"

class CommandStart : public ServerCommand
{
public:
 enum
 {
 START_WAIT_INTERVAL = 3, /*服务启动等待时间 秒*/
 START_SLEEP_INTERVAL = 100000, /*微妙*/
 };
public:
 CommandStart(const ServerObjectPtr& pServerObjectPtr, bool bByNode = false);

 ExeStatus canExecute(string& sResult);

 int execute(string& sResult);

private:
 bool startNormal(string& sResult);

 bool startByScript(string& sResult);

private:
 bool _byNode;
 string _exeFile;
 string _logPath;
 ServerDescriptor _desc;
 ServerObjectPtr _serverObjectPtr;
};

//////////////////////////////////////////////////////////////
//
inline CommandStart::CommandStart(const ServerObjectPtr& pServerObjectPtr, bool bByNode)
: _byNode(bByNode)
, _serverObjectPtr(pServerObjectPtr)
{
 _exeFile = _serverObjectPtr->getExeFile();
 _logPath = _serverObjectPtr->getLogPath();
 _desc = _serverObjectPtr->getServerDescriptor();
}
//////////////////////////////////////////////////////////////
//
inline ServerCommand::ExeStatus CommandStart::canExecute(string& sResult)
{

 TC_ThreadRecLock::Lock lock(*_serverObjectPtr);

 NODE_LOG("startServer")->debug() << FILE_FUN << _desc.application << "." << _desc.serverName << " beging activate------|byRegistry|" << _byNode << endl;

 ServerObject::InternalServerState eState = _serverObjectPtr->getInternalState();

 if (_byNode)
 {
 _serverObjectPtr->setEnabled(true);
 }
 else if (!_serverObjectPtr->isEnabled())
 {
 sResult = "server is disabled";
 NODE_LOG("startServer")->debug() << FILE_FUN << sResult << endl;
 return DIS_EXECUTABLE;
 }

 if (eState == ServerObject::Active || eState == ServerObject::Activating)
 {
 _serverObjectPtr->synState();
 sResult = "server is already " + _serverObjectPtr->toStringState(eState);
 NODE_LOG("startServer")->debug() << FILE_FUN << sResult << endl;
 return NO_NEED_EXECUTE;
 }

 if (eState != ServerObject::Inactive)
 {
 sResult = "server state is not Inactive. the curent state is " + _serverObjectPtr->toStringState(eState);
 NODE_LOG("startServer")->debug() << FILE_FUN << sResult << endl;
 return DIS_EXECUTABLE;
 }

 if (TC_File::isAbsolute(_exeFile) &&
 !TC_File::isFileExistEx(_exeFile) &&
 _serverObjectPtr->getStartScript().empty() &&
 _serverObjectPtr->getServerType() != "tars_nodejs")
 {
 _serverObjectPtr->setPatched(false);
 sResult = "The server exe patch " + _exeFile + " is not exist.";
 NODE_LOG("startServer")->debug() << FILE_FUN << sResult << endl;
 return DIS_EXECUTABLE;
 }

 _serverObjectPtr->setPatched(true);

 _serverObjectPtr->setState(ServerObject::Activating, false); //此时不通知regisrty。checkpid成功后再通知

 return EXECUTABLE;
}

inline bool CommandStart::startByScript(string& sResult)
{
 pid_t iPid = -1;
 bool bSucc = false;
 string sStartScript = _serverObjectPtr->getStartScript();
 string sMonitorScript = _serverObjectPtr->getMonitorScript();

 string sServerId = _serverObjectPtr->getServerId();
 iPid = _serverObjectPtr->getActivator()->activate(sServerId, sStartScript, sMonitorScript, sResult);

 vector<string> vtServerName = TC_Common::sepstr<string>(sServerId, ".");
 if (vtServerName.size() != 2)
 {
 sResult = sResult + "|failed to get pid for " + sServerId + ",server id error";
 NODE_LOG("startServer")->error() << FILE_FUN << sResult << endl;
 throw runtime_error(sResult);
 }

 //默认使用启动脚本路径
 string sFullExeFileName = TC_File::extractFilePath(sStartScript) + vtServerName[1];
 if (!TC_File::isFileExist(sFullExeFileName))
 {
 NODE_LOG("startServer")->error() << FILE_FUN << "file name " << sFullExeFileName << " error, use exe file" << endl;

 //使用exe路径
 sFullExeFileName = _serverObjectPtr->getExeFile();
 if (!TC_File::isFileExist(sFullExeFileName))
 {
 sResult = sResult + "|failed to get full exe file name|" + sFullExeFileName;
 NODE_LOG("startServer")->error() << FILE_FUN << sResult << endl;
 throw runtime_error(sResult);
 }
 }
 time_t tNow = TNOW;
 int iStartWaitInterval = START_WAIT_INTERVAL;
 try
 {
 //服务启动,超时时间自己定义的情况
 TC_Config conf;
 conf.parseFile(_serverObjectPtr->getConfigFile());
 iStartWaitInterval = TC_Common::strto<int>(conf.get("/tars/application/server<activating-timeout>", "3000")) / 1000;
 if (iStartWaitInterval < START_WAIT_INTERVAL)
 {
 iStartWaitInterval = START_WAIT_INTERVAL;
 }
 if (iStartWaitInterval > 60)
 {
 iStartWaitInterval = 60;
 }

 }
 catch (...)
 {
 }

 string sPidFile = "/usr/local/app/tars/tarsnode/util/" + sServerId + ".pid";
 string sGetServerPidScript = "ps -ef | grep -v 'grep' |grep -iE ' " + sFullExeFileName + " '| awk '{print 2ドル}' > " + sPidFile;

 while ((TNOW - iStartWaitInterval) < tNow)
 {
 //注意:由于是守护进程,不要对sytem返回值进行判断,始终wait不到子进程
 system(sGetServerPidScript.c_str());
 string sPid = TC_Common::trim(TC_File::load2str(sPidFile));
 if (TC_Common::isdigit(sPid))
 {
 iPid = TC_Common::strto<int>(sPid);
 _serverObjectPtr->setPid(iPid);
 if (_serverObjectPtr->checkPid() == 0)
 {
 bSucc = true;
 break;
 }
 }

 NODE_LOG("startServer")->debug() << FILE_FUN << _desc.application << "." << _desc.serverName << " activating usleep " << int(iStartWaitInterval) << endl;
 usleep(START_SLEEP_INTERVAL);
 }

 if (_serverObjectPtr->checkPid() != 0)
 {
 sResult = sResult + "|get pid for server[" + sServerId + "],pid is not digit";
 NODE_LOG("startServer")->error() << FILE_FUN << sResult << endl;
 if (TC_File::isFileExist(sPidFile))
 {
 TC_File::removeFile(sPidFile, false);
 }
 throw runtime_error(sResult);
 }

 if (TC_File::isFileExist(sPidFile))
 {
 TC_File::removeFile(sPidFile, false);
 }
 return bSucc;
}

inline bool CommandStart::startNormal(string& sResult)
{
 pid_t iPid = -1;
 bool bSucc = false;
 string sRollLogFile;
 vector<string> vEnvs;
 vector<string> vOptions;
 string sConfigFile = _serverObjectPtr->getConfigFile();
 string sLogPath = _serverObjectPtr->getLogPath();
 string sServerDir = _serverObjectPtr->getServerDir();
 string sLibPath = _serverObjectPtr->getLibPath();
 string sExePath = _serverObjectPtr->getExePath();

 //环境变量设置
 vector<string> vecEnvs = TC_Common::sepstr<string>(_serverObjectPtr->getEnv(), ";|");
 for (vector<string>::size_type i = 0; i < vecEnvs.size(); i++)
 {
 vEnvs.push_back(vecEnvs[i]);
 }

 {
 vEnvs.push_back("LD_LIBRARY_PATH=$LD_LIBRARY_PATH:" + sExePath + ":" + sLibPath);
 }

 //生成启动脚本
 std::ostringstream osStartStcript;
 osStartStcript << "#!/bin/sh" << std::endl;
 for (vector<string>::size_type i = 0; i < vEnvs.size(); i++)
 {
 osStartStcript << "export " << vEnvs[i] << std::endl;
 }

 osStartStcript << std::endl;
 if (_serverObjectPtr->getServerType() == "tars_java")
 {
 //java服务
 string sClassPath = _serverObjectPtr->getClassPath();
 string sJarList = sExePath + "/classes";
 vector<string> vJarList;
 TC_File::scanDir(sClassPath, vJarList);

 sJarList = sJarList + ":" + sClassPath + "/*";

 vOptions.push_back("-Dconfig=" + sConfigFile);
 string s = _serverObjectPtr->getJvmParams() + " -cp " + sJarList + " " + _serverObjectPtr->getMainClass();
 vector<string> v = TC_Common::sepstr<string>(s, " \t");
 vOptions.insert(vOptions.end(), v.begin(), v.end());

 osStartStcript << _exeFile << " " << TC_Common::tostr(vOptions) << endl;
 }
 else if (_serverObjectPtr->getServerType() == "tars_nodejs") 
 { 
 vOptions.push_back(sExePath + "/tars_nodejs/node-agent/bin/node-agent");
 string s = sExePath + "/src/ -c " + sConfigFile; 
 vector<string> v = TC_Common::sepstr<string>(s," \t"); 
 vOptions.insert(vOptions.end(), v.begin(), v.end());

	//对于tars_nodejs类型需要修改下_exeFile
 _exeFile = sExePath+"/tars_nodejs/node";

 osStartStcript<<sExePath+"/tars_nodejs/node" <<" "<<TC_Common::tostr(vOptions)<<" &"<< endl;
 }
 else
 {
 //c++服务
 vOptions.push_back("--config=" + sConfigFile);
 osStartStcript << _exeFile << " " << TC_Common::tostr(vOptions) << " &" << endl;
 }

 //保存启动方式到bin目录供手工启动
 TC_File::save2file(sExePath + "/tars_start.sh", osStartStcript.str());
 TC_File::setExecutable(sExePath + "/tars_start.sh", true);

 if (sLogPath != "")
 {
 sRollLogFile = sLogPath + "/" + _desc.application + "/" + _desc.serverName + "/" + _desc.application + "." + _desc.serverName + ".log";
 }

 const string sPwdPath = sLogPath != "" ? sLogPath : sServerDir; //pwd patch 统一设置至log目录 以便core文件发现 删除
 iPid = _serverObjectPtr->getActivator()->activate(_exeFile, sPwdPath, sRollLogFile, vOptions, vEnvs);
 if (iPid == 0) //child process
 {
 return false;
 }

 _serverObjectPtr->setPid(iPid);

 bSucc = (_serverObjectPtr->checkPid() == 0) ? true : false;

 return bSucc;
}
//////////////////////////////////////////////////////////////
//
inline int CommandStart::execute(string& sResult)
{
 int64_t startMs = TC_TimeProvider::getInstance()->getNowMs();
 try
 {
 bool bSucc = false;
 //set stdout & stderr
 _serverObjectPtr->getActivator()->setRedirectPath(_serverObjectPtr->getRedirectPath());

 if (!_serverObjectPtr->getStartScript().empty() || _serverObjectPtr->isTarsServer() == false)
 {
 bSucc = startByScript(sResult);
 }
 else
 {
 bSucc = startNormal(sResult);
 }

 if (bSucc == true)
 {
 _serverObjectPtr->synState();
 _serverObjectPtr->setLastKeepAliveTime(TNOW);
 _serverObjectPtr->setLimitInfoUpdate(true);
 _serverObjectPtr->setStarted(true);
			_serverObjectPtr->setStartTime(TNOWMS);
 NODE_LOG("startServer")->debug() << FILE_FUN << _desc.application << "." << _desc.serverName << "_" << _desc.nodeName << " start succ " << sResult << ", use:" << (TC_TimeProvider::getInstance()->getNowMs() - startMs) << " ms" << endl;
 return 0;
 }
 }
 catch (exception& e)
 {
 sResult = e.what();
 }
 catch (const std::string& e)
 {
 sResult = e;
 }
 catch (...)
 {
 sResult = "catch unkwon exception";
 }

 NODE_LOG("startServer")->error() << FILE_FUN << _desc.application << "." << _desc.serverName << " start failed :" << sResult << ", use:" << (TC_TimeProvider::getInstance()->getNowMs() - startMs) << " ms" << endl;
 
 _serverObjectPtr->setPid(0);
 _serverObjectPtr->setState(ServerObject::Inactive);
	_serverObjectPtr->setStarted(false);

 return -1;
}
#endif