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_NewAlarm(alarm_t*alarm);
	//增加告警取出消息新接口
	alarm_t* removeAlarm();

	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：分行模式 2：总行模式
	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();
private:

	

private:
	CRITICAL_SECTION cs;

	struct list_head m_uploading_alarm; 
	struct list_head m_uploaded_alarm; 
	alarm_state_t m_uploading_alarmstate;

	CSimpleStringA m_terminalNo;
	int m_nDealWarningTime;
	
};
#endif //RVC_MOD_ALARM_FSM_H_