recordparsethread.cs

监控系统

using System;
using System.IO;
using System.Threading;
using System.Collections;
using MonitorSystem.BasicClass;
using MonitorSystem.LogFileModule;
using MonitorSystem.RuleFileProcess;

namespace MonitorSystem.MonitorInterface
{
	/// <summary>
	/// LogRecord处理线程，将LogRecord与对应XML文件中的规则对比，写入报警信息
	/// 并将处理后的LogRecord写入新的Log文件中，Log文件定时入队列UploadLogQueue.
	/// </summary>
	public class RecordParseThread
	{
		private Thread m_Thread;
		private bool m_Pause;
		private bool m_Exit;

		private RecordQueue m_RecordQueue;
		private UploadLogQueue m_UploadLogQueue;
		private ConfigFile m_CfgFile;
		private SystemLog m_SysLog;
		private LogFile m_LogFile;
		private RuleFile m_Rule;
		public static Hashtable  m_xhTable = new Hashtable();
		private static Hashtable m_checkRule;	

		private string m_RuleFileName;
		private string m_RemoteFileName;
		private string m_LogNameHead;

		public static  Mutex     m_Lock = new Mutex(false);

		public RecordParseThread()
		{
			m_SysLog=new SystemLog();
			m_checkRule = Hashtable.Synchronized( m_xhTable );

			m_Pause = false;
			m_Exit = false;
		}

		public void Init(ref RecordQueue queRecord,ref UploadLogQueue queUploadLog,ConfigFile iCfgFile,ref LogFile iLogFile)
		{
			m_RecordQueue = queRecord;
			m_UploadLogQueue = queUploadLog;
			m_CfgFile = iCfgFile;
			m_LogFile = iLogFile;

			string LogPath = m_CfgFile.LogLocal_Path;
			m_LogNameHead = LogPath + m_CfgFile.LogFileHead;
			
		}

		public void Run()
		{
			while(true)
			{
				while(m_Pause)
				{
					try
					{
						Thread.Sleep(1000);
					}
					catch(Exception)
					{
					}
					continue;
				}
				if(m_Exit)
				{
					break;
				}

				
				if (m_RecordQueue.Count<=0)
				{
					
					try
					{
						Thread.Sleep(1000);
						continue;
					}
					catch(Exception)
					{
						continue;
					}
				}


				LogFile logRecord = new LogFile();
				logRecord = (LogFile)m_RecordQueue.Dequeue();

				string strPlatformID=String.Format("{0:0000}",logRecord.iPlatformID);
				string strNodeID=String.Format("{0:0000}",logRecord.iNodeID);
				m_RuleFileName=m_CfgFile.RuleLocal_Path;
				m_RemoteFileName = m_CfgFile.RuleRemote_Path;
				m_RuleFileName+=m_CfgFile.RuleFileNameFormat;
				m_RuleFileName=m_RuleFileName.Replace("XXXX", strPlatformID);
				m_RuleFileName=m_RuleFileName.Replace("YYYY", strNodeID);

				string tmpRuleFileName=m_RuleFileName.Replace(m_CfgFile.RuleLocal_Path,m_CfgFile.RuleTemp_Path);

				//如果logRecord是一条Update记录，就将对应的xml文件从\rule\temp 目录下复制到\rule\Local目录下,并删除\rule\remote文件
				if(logRecord.strValue=="Update")
				{
					try
					{
                        //File.Delete(m_RemoteFileName);

						
						if(File.Exists(tmpRuleFileName))
						{
							File.Delete(m_RuleFileName);
							File.Move(tmpRuleFileName,m_RuleFileName);
						}

						lock(m_Lock)
						{
							UpdateCheckRule(logRecord.iPlatformID, logRecord.iNodeID, m_RuleFileName);
						}

					}
					catch(Exception ex)
					{
						m_SysLog.WriteToSysLog(ex.Message + ex.StackTrace);
					}
					continue;
				}

				try
				{
//					if(m_checkRule == null)
//					{
//						UpdateCheckRule(logRecord.iPlatformID, logRecord.iNodeID, m_RuleFileName);
//					}

					if(logRecord.iRuleID!=0&&logRecord.iTypeID!=99)
					{
						MonitorRule rule = null;
						
							//非心跳检测记录
//							int index = GetRuleIndex(ref m_checkRule, logRecord.iPlatformID,logRecord.iNodeID,logRecord.iRuleID);
//							if(index == -1)
//							{
//								UpdateCheckRule(logRecord.iPlatformID, logRecord.iNodeID, m_RuleFileName);
//								index = GetRuleIndex(ref m_checkRule, logRecord.iPlatformID, logRecord.iNodeID, logRecord.iRuleID);
//							}
                            
						string key = logRecord.iPlatformID.ToString().PadLeft(4,'0') + logRecord.iNodeID.ToString().PadLeft(4,'0') + logRecord.iRuleID.ToString().PadLeft(4,'0');
						if(!m_checkRule.Contains(key))
						{
							lock(m_Lock)
							{
								UpdateCheckRule(logRecord.iPlatformID, logRecord.iNodeID, m_RuleFileName);
							}
						}
						rule = (MonitorRule)m_checkRule[key];
						

						
					
						if(logRecord.iPlatformID!=rule.PlatformID)
						{
							m_SysLog.WriteToSysLog(2,"logRecord与规则文件中的平台ID不符.");
							continue;
						}
						else if(logRecord.iNodeID!=rule.NodeID)
						{
							m_SysLog.WriteToSysLog(2,"logRecord与规则文件中的节点ID不符.");
							continue;
						}
						else if(logRecord.iTypeID!=rule.TypeID)
						{
							m_SysLog.WriteToSysLog(2,"logRecord与规则文件中的规则类型ID不符.");
							continue;
						}
						else
						{
							int iValue=0;
							bool bStartCheck=false;

							if(rule.CheckInterval>0)
							{
								//该记录对应的规则需要检查间隔内数据的平均值，与报警临界值比较
								int iNumber = rule.CheckInterval/rule.ScanInterval;
								if(iNumber>rule.Counter)
								{
									rule.totalValue += Convert.ToDouble(logRecord.strValue);
									rule.Counter++;
								}

								if(iNumber==rule.Counter)
								{
									//取得平均值，开始比较
									iValue = Convert.ToInt32(rule.totalValue / iNumber);
									rule.Counter=0;
									rule.totalValue=0;
									bStartCheck=true;
								}
							}
							else
							{
								//不需要取平均值，直接与报警临界值比较
								double dbValue=Convert.ToDouble(logRecord.strValue);
								iValue=Convert.ToInt32(dbValue);
								bStartCheck=true;
							}

							logRecord.iStatus=-1;
							logRecord.iInterfaceAction = new int[rule.AlertRule.Length];
							logRecord.strInActionParam = new string[rule.AlertRule.Length];

							if(bStartCheck)
							{


								for(int i=0;i<rule.AlertRule.Length;i++)
								{
									if(rule.AlertRule[i].Relation==0)//等于
									{
										if(iValue==rule.AlertRule[i].CriticalValue)
										{
											if(logRecord.iStatus<rule.AlertRule[i].Level)
												logRecord.iStatus=rule.AlertRule[i].Level;
											logRecord.iInterfaceAction[i]=rule.AlertRule[i].Action;
											logRecord.strInActionParam[i]=rule.AlertRule[i].ActionParam;
										}
										else
										{
											if(logRecord.iStatus<0)
												logRecord.iStatus=0;
											logRecord.iInterfaceAction[i]=0;
											logRecord.strInActionParam[i]="";
										}
									}
									if(rule.AlertRule[i].Relation==1)//小于
									{
										if(iValue<rule.AlertRule[i].CriticalValue)
										{
											if(logRecord.iStatus<rule.AlertRule[i].Level)
												logRecord.iStatus=rule.AlertRule[i].Level;
											logRecord.iInterfaceAction[i]=rule.AlertRule[i].Action;
											logRecord.strInActionParam[i]=rule.AlertRule[i].ActionParam;
										}
										else
										{
											if(logRecord.iStatus<0)
												logRecord.iStatus=0;
											logRecord.iInterfaceAction[i]=0;
											logRecord.strInActionParam[i]="";
										}
									}
									else if(rule.AlertRule[i].Relation==2)//大于
									{
										if(iValue>rule.AlertRule[i].CriticalValue)
										{
											if(logRecord.iStatus<rule.AlertRule[i].Level)
												logRecord.iStatus=rule.AlertRule[i].Level;
											logRecord.iInterfaceAction[i]=rule.AlertRule[i].Action;
											logRecord.strInActionParam[i]=rule.AlertRule[i].ActionParam;
										}
										else
										{
											if(logRecord.iStatus<0)
												logRecord.iStatus=0;
											logRecord.iInterfaceAction[i]=0;
											logRecord.strInActionParam[i]="";
										}
									}
									else if(rule.AlertRule[i].Relation==3)//不等于
									{
										if(iValue!=rule.AlertRule[i].CriticalValue)
										{
											if(logRecord.iStatus<rule.AlertRule[i].Level)
												logRecord.iStatus=rule.AlertRule[i].Level;
											logRecord.iInterfaceAction[i]=rule.AlertRule[i].Action;
											logRecord.strInActionParam[i]=rule.AlertRule[i].ActionParam;
										}
										else
										{
											if(logRecord.iStatus<0)
												logRecord.iStatus=0;
											logRecord.iInterfaceAction[i]=0;
											logRecord.strInActionParam[i]="";
										}
									}
									else if(rule.AlertRule[i].Relation==4)//大于等于
									{
										if(iValue>=rule.AlertRule[i].CriticalValue)
										{
											if(logRecord.iStatus<rule.AlertRule[i].Level)
												logRecord.iStatus=rule.AlertRule[i].Level;
											logRecord.iInterfaceAction[i]=rule.AlertRule[i].Action;
											logRecord.strInActionParam[i]=rule.AlertRule[i].ActionParam;
										}
										else
										{
											if(logRecord.iStatus<0)
												logRecord.iStatus=0;
											logRecord.iInterfaceAction[i]=0;
											logRecord.strInActionParam[i]="";
										}
									}
									else if(rule.AlertRule[i].Relation==5)//小于等于
									{
										if(iValue<=rule.AlertRule[i].CriticalValue)
										{
											if(logRecord.iStatus<rule.AlertRule[i].Level)
												logRecord.iStatus=rule.AlertRule[i].Level;
											logRecord.iInterfaceAction[i]=rule.AlertRule[i].Action;
											logRecord.strInActionParam[i]=rule.AlertRule[i].ActionParam;
										}
										else
										{
											if(logRecord.iStatus<0)
												logRecord.iStatus=0;
											logRecord.iInterfaceAction[i]=0;
											logRecord.strInActionParam[i]="";
										}
									}
								}
							}
						
						}
					}

					//生成监控日志文件，并将相关信息插入待发送日志文件队列
					try
					{
						LogRecord logRecord1 = new LogRecord();
						logRecord1.SetLog(m_LogNameHead,logRecord.strDateTime,logRecord.iPlatformID,
							logRecord.iNodeID,logRecord.iTypeID,logRecord.iRuleID,
							logRecord.strRuleName,logRecord.strValue,logRecord.iStatus,
							logRecord.iInterfaceAction,logRecord.strInActionParam,
							logRecord.strReserve1,logRecord.strReserve2);

						//m_LogFile.InterfaceWriteToFile();
						if (LogPrintThread.m_IsUpdate)
						{
							m_UploadLogQueue.Enqueue(LogPrintThread.m_UploadFile);
							LogPrintThread.m_IsUpdate = false;
						}
					}
					catch(Exception ex)
					{
						m_SysLog.WriteToSysLog(ex.Message + ex.StackTrace);
					}




				}
				catch(Exception ex)
				{
					string msg=String.Format("logRecord分析失败：{0}",ex.Message + ex.StackTrace);
					m_SysLog.WriteToSysLog(msg);
				}
				finally
				{
					if(m_Rule!=null)
						m_Rule=null;
				}

				if(m_Exit)
				{
					break;
				}
				
								
			}			
		}

		public void Startup()
		{ 				
			m_Thread = new Thread(new ThreadStart(this.Run));
			// Start the thread
			m_Pause = false;
			m_Exit = false;		
			m_Thread.Start();			
		}
		public void Join()
		{
			if(m_Thread != null)
			{
				m_Thread.Interrupt();
				m_Thread.Join();
			}
			else
			{
				return;
			}
		}
		public bool IsAlive()
		{
			if(m_Thread != null)
			{
				return m_Thread.IsAlive;
			}
			else
			{
				return false;
			}
		}
		public void Suspend()
		{
			if(m_Pause == false)
				m_Pause = true;
		}
		public void Resume()
		{
			if(m_Pause == true)
				m_Pause = false;		
		}
		public void SetExit()
		{
			if(m_Exit == false)
				m_Exit = true;		
		}

		private void UpdateCheckRule(int PlatformID, int NodeID, string FileName)
		{
			
			try
			{
//				ArrayList m_tmpRule=new ArrayList();
//				if (m_checkRule!=null)
//				{
					
//					//清除m_tmpRule数组中规则更新前的监控规则
//					for (int i=0; i<m_checkRule.Length; i++)
//					{
//						if(m_checkRule[i].PlatformID==PlatformID && m_checkRule[i].NodeID==NodeID)
//						{
//							continue;
//						}
//						m_tmpRule.Add(m_checkRule[i]);
//					}
//
//					m_checkRule = new MonitorRule[m_tmpRule.Count];
//					m_tmpRule.CopyTo(m_checkRule);
//
//
//					/*System.Collections.IEnumerator myEnumerator = m_tmpRule.GetEnumerator();
//
//					while(myEnumerator.MoveNext())
//					{
//						MonitorRule rule = (MonitorRule)myEnumerator.Current;
//						if(rule.PlatformID==PlatformID && rule.NodeID==NodeID)
//						{
//							m_tmpRule.Remove(rule);
//						}
//					}
//
//					m_checkRule = new MonitorRule[m_tmpRule.Count];
//					myEnumerator = m_tmpRule.GetEnumerator();
//					for(int i=0;i<m_tmpRule.Count;i++)
//					{
//						myEnumerator.MoveNext();
//						m_checkRule[i] = (MonitorRule)myEnumerator.Current;
//					}*/
//
//					//添加新的监控规则到m_tmpRule数组中
					MonitorRule[] ruleList=null;
					RuleFile ruleFile = new RuleFile();
					ruleFile.ProcessXmlFile(PlatformID,NodeID,FileName,out ruleList);
				for(int i=0;i<ruleList.GetLength(0);i++)
				{
					string key = PlatformID.ToString().PadLeft(4,'0') + NodeID.ToString().PadLeft(4,'0') + ruleList[i].RuleID.ToString().PadLeft(4,'0');
					if(!m_checkRule.Contains(key))
					{
						m_checkRule.Add(key,ruleList[i]);
						
					}
					else
					{
						m_checkRule.Remove(key);
						m_checkRule.Add(key,ruleList[i]);

					}
				}
//							
//					MonitorRule[] temp = new MonitorRule[ruleList.Length+m_checkRule.Length];
//					m_checkRule.CopyTo(temp,0);
//					ruleList.CopyTo(temp,m_checkRule.Length);
//					m_checkRule = temp;
//
//				}
//				else
//				{
//					RuleFile ruleFile = new RuleFile();
//					ruleFile.ProcessXmlFile(PlatformID,NodeID,FileName,out m_checkRule);
//				}
			}
			catch(Exception ex)
			{
				m_SysLog.WriteToSysLog(ex.Message);
			}

		}

		private int GetRuleIndex(ref MonitorRule[] ruleList,int PlatformID, int NodeID, int RuleID)
		{
			if(ruleList!=null)
			{
				for(int i=0; i<ruleList.Length; i++)
				{
					if(ruleList[i].PlatformID==PlatformID && ruleList[i].NodeID==NodeID
						&& ruleList[i].RuleID==RuleID)
					{
						return i;
					}
				}
			}

			return -1;
		}
	}
}