myvtm/Module/mod_UpgradeMgr/mod_UpgradeMgr.h

#ifndef RVC_MOD_UPGRADEMGR_H_
#define RVC_MOD_UPGRADEMGR_H_

#include "SpBase.h"
#include "SimpleString.h"
#include "UpgradeManager_server_g.h"
#include "Download_msg_g.h"
#include "UpgradeRun_msg_g.h"
#include "UpgradeMgrFSM.h"

#include "SpTest.h"
#include "modVer.h"

using namespace UpgradeManager;


// 升级管理 UpgradeManager	0x506
class CUpgradeMgrEntity : public CEntityBase, public ISysVarListener, public IBroadcastListener
{
public:
	CUpgradeMgrEntity(){
		m_IsSM3listSucc=0;
		m_beginSM3HashTime=0;
		m_strSM3Hash="";
		m_bStartUp=false;
		m_testResult=Error_Succeed;//默认是成功的
	}
	virtual ~CUpgradeMgrEntity() {}
	virtual const char *GetEntityName() const { return "UpgradeManager"; }
	virtual bool IsService()const{return true;}

	const char* GetEntityVersion() const override
	{
		return MODULE_VERSION_FULL;
	}

	ON_ENTITYT_TEST()

	virtual void OnStarted();
	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext);
	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszParam*/);
	virtual void OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName);
	void OnDownloadEvent(const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, Download::DownloadResult &evt);
	void OnUpgradeCheckEvent(const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, UpgradeRun::UpgradeCheckEvent &evt);
	void OnUpgradeDoneEvent(const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, UpgradeRun::UpgradeDoneEvent &evt);
	static char GetInstallStateVal(const InstallStateEnum enumVal);
	
	ErrorCodeEnum RegistLocalPack(const CSimpleStringA &strPackFile);
	DWORD RegistManualPack(const CSimpleStringA &strPackFile);
	DWORD GetManualPacks(CSimpleStringA &strManualPacks);
	ErrorCodeEnum DownloadPack(const CSimpleStringA &strPackFile);
	ErrorCodeEnum CancelDownloadPack(const CSimpleStringA &strPackFile);
	ErrorCodeEnum PushUpdateTask(const CSimpleStringA &strPackName, const int nPackType);
	//ErrorCodeEnum PushUpdateTask(const CSimpleStringA &strPackName);
	ErrorCodeEnum CancelUpdate(const CSimpleStringA &strPackName);
	ErrorCodeEnum RollbackUpdate(const CSimpleStringA &strVersion);
	ErrorCodeEnum SwitchUpgrade(const CSimpleStringA &strPack);
	ErrorCodeEnum GetUpgradeState(bool &bInstalling, CSimpleStringA &strPackFile, CSimpleStringA &strExecID,
		char &nInstallState, bool &bSysInstall, bool &bLightPack, CSimpleStringA &strNewVersion);
	ErrorCodeEnum SyncTime();
	ErrorCodeEnum UpdatePackFailInfo(CSimpleStringA strVersion);
	ErrorCodeEnum MD5File(CSimpleStringA strToSignFilePath, CSimpleStringA &strMD5);
	ErrorCodeEnum MD5Data(CSimpleStringA strData, CSimpleStringA &strMD5);
	ErrorCodeEnum MD5Folder(CSimpleStringA strFolderPath, bool isDepDir=false);
	ErrorCodeEnum GetMD5List(CSimpleStringA &strMD5List);

	//新国密SM3函数，isSub表示是否截取新国密中间一段密文
	ErrorCodeEnum SM3FileToStr(CSimpleStringA strFilePath, CSimpleStringA &strSM3,bool isSub);
	ErrorCodeEnum SM3DataToStr(CSimpleStringA strData, CSimpleStringA &strSM3,bool isSub);
	ErrorCodeEnum SM3_Str(CSimpleStringA &strSM3,BYTE * SM3Byte,bool isSub);

#if 0 //v4.9.0内容，暂时不加上
	//创建install.ini文件
	ErrorCodeEnum createInstallFile();
#endif

	ErrorCodeEnum StopMediaPlay();

#ifdef RVC_OS_WIN
	SP_BEGIN_MSG_DISPATCH_MAP(CUpgradeMgrEntity)
		SP_BEGIN_ENTITY_MSG("Download")
		SP_MSG_HANDLE_NS(Download, DownloadResult, OnDownloadEvent)
		SP_END_ENTITY_MSG()
		SP_BEGIN_ENTITY_MSG("UpgradeRun")
		SP_MSG_HANDLE_NS(UpgradeRun, UpgradeCheckEvent, OnUpgradeCheckEvent)
		SP_MSG_HANDLE_NS(UpgradeRun, UpgradeDoneEvent, OnUpgradeDoneEvent)
		SP_END_ENTITY_MSG()
	SP_END_MSG_DISPATCH_MAP()
#else
	virtual void OnBroadcastEvent(CUUID SubID, const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer) 
	{ 
		if (!pszEntityName) 
		{ 
			LOG_TRACE("pszEntityName cannot empty!"); 
		}
		else if (_stricmp("Download", pszEntityName) == 0)
		{
			switch (dwMessageId) {
			case eMsg_DownloadResult:
				if (eMsgSig_DownloadResult == dwMessageSignature) {
					Download::DownloadResult t;
					ErrorCodeEnum Error = SpBuffer2Object(Buffer, t);
					if (Error == Error_Succeed)
						OnDownloadEvent(pszEntityName, dwMessageId, dwMessageSignature, t);
				}
				else {
					LOG_TRACE("DownloadResult signature mismatched!");
				}
				break;
			default:
				LOG_TRACE("msg id %d ignored!", dwMessageId);
				break;
			}
		}
		else if (_stricmp("UpgradeRun", pszEntityName) == 0)
		{
			switch (dwMessageId) {
			case eMsg_UpgradeCheckEvent:
				if (eMsgSig_UpgradeCheckEvent == dwMessageSignature) {
					UpgradeRun::UpgradeCheckEvent t;
					ErrorCodeEnum Error = SpBuffer2Object(Buffer, t);
					if (Error == Error_Succeed)
						OnUpgradeCheckEvent(pszEntityName, dwMessageId, dwMessageSignature, t);
				}
				else {
					LOG_TRACE("UpgradeCheckEvent signature mismatched!" );
				}
				break;
			case eMsg_UpgradeDoneEvent:
				if (eMsgSig_UpgradeDoneEvent == dwMessageSignature) {
					UpgradeRun::UpgradeDoneEvent t;
					ErrorCodeEnum Error = SpBuffer2Object(Buffer, t);
					if (Error == Error_Succeed)
						OnUpgradeDoneEvent(pszEntityName, dwMessageId, dwMessageSignature, t);
				}
				else {
					LOG_TRACE("UpgradeDoneEvent signature mismatched!");
				}
				break;
			default:
				LOG_TRACE("msg id %d ignored!", dwMessageId);
				break;
			}
		}
		else 
		{ 
			LOG_TRACE("ignore pszEntityName"); 
		} 
	}
#endif
public:
	CUpgradeMgrFSM m_fsm;
	map<CSimpleStringA, CSimpleStringA> m_FileHashMap;		// 版本文件hash值集合
	CSimpleStringA m_strMD5List;
	CSimpleStringA m_strSM3Hash;//SM3 32位hash
	int m_IsSM3listSucc;//获取SM3哈希list是否成功，0：还未计算完毕，1：表示成功 ，-1表示计算失败
	DWORD m_beginSM3HashTime;//开始计算sm3hahs时间
	bool m_bStartUp;//是否系统首页启动成功

	ErrorCodeEnum m_testResult;//实体级别握手变量
};

class CUpgradeMgrSession : public UpgradeMgrService_ServerSessionBase
{
public:
	CUpgradeMgrSession(CUpgradeMgrEntity *pEntity) : m_pEntity(pEntity) {}
	virtual ~CUpgradeMgrSession() {}

	virtual void Handle_RegistLocalPack(SpReqAnsContext<UpgradeMgrService_RegistLocalPack_Req, UpgradeMgrService_RegistLocalPack_Ans>::Pointer ctx)
	{
		ErrorCodeEnum rc = m_pEntity->RegistLocalPack(ctx->Req.strPackFile);
		ctx->Answer(rc);
	}

	virtual void Handle_RegistManualPack(SpReqAnsContext<UpgradeMgrService_RegistManualPack_Req, UpgradeMgrService_RegistManualPack_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		DWORD dwRet = 0;
		CSimpleStringA strErrmsg;

		dwRet = m_pEntity->RegistManualPack(ctx->Req.strPackFile);		

		if (ERROR_SUCCESS != dwRet)
		{
			switch (dwRet)
			{
			case NOT_MANUALPACK_ERR:
				strErrmsg = "升级包类型不是手动安装，请确认!";
				break;
			
			case IS_UPDATEING_ERR:
				strErrmsg = "正在升级，请稍后!";
				break;

			default:
				strErrmsg = "未知的手动升级错误，请联系维护人员!";
				break;
			}
		}
		else
		{
			Dbg("推送手动升级任务:[%s]成功", ctx->Req.strPackFile);
		}

		ctx->Ans.Errcode = dwRet;
		ctx->Ans.ErrMsg = strErrmsg;
		ctx->Answer(Error_Succeed);
		//ctx->Answer(Error_Succeed, dwRet);
	}

	virtual void Handle_CancelUpdate(SpReqAnsContext<UpgradeMgrService_CancelUpdate_Req, UpgradeMgrService_CancelUpdate_Ans>::Pointer ctx)
	{
		ErrorCodeEnum rc = m_pEntity->CancelUpdate(ctx->Req.strPackFile);
		ctx->Answer(rc);
	}

	virtual void Handle_RollbackUpdate(SpReqAnsContext<UpgradeMgrService_RollbackUpdate_Req, UpgradeMgrService_RollbackUpdate_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->RollbackUpdate(ctx->Req.strVersion);
		ctx->Answer(rc);
	}

	virtual void Handle_GetUpgradeState(SpReqAnsContext<UpgradeMgrService_GetUpgradeState_Req, UpgradeMgrService_GetUpgradeState_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->GetUpgradeState(ctx->Ans.bInstalling, ctx->Ans.strPackFile, ctx->Ans.strExecID,
			ctx->Ans.cInstallState, ctx->Ans.bSysInstall, ctx->Ans.bLightPack, ctx->Ans.strNewVersion);
		ctx->Answer(rc);
	}

	virtual void Handle_SwitchUpgrade(SpReqAnsContext<UpgradeMgrService_SwitchUpgrade_Req, UpgradeMgrService_SwitchUpgrade_Ans>::Pointer ctx)
	{
		auto rc = m_pEntity->SwitchUpgrade(ctx->Req.strPackFile);
		ctx->Answer(rc);
	}

	virtual void Handle_GetManualPacks(SpReqAnsContext<UpgradeMgrService_GetManualPacks_Req, UpgradeMgrService_GetManualPacks_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		DWORD dwRet = 0;
		CSimpleStringA strErrmsg;	
		CSimpleStringA strPackList;
		dwRet = m_pEntity->GetManualPacks(strPackList);

		if (ERROR_SUCCESS == dwRet)
		{
			ctx->Ans.strPackFileList = strPackList;
			Dbg("获取手动升级包列表成功:[%s]", strPackList);
		}
		else
		{
			Dbg("不存在手动安装的升级包");
			ctx->Ans.strPackFileList = "";

			switch (dwRet)
			{
			case NO_EXIST_MANUAL_PACK_ERR:
				strErrmsg = "不存在手动升级任务，请确认!";
				break;

			default:
				strErrmsg = "未知的获取手动升级任务错误，请联系维护人员!";
				break;
			}
		}		

		ctx->Ans.Errcode = dwRet;
		ctx->Ans.ErrMsg = strErrmsg;
		//ctx->Answer(Error_Succeed, dwRet);
		ctx->Answer(Error_Succeed);
	}

private:
	CUpgradeMgrEntity *m_pEntity;
};
#endif //RVC_MOD_UPGRADEMGR_H_