myvtm/Module/mod_alarm/AlarmFSM.h

#ifndef RVC_MOD_ALARM_FSM_H_
#define RVC_MOD_ALARM_FSM_H_

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

#include "Alarm.h"
#include "IHttpFunc.h"

#define USER_EVT_JMP_ALARMUP	    EVT_USER+1
#define USER_EVT_JMP_ALARMSTATEUP	EVT_USER+2
#define USER_EVT_JMP_RELEASE		EVT_USER+3
#define USER_EVT_DISCONNECT			EVT_USER+4
#define USER_EVT_UPLOAD_ANS			EVT_USER+5
#define USER_EVT_ALARMSTATE_ANS		EVT_USER+6
#define USER_EVT_DISCONNECT_FAIL	EVT_USER+7
#define USER_EVT_DISCONNECT_SUCC	EVT_USER+8
#define USER_EVT_JMP_START			EVT_USER+9
#define USER_EVT_JMP_NEW_ALARM		EVT_USER+10
#define USER_EVT_SEND_ALARM			EVT_USER+11

#define WARN_ALARM_START_NEW_MODE 0x10700001 //启动新模式告警
#define WARN_ALARM_START_OLD_MODE 0x10700002 //启动旧模式告警
#define WARN_ALARM_SEND_FAIL	  0x10700003 //长时间发送失败丢弃告警
#define WARN_ALARM_PARSE_FAIL	  0x10700004 //解析失败发送失败丢失告警

#pragma pack(1)
const int UPLOG_MAX_COUNT = 500;//队列长度
//[StructName("ALARMUPLOAD")]
struct AlarmUpload
{
	char TerminalNo[16];
	char EntityName[32];
	char SN[20];
#ifdef RVC_OS_WIN
	unsigned long  LifeID;
	unsigned long Item;
	unsigned long UserCode;
#else 
	uint32_t  LifeID;
	uint32_t Item;
	uint32_t UserCode;
#endif
	char Level;
	char Description[512];
};

//[StructName("ALARMANS")]
struct AlarmReply
{
	int ResultCode;
};
// [StructName("ALARMSTATE")]
struct AlarmStateUpload
{
	char TerminalNo[16];
#ifdef RVC_OS_WIN
	unsigned __int64 SN;
#else
	unsigned long long SN;
#endif
	unsigned long  LifeID;
	unsigned long Item;
	char Level;
	char Description[512];
};

//[StructName("ALARMSTATEANS")]
struct AlarmStateReply
{
	int ResultCode;
};


#pragma pack()

enum AlarmCtlCode
{
	Finish = 0,             //完成
	Error = 1,              //错误
};

struct AlarmAnsEvent : public FSMEvent 
{
	AlarmAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_UPLOAD_ANS) 
	{
		memcpy(&m_reply, pBuf, sizeof(AlarmReply));
	}
	virtual ~AlarmAnsEvent() {}
	AlarmReply m_reply;
};

struct AlarmStateAnsEvent : public FSMEvent
{
	AlarmStateAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_ALARMSTATE_ANS) 
	{
		memcpy(&m_reply, pBuf, sizeof(AlarmStateReply));
	}
	virtual ~AlarmStateAnsEvent() {}
	AlarmStateReply m_reply;
};

struct SendAlarmEvent:public FSMEvent
{
	bool isSucc;//是否写入成功
	SendAlarmEvent(bool isSendSucc) 
		: FSMEvent(USER_EVT_SEND_ALARM), isSucc(isSendSucc)
	{}
};

namespace HttpStruct
{
	//发送文件hash列表接口
	struct SendAlarmTaskReq : CHTTPReq {
		string m_reqStr;
		string ToJson() {
			return m_reqStr;
		}
	};
	struct SendAlarmTaskRet : CHTTPRet {
		string m_retStr;
		bool Parse(string strData) {
			m_retStr=strData;
			return true;
		}
	};
}
class AlarmConnection;

class AlarmFSM : public FSMImpl<AlarmFSM>, public IFSMStateHooker, public ISysVarListener
{
public:
	enum {s0,s1,s2,s3};

	BEGIN_FSM_STATE(AlarmFSM)
		FSM_STATE_ENTRY(s0,"Starting",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1, "AlarmUp", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "AlarmStateUp", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Release", s3_on_entry, s3_on_exit, s3_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(AlarmFSM,s0)
		FSM_RULE_ENTRY_ANY(s0, s1, USER_EVT_JMP_ALARMUP)
		//FSM_RULE_ENTRY_ANY(s0, s2, USER_EVT_JMP_ALARMSTATEUP)
		//FSM_RULE_ENTRY_ANY(s1, s3, USER_EVT_JMP_RELEASE)
		FSM_RULE_ENTRY_ANY(s1, s0, USER_EVT_JMP_START)
		//FSM_RULE_ENTRY_ANY(s1, s0, EVT_TIMER)
		//FSM_RULE_ENTRY_ANY(s2, s3, USER_EVT_JMP_RELEASE)
		//FSM_RULE_ENTRY_ANY(s2, s0, EVT_TIMER)
		//FSM_RULE_ENTRY_ANY(s3, s0, EVT_TIMER)
		//FSM_RULE_ENTRY_ANY(s3, s0, USER_EVT_DISCONNECT)
		END_FSM_RULE()

	AlarmFSM();
	~AlarmFSM();

	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 add_alarm(alarm_t*alarm);
	//设置告警状态
	void set_alarm_state(const CUUID nLogID,DWORD LifeId,const SeverityLevelEnum eLevel,
						DWORD Item,const char *pszMessage);

	//增加历史告警
	void add_UploadedAlarm(alarm_t*alarm);
	bool is_UploadedAlarm_empty();

	//是否是已上传告警
	bool find_UploadedAlarm(alarm_t*alarm);
	bool update_UploadedAlarm(alarmUpgraded_t*alarm);

	//告警状态标志位
	BOOL m_b_alarmstate;

	//增加告警新接口
	void add_NewAlarm(alarm_t*alarm);
	//增加告警取出消息新接口
	alarm_t* removeAlarm();
	void closeClientConn();
	bool SendAlarm();
	int m_iEachSend;//每次发送数量
	long m_iRec;//累计收到的告警数目
	long m_iSend;//累计队列发送总数,新模式丢失这个数据统计
	long m_iThrow;//累计队列丢弃总数
	long m_iFail;//累计发送失败总次数
	long m_iSucc;//累计发送成功总次数
	vector<alarm_t*> m_NewUploading_alarm;//新的告警记录列表

	//modify by lwt
	CSimpleStringA m_unSendAlarm;//未发送出去的告警信息(json格式)
	int m_CenterModel;//集中配置模式 0：分行模式 1：总行模式
	CSimpleStringA m_topic;//总行kafka topic
	CSimpleStringA m_sendUrl;//总行告警url服务地址
	CSimpleStringA m_branchNo;//终端告警分行服务信息
	CSmallDateTime m_sendBeginTime;//告警每次发送开始时间
	int m_maxResendTime;//告警最大重发时间间隔(秒)
	int m_eachSum;//每批次条数
	CUUID m_uuid;//告警的UUID
	bool m_initAlarm;//初次化告警标志位

	static void HttpsLogCallBack(const char* logtxt);
	string alarmJson();
#ifdef RVC_OS_WIN
#else
	int HexBuf2StrBuf(PBYTE hexBuf, char** strBuf, DWORD len);
#endif
private:
	//获取告警数量
	bool is_alarm_empty();
	

private:
	CRITICAL_SECTION cs;
	AlarmConnection *m_pConnection;
	struct list_head m_uploading_alarm; 
	struct list_head m_uploaded_alarm; 
	alarm_state_t m_uploading_alarmstate;

	CSimpleStringA m_terminalNo;
	int m_nDealWarningTime;
	
};

class AlarmConnection : public SpSecureClient
{
public:
	AlarmConnection(CEntityBase *pEntity, AlarmFSM *pFSM) : SpSecureClient(pEntity), m_pFSM(pFSM) {}
	virtual ~AlarmConnection() {}

	void SendAlarm(alarm_t*alarm)
	{
		
		AlarmUpload alarmup = {0};
		CSystemStaticInfo si;
		{
			m_pEntity->GetFunction()->GetSystemStaticInfo(si);
		}
		strcpy(alarmup.TerminalNo, si.strTerminalID);
		strcpy(alarmup.EntityName, alarm->EntityName);
		strcpy(alarmup.SN,alarm->SN);
		alarmup.LifeID = alarm->LifeID;
		alarmup.Item = alarm->Item;
		alarmup.UserCode = alarm->UserCode;
		alarmup.Level = alarm->Level;
		strcpy(alarmup.Description, alarm->Description);
		CSmartPointer<IPackage> pkt = CreateNewPackage("WARNING");
		pkt->AddStruct("WARNING", false, false, (LPBYTE)&alarmup, sizeof(AlarmUpload));
		//SendPackage(pkt);
		if (SendPackage(pkt) == "")
		{
			//Dbg("send fail");
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("SendAlarm")("send fail");
			m_pFSM->m_iFail++;//失败计数
			//发送失败，断开连接
			m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT_FAIL));//失败，等下次发送
		}else{
			//Dbg("send succ");
		}
	}

	void SendAlarmState(alarm_state_t*alarmstate)
	{
		AlarmStateUpload alarmstate0 = {0};
		CSystemStaticInfo si;
		{
			m_pEntity->GetFunction()->GetSystemStaticInfo(si);
		}
		strcpy(&alarmstate0.TerminalNo[0], si.strTerminalID);
		alarmstate0.SN = alarmstate->SN;
		alarmstate0.LifeID = alarmstate->LifeID;
		alarmstate0.Level = alarmstate->Level;
		alarmstate0.Item = alarmstate->Item;
		strcpy(&alarmstate0.Description[0], alarmstate->Description);
		CSmartPointer<IPackage> pkt = CreateNewPackage("STATE");
		pkt->AddStruct("STATE", false, false, (LPBYTE)&alarmstate, sizeof(AlarmUpload));
		SendPackage(pkt);
	}

protected:
	virtual void OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg) {
		string serviceCode = pRecvPkg->GetServiceCode();
		if (serviceCode == "WARNING") 
		{
			//Dbg("rece ans 1");
			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 packet Fail!, %s", strErrMsg.c_str()));
				//跳出连接
				OnDisconnect();
			}else{
				//Dbg("rece ans 2");
				int nLen = pRecvPkg->GetStructLen("WANS");
				if (nLen > 0) 
				{
					BYTE *pBuf = new BYTE[nLen];
					memset(pBuf, 0, nLen);
					int nArrayNum = 0;
					if (pRecvPkg->GetStructData("WANS", pBuf, &nLen, &nArrayNum)) 
					{
						//Dbg("rece ans 3");
						FSMEvent *evt = new AlarmAnsEvent(pBuf, nLen);
						AlarmAnsEvent *ans = (AlarmAnsEvent *)evt;
						if (ans->m_reply.ResultCode == Finish)
						{
							//Dbg("send finish!");
							m_pFSM->m_iSucc++;//成功计数
						}
						else if (ans->m_reply.ResultCode == Error)
						{
							m_pFSM->m_iFail++;//失败计数
							//Dbg("send error!");
							DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnPkgAnswer WARNING")("send error!");
						}
						delete evt;
						m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_UPLOAD_ANS));//继续发送
					} 
					else 
					{
						//Dbg("create invalid alarm upans packet!");
						DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnPkgAnswer WARNING")("create invalid alarm upans packet!");
						OnDisconnect();
						//跳出连接
					}
					delete pBuf;
				}
			}
		} 
		else if (serviceCode == "STATE")
		{
			int nLen = pRecvPkg->GetStructLen("SANS");
			if (nLen > 0) 
			{
				BYTE *pBuf = new BYTE[nLen];
				memset(pBuf, 0, nLen);
				int nArrayNum = 0;
				if (pRecvPkg->GetStructData("SANS", pBuf, &nLen, &nArrayNum)) 
				{
					FSMEvent *evt = new AlarmStateAnsEvent(pBuf, nLen);
					AlarmStateAnsEvent *ans = (AlarmStateAnsEvent *)evt;
					if (ans->m_reply.ResultCode == Finish)
					{
						//Dbg("alarmstate upload finish!");
						DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnPkgAnswer STATE")("alarmstate upload finish!");

					}
					else if (ans->m_reply.ResultCode == Error)
					{
						//Dbg("alarmstate upload error!");
						DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnPkgAnswer STATE")("alarmstate upload error!");
					}
					delete evt;
				} 
				else 
				{
					//Dbg("create invalid alarmstate upans packet!");
					DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnPkgAnswer STATE")("create invalid alarmstate upans packet!");
					OnDisconnect();
				}
				delete pBuf;
			}

		}
		else 
		{
			//Dbg("unknown service code!");
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnPkgAnswer")("unknown service code!");
			OnDisconnect();
			//跳出连接
		}
	}
	virtual void OnDisconnect() 
	{
		m_pFSM->m_iFail++;//失败计数
		m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT_FAIL));
	}
	virtual void OnReceivePackage(IPackage *pRecvPkg)
	{
		//string serviceCode = pRecvPkg->GetServiceCode();
		//if (serviceCode == "WARNING") 
		//{
		//	Dbg("rece ans 1");
		//	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 packet Fail!, %s", strErrMsg.c_str()));
		//		//跳出连接
		//		OnDisconnect();
		//	}else{
		//		Dbg("rece ans 2");
		//		int nLen = pRecvPkg->GetStructLen("WANS");
		//		if (nLen > 0) 
		//		{
		//			BYTE *pBuf = new BYTE[nLen];
		//			memset(pBuf, 0, nLen);
		//			int nArrayNum = 0;
		//			if (pRecvPkg->GetStructData("WANS", pBuf, &nLen, &nArrayNum)) 
		//			{
		//				Dbg("rece ans 3");
		//				FSMEvent *evt = new AlarmAnsEvent(pBuf, nLen);
		//				AlarmAnsEvent *ans = (AlarmAnsEvent *)evt;
		//				if (ans->m_reply.ResultCode == Finish)
		//				{
		//					Dbg("alarm upload finish!");
		//				}
		//				else if (ans->m_reply.ResultCode == Error)
		//				{
		//					Dbg("alarm upload error!");
		//				}
		//				delete evt;
		//				m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_UPLOAD_ANS));//继续发送
		//			} 
		//			else 
		//			{
		//				Dbg("create invalid alarm upans packet!");
		//				OnDisconnect();
		//				//跳出连接
		//			}
		//			delete pBuf;
		//		}
		//	}
		//} 
		//else if (serviceCode == "STATE")
		//{
		//	int nLen = pRecvPkg->GetStructLen("SANS");
		//	if (nLen > 0) 
		//	{
		//		BYTE *pBuf = new BYTE[nLen];
		//		memset(pBuf, 0, nLen);
		//		int nArrayNum = 0;
		//		if (pRecvPkg->GetStructData("SANS", pBuf, &nLen, &nArrayNum)) 
		//		{
		//			FSMEvent *evt = new AlarmStateAnsEvent(pBuf, nLen);
		//			AlarmStateAnsEvent *ans = (AlarmStateAnsEvent *)evt;
		//			if (ans->m_reply.ResultCode == Finish)
		//			{
		//				Dbg("alarmstate upload finish!");
		//			}
		//			else if (ans->m_reply.ResultCode == Error)
		//			{
		//				Dbg("alarmstate upload error!");
		//			}
		//			delete evt;
		//		} 
		//		else 
		//		{
		//			Dbg("create invalid alarmstate upans packet!");
		//			OnDisconnect();
		//		}
		//		delete pBuf;
		//	}

		//}
		//else 
		//{
		//	Dbg("unknown service code!");
		//	OnDisconnect();
		//	//跳出连接
		//}
	}

private:
	AlarmFSM *m_pFSM;
};
#endif //RVC_MOD_ALARM_FSM_H_