monitorbasicclass.cs

监控系统

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
using System.Collections;

namespace MonitorSystem.BasicClass
{
	/// <summary>
	/// 报警规则类
	/// </summary>
	public class AlertRule
	{
		/// <summary>
		/// 报警临界值
		/// </summary>
		public int CriticalValue;
		/// <summary>
		/// 临界值关系 0：等于，1：小于，2：大于，3：不等于，4：大于等于，5：小于等于
		/// </summary>
		public int Relation;
		/// <summary>
		/// 报警等级 1 一般警告，2 严重警告，3 一般故障，4 严重故障，5 待判断
		/// </summary>
		public int Level;
		/// <summary>
		/// 报警方式 0 无，1 鸣叫，2 短信，3 email, 4 待判断
		/// </summary>
		public int Action;
		/// <summary>
		/// 报警参数
		/// </summary>
		public string ActionParam;

		public AlertRule()
		{
			//
			// TODO: 在此处添加构造函数逻辑
			//			
		}

		/// <summary>
		/// 根据采集的值检查报警规则
		/// </summary>
		/// <returns></returns>
		public int Check()
		{
			return -1;
		}
	}

	/// <summary>
	/// 监控规则类，是实际监控项目类的基类
	/// </summary>
	public abstract class MonitorRule
	{
		/// <summary>
		/// 规则ID
		/// </summary>
		public int RuleID;
		/// <summary>
		/// 规则类型id
		/// </summary>
		public int TypeID;
		/// <summary>
		/// 规则名称
		/// </summary>
		public string RuleName;
		/// <summary>
		/// 执行时间间隔（采集时间间隔）
		/// </summary>
		public int ScanInterval;
		/// <summary>
		/// 报警检查间隔，用扫描值的平均值与报警值比较
		/// </summary>
		public int CheckInterval;
		/// <summary>
		/// 扫描值
		/// </summary>
		public int Value;
		/// <summary>
		/// 临时保存报警检查间隔内Value的总和
		/// </summary>
		public double totalValue;
		/// <summary>
		/// 累加计数器，如等于CheckInterval/ScanInterval则表示计数结束
		/// </summary>
		public int Counter;
		/// <summary>
		/// 指定规则最后一次执行的时间
		/// </summary>
		public DateTime LastExcuteTime;
		/// <summary>
		/// 规则开始执行时间
		/// </summary>
		public DateTime StartTime;
		/// <summary>
		/// 规则结束执行时间
		/// </summary>
		public DateTime EndTime;
		/// <summary>
		/// 节点所属平台ID
		/// </summary>
		public int PlatformID;
		/// <summary>
		/// 所属节点ID
		/// </summary>
		public int NodeID;
		/// <summary>
		/// 报警规则列表
		/// </summary>
		public AlertRule[] AlertRule;
		/// <summary>
		/// 该监控记录是否监控规则更新记录的标记
		/// </summary>
		public bool m_bUpdate=false;
        
		public MonitorRule()
		{
			totalValue=0;
			Counter=0;

			this.StartTime = DateTime.MinValue;
			this.EndTime = DateTime.MaxValue;

		}

		public abstract object ExcuteCollect();	//执行监控，并将监控数据写入原始监控数据队列

	}

	public class UpdateRecord:MonitorRule
	{
		public UpdateRecord()
		{
			this.m_bUpdate=true;
		}

		public override object ExcuteCollect()
		{
			return null;
		}
	}


	#region  监控节点类
	/// <summary>
	/// 监控节点类
	/// </summary>
	/*
	public class MonitorNode
	{
		private MonitorRule[] m_RuleList=null;	//监控规则列表

		private int m_PlatformID;		//平台ID
		private int m_NodeID;			//节点ID
		private string m_NodeName;		//节点名称
		private string m_NodeRemark;	//节点说明
		private string m_strIP;			//中心接口IP地址
		private int	m_iPort;			//中心接口socket通讯端口号

		private string m_LogFtpPath;	//监控日志文件上传的FTP路径
		private string m_ConfigFtpPath;	//监控规则的配置文件的FTP路径
		private string m_FtpLoginID;	//中心接口FTP帐号
		private string m_FtpLoginPwd;	//中心接口FTP登录密码

		private string m_LogPath;		//监控日志文件本地保存路径
		private string m_RulePath;		//规则配置文件本地保存路径


		private IPAddress m_hostIPAddress;
		private IPEndPoint m_Server;
		private Socket m_Sock;

		private NodeRegPackage m_NodeReg=new NodeRegPackage();
		private NodeRegRespPackage m_NodeResp=new NodeRegRespPackage();

		#region 属性
		/// <summary>
		/// 平台ID
		/// </summary>
		public int PlatformID
		{
			get{return m_PlatformID;}
			set{m_PlatformID=value;}
		}
		/// <summary>
		/// 节点ID
		/// </summary>
		public int NodeID
		{
			get{return m_NodeID;}
			set{m_NodeID=value;}
		}
		/// <summary>
		/// 节点名称
		/// </summary>
		public string NodeName
		{
			get{return m_NodeName;}
			set{m_NodeName=value;}
		}
		/// <summary>
		/// 节点说明
		/// </summary>
		public string NodeRemark
		{
			get{return m_NodeRemark;}
			set{m_NodeRemark=value;}
		}
		/// <summary>
		/// 监控日志文件上传的FTP路径
		/// </summary>
		public string LogFtpPath
		{
			get{return m_LogFtpPath;}
			set{m_LogFtpPath=value;}
		}
		/// <summary>
		/// 监控规则的配置文件的FTP路径
		/// </summary>
		public string ConfigFtpPath
		{
			get{return m_ConfigFtpPath;}
			set{m_ConfigFtpPath=value;}
		}
		/// <summary>
		/// 中心接口FTP帐号
		/// </summary>
		public string FtpLoginID
		{
			get{return m_FtpLoginID;}
			set{m_FtpLoginID=value;}
		}
		/// <summary>
		/// 中心接口FTP登录密码
		/// </summary>
		public string FtpLoginPwd
		{
			get{return m_FtpLoginPwd;}
			set{m_FtpLoginPwd=value;}
		}
		/// <summary>
		/// 中心接口IP地址
		/// </summary>
		public string IPAdress
		{
			get{return m_strIP;}
			set{m_strIP=value;}
		}
		/// <summary>
		/// 中心接口端口号
		/// </summary>
		public int Port
		{
			get{return m_iPort;}
			set{m_iPort=value;}
		}
		/// <summary>
		/// 监控日志文件本地保存路径
		/// </summary>
		public string LogPath
		{
			get{return m_LogPath;}
			set{m_LogPath=value;}
		}
		/// <summary>
		/// 规则配置文件本地保存路径
		/// </summary>
		public string RulePath
		{
			get{return m_RulePath;}
			set{m_RulePath=value;}
		}
		#endregion

		public MonitorNode()
		{
			this.m_PlatformID=1;
		}

		/// <summary>
		/// 读节点基本配置信息文件，此文件由人工生成、配置
		/// 保存节点的注册请求信息
		/// </summary>
		public int ReadNodeConfig(string strFilePath)
		{
			try
			{
				FileInfo fi=new FileInfo(strFilePath);
				if (fi.Exists)
				{
					FileStream fs = fi.OpenRead();
					StreamReader sr = new StreamReader (fs,new System.Text.ASCIIEncoding());

					string line="";
					string[] delim = new string[]{"NodeID=","NodeName=","NodeRemark=","TcpServerIP=","TcpServerPort="};
					for (int i=0;(line=sr.ReadLine())!=null&&i<5; i++)
					{
						if (i==0)
							m_NodeID = Convert.ToInt32(line.Trim(delim[i].ToCharArray()));
						else if (i==1)
							m_NodeName = line.Trim(delim[i].ToCharArray());
						else if (i==2)
							m_NodeRemark = line.Trim(delim[i].ToCharArray());
						else if (i==3)
							m_strIP = line.Trim(delim[i].ToCharArray());
						else if (i==4)
							m_iPort = Convert.ToInt32(line.Trim(delim[i].ToCharArray()));
					}
				}
				else
				{
					throw new Exception("节点配置文件不存在");
				}
			}
			catch(Exception ex)
			{
				//错误处理
				string msg = ex.Message;
				return -1;
			}
			return 0;
		}		



		/// <summary>
		/// 在监控平台上注册该节点，Socket方式。并将保存平台ID、日志文件上传的FTP路径、监控规则的配置文件路径
		/// </summary>
		/// <returns>
		/// 成功:将配置信息写入对应的成员变量
		/// 失败:抛出一个异常
		/// </returns>
		public void RegNode()
		{
			try
			{
				m_hostIPAddress=IPAddress.Parse(m_strIP);
			}
			catch
			{
				string msg="IP地址格式错误。";
				throw new Exception(msg);
			}

			#region 发送、接收注册信息
			try
			{
				m_Server=new IPEndPoint(m_hostIPAddress,m_iPort);
				m_Sock=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
				m_Sock.Connect(m_Server);

				byte[] ByteSend = new byte[1024];
				ByteSend=m_NodeReg.EncodeSocketPackage();
				m_Sock.Send(ByteSend,ByteSend.Length,0);

				byte[] ByteRecv=new byte[1024];
				m_Sock.Receive(ByteRecv,ByteRecv.Length,0);
				m_NodeResp.DecodeSocketPackage(ByteRecv);
				m_Sock.Close();
			}
			catch(Exception ex)
			{
				string msg=ex.Message;
				throw new Exception(msg);
			}
			#endregion

			#region 检查response包体
			try
			{
				char[] checkHeadFlag = new char[]{'O','P','E','N','E','T'};
				if (m_NodeResp.HeadFlag==checkHeadFlag && m_NodeResp.ContentLength==656
					&& m_NodeResp.PacketType=='1')
				{
					if (m_NodeResp.Result==1)
						throw new Exception("注册未通过中心接口鉴权！");

					if (m_NodeResp.PlatformID.Length <= 0)
						throw new Exception("监控平台ID号错误！");
					else
						m_PlatformID = Convert.ToInt32(m_NodeResp.PlatformID);

					if (m_NodeResp.LogFtpPath.Length<=0)
						throw new Exception("日志上传路径错误");
					else
						m_LogFtpPath = string.Format("{0}",m_NodeResp.LogFtpPath);
					if (m_NodeResp.ConfigFtpPath.Length<=0)
						throw new Exception("配置文件更新FTP路径错误");
					else
						m_ConfigFtpPath=string.Format("{0}",m_NodeResp.ConfigFtpPath);

					m_FtpLoginID=string.Format("{0}",m_NodeResp.FtpLoginID);
					m_FtpLoginPwd=string.Format("{0}",m_NodeResp.FtpLoginPwd);
				}
				else
				{
					throw new Exception("应答包包头信息错误！");
				}
			}
			catch(Exception ex)
			{
				throw new Exception(ex.Message);
			}
			#endregion
		}

		public void RegInit(char[] HeadFlag,int ContentLength,uint CommandID,char PacketType,int Version,int Encrypt,char[] Reserve)
		{
			m_NodeReg.MonitorNodeID = String.Format("{0,4:0000}",this.m_NodeID).ToCharArray(0,4);
			m_NodeReg.MonitorNodeName = this.m_NodeName.ToCharArray(0,64);
			m_NodeReg.MonitorRemark = this.m_NodeRemark.ToCharArray(0,128);

			m_NodeReg.HeadFlag = HeadFlag;
			m_NodeReg.ContentLength = ContentLength;
			m_NodeReg.CommandID = CommandID;
			m_NodeReg.PacketType = PacketType;
			m_NodeReg.Version = Version;
			m_NodeReg.Encrypt = Encrypt;