myvtm/Module/mod_upload/UploadFSM.h

#ifndef RVC_MOD_UPLOAD_UPLOADFSM_H_
#define RVC_MOD_UPLOAD_UPLOADFSM_H_

#include "SpBase.h"
#include "SpFSM.h"
#include "SpSecureClient.h"
#include "SpUtility.h"

#include "upload.h"
#include <list>
#include "IHttpFunc.h"
#ifdef RVC_OS_WIN
#include "json.h"
#include <io.h>
#else 
#include "json/json.h"
#include <map>
#endif

#define USER_EVT_JMP_DISABLE	EVT_USER+1
#define USER_EVT_JMP_ENABLE		EVT_USER+2
#define USER_EVT_JMP_CONNECT	EVT_USER+3
#define USER_EVT_DISCONNECT		EVT_USER+4
#define USER_EVT_UPLOAD_ANS		EVT_USER+5
#define USER_EVT_BLOCK_ANS		EVT_USER+6
#define USER_EVT_JMP_UPLOAD		EVT_USER+7

#define USER_EVT_JMP_OLD_SCAN	EVT_USER+8
#define USER_EVT_JMP_NEW_SCAN	EVT_USER+9
#define USER_EVT_JMP_NEW_UPLOAD		EVT_USER+10
#define USER_EVT_JMP_NEW_DISABLE	EVT_USER+11
#define USER_EVT_UPLOAD_SUCC		EVT_USER+12
#define USER_EVT_UPLOAD_FAIL		EVT_USER+13

using namespace std;

#pragma pack(1)
// [StructName("UPREQ")]
struct UploadReq
{
	char TerminalNo[16];
	char FileName[64];
	char FileType[16];
	int FileLength;
	int FileCreatDate;
};
//    [StructName("UPANS")]
struct UploadReply
{
	int ResultCode;
	char UploadID[16];
	int BeginBlock;
};
//[StructName("BLKREQ")]
struct BlockReq
{
	char TerminalNo[16];
	char FileName[64];
	char UploadID[16];
	int BlockNo;
	char Data[0];
};
//[StructName("BLKANS")]
struct BlockReply
{
	char UploadID[16];
	int ResultCode;
};
#pragma pack()

enum UploadCtlCode
{
	Finish = 0,                  //完成（BLOCK）
	Begin = 1,                   //开始上传（UPLOAD）
	Continua = 2,                //文件已经存在，断点续传，按返回块开始传（UPLOAD）（BLOCK）
	ErrorBlock = 3,              //上块错误，重新传（BLOCK）
	ErrorType = 4,               //错误的类型（UPLOAD）
	Timeout = 5,                 //过期（UPLOAD）
	ErrorUploadId = 6,           //错误的上传id（BLOCK）
};
//上传请求回应
struct UploadAnsEvent : public FSMEvent 
{
	UploadAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_UPLOAD_ANS) {
		memcpy(&m_reply, pBuf, sizeof(UploadReply));
	}
	virtual ~UploadAnsEvent() {}
	UploadReply m_reply;
};
//上传块请求回应
struct BlockAnsEvent : public FSMEvent
{
	BlockAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_BLOCK_ANS) {
		memcpy(&m_reply, pBuf, sizeof(BlockReply));
	}
	virtual ~BlockAnsEvent() {}
	BlockReply m_reply;
};
/** 交易受限功能代码废弃
struct UploadProgress
{
	int uploadState;
	int uploadNumber;
	CSimpleStringA elapseTime;
};
*/


enum CenterModelEnum
{
	branchModel = 0,                //分行模式
	mixModel = 1,					//混合模式
	centerModel = 2,                //总行模式
	
};
struct CenterUrl
{
	string queryPlanUrl;	//上传策略查询接口
	string queryTempFileUrl;   //查询临时计划文件状态接口
	string updateStateUrl;	//更新上传状态接口
	string addUploadFailUrl;	//增加失败流水接口
	//string uploadCenterUrl;	//终端总行上传文件接口
};

//上传接口
struct UploadFileReq : CHTTPUploadReq {
};

struct UploadFileRet : CHTTPUploadRet {
};
struct UploadDataRet{
	int uploaded_length;
	bool upload_finish;
	string branchFilePath;
	string strBody;
};

//上传策略查询接口
struct UploadQueryPlanReq : CHTTPReq {
	string m_reqStr;
	string ToJson() {
		return m_reqStr;
	}
};

struct UploadQueryPlanRet : CHTTPRet {
	string m_retStr;
	bool Parse(string strData) {
		m_retStr=strData;
		return true;
	}
};
//查询临时计划文件状态接口
struct UploadQueryTempFileReq : CHTTPReq {
	string m_reqStr;
	string ToJson() {
		return m_reqStr;
	}
};

struct UploadQueryTempFileRet : CHTTPRet {
	string m_retStr;
	bool Parse(string strData) {
		m_retStr=strData;
		return true;
	}
};

//更新上传状态接口
struct UploadUpdateStateReq : CHTTPReq {
	string m_reqStr;
	string ToJson() {
		return m_reqStr;
	}
};

struct UploadUpdateStateRet : CHTTPRet {
	string m_retStr;
	bool Parse(string strData) {
		m_retStr=strData;
		return true;
	}
};

//增加失败流水接口
struct UploadUploadFailReq : CHTTPReq {
	string m_reqStr;
	string ToJson() {
		return m_reqStr;
	}
};

struct UploadUploadFailRet : CHTTPRet {
	string m_retStr;
	bool Parse(string strData) {
		m_retStr=strData;
		return true;
	}
};

struct UploadPlan{
	string plan_id;//计划ID
	string branch_no;//分行号
	string plan_type;//计划类型 T-临时计划(Temp)  P-永久计划（Permanent）
	string file_type;//文件类型 V-录像文件(Vedio) O-其他文件（Other）
	string path_type;//路径类型（R-相对路径，A-绝对路径）
	string path_name;//路径
	string file_name;//文件名通配符（*表示任意0个或N个字符，如*.* *xx xx*）
	string file_regex;//文件名正则表达式（通用的正则表达式，上面文件名通配符已够用，一般不使用）
	string before_deal_type; //上传前处理类型（Z压缩...）
	string after_deal_type;//上传后处理类型（D删除|M移动|N不动）
	string after_deal_text;//上传后处理操作（如 移动路径）
	int  file_limit;//（文件路径下最大扫描出文件个数，默认256）
	int  file_length_limit;//（扫描出文件最大长度限制，单位M）
	int  max_silent;//（文件最新修改时间流失间隔，用于热点文件隔离）
	string upload_address_env;//上传文件地址环境：DMZ: 行外，BIZ：行内
};

struct UploadFileInfo:UploadPlan{
	string filePath; //文件绝对路径(用于读取本地文件)
	string fileUploadPath;//上传给总行的绝对路径（不能超过900字符）
	//string fileUploadRelativePath;//上传给总行的路径（不超过900字符，不包含文件名称）
	string fileName; //文件名称
	string BranchFilePath;//分行文件路径（含IP）
	long fileLen;// 文件长度
	long decFileLen;//解密后的长度
	string decHeadJson;//解密后自定义头
	string editTime;//文件最后修改时间
//	UploadPlan* plan;//对应的计划指针
};

struct UploadReport{
	int sum;//一批上传文件个数
	int succ;//上传成功文件个数
	int fail;//上传失败文件个数
	int uploadFail;//上传失败次数
	int decodeFail;//解密失败次数
	int updateState;//上传登记失败次数
	int operateFileFail;//上传完处理文件失败次数
	int queryTempFail;//查询临时文件失败次数
	bool isBreak;//批次是否被中断
};
 

class UploadConnection;

class UploadFSM : public FSMImpl<UploadFSM>, public IFSMStateHooker, public ISysVarListener
{
public:
	enum {s0,s1,s2,s3,s4,s5,s6,s7};

	BEGIN_FSM_STATE(UploadFSM)
		FSM_STATE_ENTRY(s0,"Starting",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1, "Disable",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2, "Enable", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Connect", s3_on_entry, s3_on_exit, s3_on_event)
		FSM_STATE_ENTRY(s4, "Upload", s4_on_entry, s4_on_exit, s4_on_event)
		FSM_STATE_ENTRY(s5, "Release", s5_on_entry, s5_on_exit, s5_on_event)
		FSM_STATE_ENTRY(s6, "DisConnect", s6_on_entry, s6_on_exit, s6_on_event)//添加断连等待时间状态
		FSM_STATE_ENTRY(s7, "NewUpload", s7_on_entry, s7_on_exit, s7_on_event)//添加新模式上传状态
	END_FSM_STATE()

	BEGIN_FSM_RULE(UploadFSM,s0)
		FSM_RULE_ENTRY_ANY(s0, s1, USER_EVT_JMP_DISABLE)
		FSM_RULE_ENTRY_ANY(s0, s2, USER_EVT_JMP_ENABLE)
		FSM_RULE_ENTRY_ANY(s1, s2, USER_EVT_JMP_ENABLE)
		FSM_RULE_ENTRY_ANY(s2, s3, USER_EVT_JMP_CONNECT)//旧上传模式
		FSM_RULE_ENTRY_ANY(s2, s1, USER_EVT_JMP_DISABLE)
		FSM_RULE_ENTRY_ANY(s2, s7, USER_EVT_JMP_NEW_UPLOAD)//新上传模式
		FSM_RULE_ENTRY_ANY(s3, s4, USER_EVT_JMP_UPLOAD)
		FSM_RULE_ENTRY_ANY(s3, s1, USER_EVT_JMP_DISABLE)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_UPLOAD_ANS, 1)
		FSM_RULE_ENTRY(s4, s6, USER_EVT_DISCONNECT, 1)//断连时跳转到S6
		FSM_RULE_ENTRY(s4, s5, USER_EVT_BLOCK_ANS, 1)
		FSM_RULE_ENTRY_ANY(s4, s5, EVT_TIMER)
		FSM_RULE_ENTRY_ANY(s4, s1, USER_EVT_JMP_DISABLE)
		FSM_RULE_ENTRY_ANY(s5, s2, EVT_TIMER)
		FSM_RULE_ENTRY_ANY(s5, s2, USER_EVT_DISCONNECT)
		FSM_RULE_ENTRY_ANY(s5, s1, USER_EVT_JMP_DISABLE)
		FSM_RULE_ENTRY_ANY(s6, s2, EVT_TIMER)//等待一段时间进入S2
		FSM_RULE_ENTRY_ANY(s6, s1, USER_EVT_JMP_DISABLE)
		FSM_RULE_ENTRY_ANY(s7, s2, EVT_TIMER)//等待一段时间进入s2,重新开始扫描文件
		FSM_RULE_ENTRY_ANY(s7, s1, USER_EVT_JMP_NEW_DISABLE)//等待一段时间进入s2
	END_FSM_RULE()

	UploadFSM();
	~UploadFSM();

	virtual void OnStateTrans(int iSrcState, int iDstState);

	virtual void OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName);

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);

	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);

	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);

	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* event);

	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);

	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* event);

	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* event);

	void s7_on_entry();
	void s7_on_exit();
	unsigned int s7_on_event(FSMEvent* event);

private:
	/** 交易受限功能代码废弃
	ErrorCodeEnum LoadServerConfigFromCenterSetting();
	*/
	file_t *find_first_upload_file();
	void post_process();
	/** 交易受限功能代码废弃
	int getUploadFileNum(int &fileSumlen);
public:
	
	int getCheckDirFile(int silentTime);//检查文件夹文件个数
	void getUploadProgress(UploadProgress &progress);//获取上传文件状态
	bool clearUploadDate();//清空上传日期
	ErrorCodeEnum SaveUploadDate();//保存上传日期
	ErrorCodeEnum getUploadDate(CAutoArray<CSimpleStringA> &strList);//获取上传日期
	ErrorCodeEnum insertUploadDate();//插入上传日期
	bool uploadDate_exist(CSimpleStringA uploadDate);
	*/
public:
	bool queryPlan();//查询上传策略(true表示新模式，false表示旧模式)
	void scanFile();//扫描文件
	void scanDirfresh(UploadPlan* plan,const char* path);
	static void HttpsLogCallBack(const char* logtxt);
	bool IsFileMatch(const char *pszFilter, const char *pszFileName);//通配符过滤
	ErrorCodeEnum SM3FileToStr(CSimpleStringA strFilePath, CSimpleStringA &strSM3,bool isSub);//文件获取SM3 
	ErrorCodeEnum SM3_Str(CSimpleStringA &strSM3,BYTE * SM3Byte,bool isSub);//获取SM3字符串
	bool getFileContent(FILE* file,unsigned char* content,int beginPos, int contentLen);//从文件中获取内容
	bool test_zero_ref(const char *path);
	bool GetFileLength(const char* filePath,long &fileLen);//获取文件长度
	void reportBatchMsg();//报告批次消息
	
private:
	UploadConnection *m_pConnection;
	file_t *m_uploading_file; //当前正在上传的文件
	int m_uploading_block_id; //正在上传的块号
#ifdef RVC_OS_WIN
	HANDLE m_uploading_handle;
#else()
	FILE* m_uploading_handle;
#endif // RVC_OS_WIN
	
	char m_upload_id[16];

	CSimpleStringA m_terminalNo;
    /** 交易受限功能代码废弃
	CSimpleStringA m_server1;
	int m_server1_port;
	CSimpleStringA m_server2;
	int m_server2_port;
	*/
	struct list_head m_updir_list;//文件夹配置列表
	//添加lwt
    /** 交易受限功能代码废弃
	list<CSimpleStringA>* m_check_dir;//重点文件夹的列表
	DWORD m_dBeginTime;//统计上传速度开始时间
	DWORD m_dEndTime;//统计上传速度结束时间
	int m_iSpeed;//单位k/ms
	CRITICAL_SECTION m_cs;//临界区变量
	list<CSimpleStringA>* m_uploadDateList;//上传日期文件列表
	*/

	bool m_isOffLine;//是否坐席空闲

	int m_centerModel;//上传模式 （0:分行模式 1:混合模式  2:总行模式）
	
	bool m_uploadModel; //上传文件模式 （false:分行模式 ，true:总行模式）

	list<UploadFileInfo*>* m_uploadList; //新模式下待上传文件列表
	list<UploadPlan*>* m_uploadPlanList; //新模式策略列表
	
public:
	CenterUrl m_centerUrl;//访问总行的url地址集合
	string m_rootPath ;//系统根路径,例如：windows: C:     linux:/opt
	UploadFileInfo* m_currUploadFile;//正在上传的文件指针
	map<int,string> m_branchIpList;//新模式下分行服务器列表
	int m_eachUploadLen;//每次上传数据的最大长度,单位K
	UploadReport m_uploadReport;//每批次上传告警统计

};

class UploadConnection : public SpSecureClient
{
public:
	UploadConnection(CEntityBase *pEntity, UploadFSM *pFSM) : SpSecureClient(pEntity), m_pFSM(pFSM) {}

	void SendUpReq(file_t *file)
	{
		UploadReq req = {0};
		CSystemStaticInfo si;
		{
			m_pEntity->GetFunction()->GetSystemStaticInfo(si);
		}
		strcpy(&req.TerminalNo[0], si.strTerminalID);
		strcpy(&req.FileType[0], file->owner->name);

#ifdef RVC_OS_WIN
		strcpy(&req.FileName[0], file->name);
#else
		string fileName = file->name;
		std::string result = SP::Utility::UTF8ToGBK(fileName);
		strcpy(&req.FileName[0], result.c_str());
#endif // RVC_OS_WIN

		req.FileLength = file->length;
		req.FileCreatDate = file->create_time;
		CSmartPointer<IPackage> pkt = CreateNewPackage("UPREQ");
		pkt->AddStruct("UPREQ", false, false, (LPBYTE)&req, sizeof(UploadReq));
		
		SendPackage(pkt);
	}
#ifdef RVC_OS_WIN
	bool SendBlockReq(file_t* file, HANDLE hFile, const char* upload_id, int block_id)
	{
		bool ret = true;
		int nLen = sizeof(BlockReq) + 0x8000;
		BlockReq* req = (BlockReq*)new BYTE[nLen];
		memset(req, 0, nLen);
		CSystemStaticInfo si;
		{
			m_pEntity->GetFunction()->GetSystemStaticInfo(si);
		}
		req->BlockNo = block_id;
		strcpy(&req->TerminalNo[0], si.strTerminalID);
		strcpy(&req->FileName[0], file->name);
		memcpy(req->UploadID, upload_id, sizeof(req->UploadID));
		DWORD dwOffset = block_id << 15; // 32k once 		

		DWORD dwLength = min(file->length - dwOffset, 1 << 15);
		SetFilePointer(hFile, dwOffset, NULL, FILE_BEGIN);
		BOOL bRet = ReadFile(hFile, &req->Data[0], dwLength, &dwLength, NULL);
		if (bRet) {
			//Dbg("block len:%d", dwLength);
			CSmartPointer<IPackage>pkt = CreateNewPackage("BLKREQ");
			pkt->AddStruct("BLKREQ", false, false, (LPBYTE)req, sizeof(BlockReq) + dwLength);
			SendPackage(pkt);
			ret = true;
		}
		else {
			//增加跳出分支，防止状态机跳不出
			DWORD err = GetLastError();
			Dbg("SendBlockReq is error file name [%s] , block_id [%d] , GetLastError = %d", file->name, block_id, err);
			ret = false;
		}

		delete req;
		return ret;
	}
#else
	bool SendBlockReq(file_t* file, FILE* hFile, const char* upload_id, int block_id)
	{
		bool ret = true;
		int nLen = sizeof(BlockReq) + 0x8000;
		BlockReq* req = (BlockReq*)new BYTE[nLen];
		memset(req, 0, nLen);
		CSystemStaticInfo si;
		{
			m_pEntity->GetFunction()->GetSystemStaticInfo(si);
		}
		req->BlockNo = block_id;
		strcpy(&req->TerminalNo[0], si.strTerminalID);

		string fileName = file->name;
		std::string result = SP::Utility::UTF8ToGBK(fileName);
		strcpy(&req->FileName[0], fileName.c_str());

		memcpy(req->UploadID, upload_id, sizeof(req->UploadID));
		DWORD dwOffset = block_id << 15; // 32k once 		
		//DWORD dwLength = min(file->length - dwOffset, 1 << 15);
		DWORD dwLength = ((file->length - dwOffset) < (1 << 15)) ? (file->length - dwOffset) : (1 << 15);

		if (fseek(hFile, dwOffset, SEEK_SET)==0) {
			int bRet = fread(&req->Data[0], dwLength, 1, hFile);
			//dwLength=0时，表示文件长度是0，也需要发送到分行服务
			if (bRet == 1||dwLength==0) {
				CSmartPointer<IPackage>pkt = CreateNewPackage("BLKREQ");
				pkt->AddStruct("BLKREQ", false, false, (LPBYTE)req, sizeof(BlockReq) + dwLength);
				SendPackage(pkt);
				ret = true;
			}
			else {
				//增加跳出分支，防止状态机跳不出
				Dbg("SendBlockReq fread fail, is error file name [%s] , block_id [%d] ", file->name, block_id);
				ret = false;
			}
		}
		else {
			//增加跳出分支，防止状态机跳不出
			Dbg("SendBlockReq fseek fail, is error file name [%s] , block_id [%d]", file->name, block_id);
			ret = false;
		}
		
		delete req;
		return ret;
	}
#endif // RVC_OS_WIN

protected:
	virtual ~UploadConnection() {}
	virtual void OnDisconnect() 
	{
		m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
	}
	virtual void OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg)
	{
		string serviceCode = pRecvPkg->GetServiceCode();
		if (serviceCode == "UPREQ") 
		{
			DWORD dwSysCode, dwUserCode;
			string strErrMsg;
			ErrorCodeEnum rc = Error_Succeed;
			if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
			{
				rc = (ErrorCodeEnum)dwSysCode;
				LogWarn(Severity_Low, rc, dwUserCode, CSimpleStringA::Format("create up packet Fail!, %s", strErrMsg.c_str()).GetData());
				//Sleep(3000);
				OnDisconnect();
			}
			else
			{
				int nLen = pRecvPkg->GetStructLen("UPANS");
				if (nLen > 0) 
				{
					BYTE *pBuf = new BYTE[nLen];
					memset(pBuf, 0, nLen);
					int nArrayNum = 0;
					if (pRecvPkg->GetStructData("UPANS", pBuf, &nLen, &nArrayNum)) 
					{
						FSMEvent *evt = new UploadAnsEvent(pBuf, nLen);
						m_pFSM->PostEventFIFO(evt);
					} 
					else 
					{
						Dbg("create invalid upans packet!");
						OnDisconnect();
					}
					delete pBuf;
				}else{
					//nlen增加跳出分支
					Dbg("upans packet len is error len=%d",nLen);
					//Sleep(1000);
					OnDisconnect();
				}

			}
		} 
		else if (serviceCode == "BLKREQ") 
		{
			DWORD dwSysCode, dwUserCode;
			string strErrMsg;
			ErrorCodeEnum rc = Error_Succeed;
			if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
			{
				rc = (ErrorCodeEnum)dwSysCode;
				LogError(Severity_Middle, rc, dwUserCode, CSimpleStringA::Format("create up blk Fail!, %s", strErrMsg.c_str()));
				//Sleep(3000);
				OnDisconnect();
			}
			else
			{
				int nLen = pRecvPkg->GetStructLen("BLKANS");
				if (nLen > 0) 
				{
					BYTE *pBuf = new BYTE[nLen];
					memset(pBuf, 0, nLen);
					int nArrayNum = 0;
					if (pRecvPkg->GetStructData("BLKANS", pBuf, &nLen, &nArrayNum)) 
					{
						FSMEvent *evt = new BlockAnsEvent(pBuf, nLen);
						m_pFSM->PostEventFIFO(evt);
					} 
					else 
					{
						Dbg("create invalid blkans packet!");
						OnDisconnect();
					}
					delete pBuf;
				}else{
					//nlen增加跳出分支
					Dbg("blkans packet len is error len=%d",nLen);
					//Sleep(1000);
					OnDisconnect();
				}
			}
		} 
		else 
		{
			Dbg("unknown service code! code= %s",serviceCode.c_str());
			//Sleep(2000);
			OnDisconnect();
		}
	}

private:
	UploadFSM *m_pFSM;
};
#endif // RVC_MOD_UPLOAD_UPLOADFSM_H_