xmlloggingprovider.cs

SharpNuke源代码

using System;
using System.Data;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Security.Permissions;
using System.Threading;
using System.Web;
using System.Xml;
using System.Xml.Xsl;
using System.Xml.Serialization;

using DotNetNuke.Common;
using DotNetNuke.Common.Utilities;
using DotNetNuke.Framework.Providers;

//
// DotNetNuke -  http://www.dotnetnuke.com
// Copyright (c) 2002-2005
// by Shaun Walker ( [e-mail] ) of Perpetual Motion Interactive Systems Inc. ( http://www.perpetualmotion.ca )
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
// to permit persons to whom the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial portions
// of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//


namespace DotNetNuke.Services.Log.EventLog
{
	
	public class XMLLoggingProvider : LoggingProvider
	{
		private const string providerType = "logging";
		private ProviderConfiguration providerConfiguration;
		
		private static ReaderWriterLock lockLog = new ReaderWriterLock();
		private static ReaderWriterLock lockNotif = new ReaderWriterLock();
		private static ReaderWriterLock lockPurgeLog = new ReaderWriterLock();
		private const int readerLockTimeout = 10000; //milliseconds
		private const int writerLockTimeout = 10000; //milliseconds
		
		private const string pendingNotificationsFile = "PendingLogNotifications.xml.resources";
		private static XmlDocument xmlConfigDoc;
		private static ArrayList logQueue = new ArrayList();
		
		public XMLLoggingProvider() 
		{
			providerConfiguration = ProviderConfiguration.GetProviderConfiguration(providerType);
			
			if (xmlConfigDoc == null)
			{
				xmlConfigDoc = GetConfigDoc();
			}
		}
		
		public static ArrayList LogQueue
		{
			get { return logQueue; }
		}

		#region "Abstract Method Implementation"
		
		//--------------------------------------------------------------
		//Method to add a log entry
		//--------------------------------------------------------------
		public override void AddLog (LogInfo logInfo)
		{
			string configPortalID;
			if (logInfo.LogPortalID != Null.NullInteger)
			{
				configPortalID = logInfo.LogPortalID.ToString();
			}
			else
			{
				configPortalID = "*";
			}
			
			LogTypeConfigInfo logTypeConfigInfo;
			logTypeConfigInfo = GetLogTypeConfig(configPortalID, logInfo.LogTypeKey);
			if (logTypeConfigInfo != null && logTypeConfigInfo.LoggingIsActive)
			{
				string logString;
				logInfo.LogFileID = logTypeConfigInfo.ID;
				logInfo.LogCreateDateNum = DateToNum(logInfo.LogCreateDate);
				logString = XmlUtils.Serialize(logInfo);
				LogQueueItem logQueueItem = new LogQueueItem();
				logQueueItem.LogString = logString;
				logQueueItem.LogTypeConfigInfo = logTypeConfigInfo;
				
				bool useEventLogBuffer = true;
				if (Globals.HostSettings.ContainsKey("EventLogBuffer"))
				{
					if (Convert.ToString(Globals.HostSettings["EventLogBuffer"]) != "Y")
					{
						useEventLogBuffer = false;
					}
				}
				else
				{
					useEventLogBuffer = false;
				}
				
				Scheduling.SchedulingProvider scheduler = Scheduling.SchedulingProvider.Instance();
				if (logInfo.BypassBuffering || Scheduling.SchedulingProvider.Enabled || scheduler.GetScheduleStatus() == Scheduling.ScheduleStatus.STOPPED || !useEventLogBuffer)
				{
					WriteLog(logQueueItem);
				}
				else
				{
					LogQueue.Add(logQueueItem);
				}
			}
		}
		
		//--------------------------------------------------------------
		//Method to add Log Type Configuration
		//--------------------------------------------------------------
		public override void AddLogTypeConfigInfo (string id, bool isActive, string logTypeKey, string logTypePortalID, 
			string keepMostRecent, string logFileName, bool emailNotificationIsActive, string notificationThreshold, 
			string notificationThresholdTime, string notificationThresholdTimeType, string mailFromAddress, string mailToAddress)
		{
			XmlDocument xmlDoc = GetConfigDoc();
			XmlNode xmlNode;
			xmlNode = xmlDoc.ImportNode(GetXMLFromLogTypeConfigInfo(id, isActive, logTypeKey, logTypePortalID, 
				keepMostRecent, logFileName, emailNotificationIsActive, notificationThreshold, notificationThresholdTime, 
				notificationThresholdTimeType, mailFromAddress, mailToAddress), true);
			xmlDoc.DocumentElement.AppendChild(xmlNode);
			xmlDoc.Save(GetConfigDocFileName());
			DataCache.RemoveCache("LoggingGetConfigDoc");
			xmlConfigDoc = GetConfigDoc();
		}
		
		public override void AddLogType (string logTypeKey, string logTypeFriendlyName, string logTypeDescription, string logTypeCSSClass, string logTypeOwner)
		{
			XmlDocument xmlDoc = GetConfigDoc();
			XmlNode xmlNode;
			xmlNode = xmlDoc.ImportNode(GetXMLFromLogTypeInfo(logTypeKey, logTypeFriendlyName, logTypeDescription, logTypeCSSClass, logTypeOwner), true);
			xmlDoc.DocumentElement.AppendChild(xmlNode);
			xmlDoc.Save(GetConfigDocFileName());
			DataCache.RemoveCache("LoggingGetConfigDoc");
			xmlConfigDoc = GetConfigDoc();
		}
		
		public override void UpdateLogType (string logTypeKey, string logTypeFriendlyName, string logTypeDescription, string logTypeCSSClass, string logTypeOwner)
		{
			DeleteLogType(logTypeKey);
			AddLogType(logTypeKey, logTypeFriendlyName, logTypeDescription, logTypeCSSClass, logTypeOwner);
		}
		
		//--------------------------------------------------------------
		//Method to delete the log files
		//--------------------------------------------------------------
		public override void ClearLog ()
		{
			XmlDocument xmlConfigDoc = GetConfigDoc();
			
			ArrayList arrayList;
			arrayList = GetLogFiles(xmlConfigDoc, "*", "*");
			
			foreach (string file in arrayList)
			{
				File.Delete(file);
			}
		}
		
		//--------------------------------------------------------------
		//Method to delete a log entry
		//--------------------------------------------------------------
		public override void DeleteLog (LogInfo logInfo)
		{
			XmlDocument xmlConfigDoc = GetConfigDoc();
			
			string fileName = GetLogFileByLogFileID(GetConfigDoc(), logInfo.LogFileID);
			
			XmlDocument xmlDoc = new XmlDocument();
			int intAttempts = 0;
			//wait for up to 100 milliseconds for the file
			//to be unlocked if it is not available
			while (xmlDoc.OuterXml == "" && intAttempts < 100)
			{
				intAttempts ++;
				try
				{
					xmlDoc.Load(fileName);
				}
				catch (IOException)
				{
					Thread.SpinWait(1);
				}
			}
			
			XmlNode xmlNode;
			xmlNode = xmlDoc.SelectSingleNode("/logs/log[@LogGUID=\'" + logInfo.LogGUID + "\']");
			if (xmlNode != null)
			{
				xmlDoc.DocumentElement.RemoveChild(xmlNode);
			}
			xmlDoc.Save(fileName);
		}
		
		//--------------------------------------------------------------
		//Method to delete Log Type Configuration
		//--------------------------------------------------------------
		public override void DeleteLogTypeConfigInfo (string id)
		{
			XmlDocument xmlDoc = GetConfigDoc();
			XmlNode xmlNode = xmlDoc.DocumentElement.SelectSingleNode("LogTypeConfig[@LogFileID=\'" + id + "\']");
			if (xmlNode != null)
			{
				xmlDoc.DocumentElement.RemoveChild(xmlNode);
				xmlDoc.Save(GetConfigDocFileName());
			}
			DataCache.RemoveCache("LoggingGetConfigDoc");
			xmlConfigDoc = GetConfigDoc();
		}
		
		public override void DeleteLogType (string logTypeKey)
		{
			XmlDocument xmlDoc = GetConfigDoc();
			XmlNode xmlNode = xmlDoc.DocumentElement.SelectSingleNode("LogTypes/LogType[@LogTypeKey=\'" + logTypeKey + "\']");
			if (xmlNode != null)
			{
				xmlDoc.DocumentElement.RemoveChild(xmlNode);
				xmlDoc.Save(GetConfigDocFileName());
			}
			DataCache.RemoveCache("LoggingGetConfigDoc");
			xmlConfigDoc = GetConfigDoc();
		}
		
		//--------------------------------------------------------------
		//Method to get all log entries for all portals & log types
		//--------------------------------------------------------------
		public override LogInfoArray GetLog()
		{
			int totalRecords = 0;
			return GetLogFromXPath("logs/log", "*", "*", int.MaxValue, 1, ref totalRecords);
		}
		
		//--------------------------------------------------------------
		//Method to get all log entries for specified portal & all log types
		//--------------------------------------------------------------
		public override LogInfoArray GetLog(int portalID)
		{
			int totalRecords = 0;
			if (portalID == - 1)
			{
				return GetLog();
			}
			else
			{
				return GetLogFromXPath("logs/log[@LogPortalID=\'" + portalID.ToString() + "\']", portalID.ToString(), "*", int.MaxValue, 1, ref totalRecords);
			}
		}
		
		//--------------------------------------------------------------
		//Method to get all log entries for all portals & specified log type
		//--------------------------------------------------------------
		public override LogInfoArray GetLog(string logType)
		{
			int totalRecords = 0;
			return GetLogFromXPath("logs/log[@LogTypeKey=\'" + logType + "\']", "*", logType, int.MaxValue, 1, ref totalRecords);
		}
		
		//--------------------------------------------------------------
		//Method to get all log entries for specified portal & log type
		//--------------------------------------------------------------	
		public override LogInfoArray GetLog(int portalID, string logTypeKey)
		{
			int totalRecords = 0;
			if (portalID == - 1)
			{
				return GetLog(logTypeKey, int.MaxValue, 1, ref totalRecords);
			}
			else
			{
				return GetLogFromXPath("logs/log[@LogPortalID=\'" + portalID.ToString() + 
					"\' and @LogTypeKey=\'" + logTypeKey + "\']", portalID.ToString(), logTypeKey, int.MaxValue, 1, ref totalRecords);
			}
		}
		
		public override LogInfoArray GetLog(int pageSize, int pageIndex, ref int totalRecords)
		{
			return GetLogFromXPath("logs/log", "*", "*", pageSize, pageIndex, ref totalRecords);
		}

		//--------------------------------------------------------------
		//Method to get all log entries for specified portal & all log types
		//--------------------------------------------------------------
		public override LogInfoArray GetLog(int portalID, int pageSize, int pageIndex, ref int totalRecords)
		{
			if (portalID == -1)
			{
				return GetLog();
			}				
			else
			{
				return GetLogFromXPath("logs/log[@LogPortalID='" + portalID.ToString() + "']", portalID.ToString(), "*", pageSize, pageIndex, ref totalRecords);
			}
		}

		//--------------------------------------------------------------
		//Method to get all log entries for all portals & specified log type
		//--------------------------------------------------------------
		public override LogInfoArray GetLog(string logType, int pageSize, int pageIndex, ref int totalRecords)
		{
			return GetLogFromXPath("logs/log[@LogTypeKey='" + logType + "']", "*", logType, pageSize, pageIndex, ref totalRecords);
		}

		//--------------------------------------------------------------
		//Method to get all log entries for specified portal & log type
		//--------------------------------------------------------------
		public override LogInfoArray GetLog(int portalID, string logTypeKey, int pageSize, int pageIndex, ref int totalRecords)
		{
			if (portalID == -1)
			{
				return GetLog(logTypeKey, pageSize, pageIndex, ref totalRecords);
			}
			else
			{
				return GetLogFromXPath("logs/log[@LogPortalID='" + portalID.ToString() + "' and @LogTypeKey='" + logTypeKey + "']", portalID.ToString(), logTypeKey, pageSize, pageIndex, ref totalRecords);
			}
		}

		//--------------------------------------------------------------
		//Method to get Log Type Configuration
		//--------------------------------------------------------------
		public override ArrayList GetLogTypeConfigInfo()
		{
			XmlDocument xmlConfigDoc = GetConfigDoc();
			
			XmlNodeList xmlLogTypeConfigInfoList;
			xmlLogTypeConfigInfoList = xmlConfigDoc.SelectNodes("/LogConfig/LogTypeConfig ");
			
			ArrayList arrLogTypeInfo = new ArrayList();
			
			foreach (XmlNode xmlLogTypeConfigInfo in xmlLogTypeConfigInfoList)
			{
				arrLogTypeInfo.Add(GetLogTypeConfigInfoFromXML(xmlLogTypeConfigInfo));
			}
			return arrLogTypeInfo;
		}
		
		//--------------------------------------------------------------
		//Method to get Log Type Configuration by ID
		//--------------------------------------------------------------
		public override LogTypeConfigInfo GetLogTypeConfigInfoByID(string id)
		{
			XmlDocument xmlConfigDoc = GetConfigDoc();
			
			XmlNode xmlLogTypeConfigInfo;
			xmlLogTypeConfigInfo = xmlConfigDoc.SelectSingleNode("/LogConfig/LogTypeConfig[@LogFileID=\'" + id + "\']");
			
			return GetLogTypeConfigInfoFromXML(xmlLogTypeConfigInfo);
		}
		
		//--------------------------------------------------------------
		//Methods to get the log configuration info
		//--------------------------------------------------------------
		public override ArrayList GetLogTypeInfo()
		{
			XmlDocument xmlConfigDoc = GetConfigDoc();
			
			XmlNodeList xmlLogTypeInfoList;
			xmlLogTypeInfoList = xmlConfigDoc.SelectNodes("/LogConfig/LogTypes/LogType");
			
			ArrayList arrLogTypeInfo = new ArrayList();
			
			foreach (XmlNode xmlLogTypeInfo in xmlLogTypeInfoList)
			{
				arrLogTypeInfo.Add(GetLogTypeInfoFromXML(xmlLogTypeInfo));
			}
			return arrLogTypeInfo;
		}
		
		public override object GetSingleLog(LogInfo logInfo, ReturnType returnType)
		{
			XmlDocument xmlConfigDoc = GetConfigDoc();
			
			string fileName = GetLogFileByLogFileID(GetConfigDoc(), logInfo.LogFileID);
			
			XmlDocument xmlDoc = new XmlDocument();
			int intAttempts = 0;
			//wait for up to 100 milliseconds for the file
			//to be unlocked if it is not available
			while (xmlDoc.OuterXml == "" && intAttempts < 100)
			{
				intAttempts ++;
				try
				{
					xmlDoc.Load(fileName);
				}
				catch (IOException)
				{
					Thread.SpinWait(1);