filebasedcachingprovider.cs

SharpNuke源代码

using System;
using System.Data;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Threading;
using System.Web;
using System.Web.Caching;
using System.Xml.Serialization;

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

//
// 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.Cache.FileBasedCachingProvider
{
	
	public class FBCachingProvider : CachingProvider
	{
		
		private const string providerType = "caching";
		private ProviderConfiguration providerConfiguration;
		
		internal static string cachingDirectory = Globals.HostMapPath + "Cache\\";
		internal const string cacheFileExtension = ".resources";
		private static System.Web.Caching.Cache cache;
		
		public FBCachingProvider()
		{
			providerConfiguration = ProviderConfiguration.GetProviderConfiguration(providerType);
		}

		private static System.Web.Caching.Cache Cache
		{
			get {
				//create singleton of the cache object
				if (cache == null)
				{
					cache = HttpRuntime.Cache;
				}
				return cache;
			}
		}
		
		#region "Abstract Method Implementation"
		public override object Add(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, 
			CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback)
		{
			return Cache.Add(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemoveCallback);
		}
		
		public override IDictionaryEnumerator GetEnumerator()
		{
			return Cache.GetEnumerator();
		}
		
		public override object GetItem(string cacheKey)
		{
			return Cache[cacheKey];
		}
		
		public override object GetPersistentCacheItem(string cacheKey, Type type)
		{
			object obj = Cache[cacheKey];
			if (obj != null)
			{
				return obj;
			}
			else if (DataCache.CachePersistenceEnabled)
			{
				Stream stream;
				string file = GetFileName(cacheKey);
				if (File.Exists(file))
				{
					stream = File.OpenRead(file);
					
					XmlSerializer serializer = new XmlSerializer(type);
					TextReader textReader = new StreamReader(stream);
					obj = serializer.Deserialize(textReader);
					textReader.Close();
					Insert(cacheKey, obj, true);
				}
			}
			return obj;
		}
		
		public override void Insert (string cacheKey, object o, bool persistAppRestart)
		{
			if (persistAppRestart)
			{
				//remove the cache key which
				//will remove the serialized
				//file before creating a new one
				Remove(cacheKey);
			}
			
			string file = GetFileName(cacheKey);
			System.Web.Caching.CacheDependency dependency = new CacheDependency(file);
			
			if (persistAppRestart && DataCache.CachePersistenceEnabled)
			{
				CreateCacheFile(file, o);
			}
			else if (Globals.WebFarmEnabled)
			{
				CreateCacheFile(file);
			}
			else
			{
				dependency = null;
			}
			
			Cache.Insert(cacheKey, o, dependency);
		}
		
		public override void Insert (string cacheKey, object o, CacheDependency dependency, bool persistAppRestart)
		{
			if (persistAppRestart)
			{
				//remove the cache key which
				//will remove the serialized
				//file before creating a new one
				Remove(cacheKey);
			}
			
			string[] files = new string[1];
			files[0] = GetFileName(cacheKey);
			
			CacheDependency fileDependency = new CacheDependency(files, null, dependency);
			if (persistAppRestart && DataCache.CachePersistenceEnabled)
			{
				CreateCacheFile(files[0], o);
			}
			else if (Globals.WebFarmEnabled)
			{
				CreateCacheFile(files[0]);	
			}
			else
			{
				fileDependency = dependency;
			}
			
			Cache.Insert(cacheKey, o, fileDependency);
			
		}
		
		public override void Insert (string cacheKey, object o, CacheDependency dependency, DateTime absoluteExpiration, TimeSpan slidingExpiration, bool persistAppRestart)
		{
			if (persistAppRestart)
			{
				//remove the cache key which
				//will remove the serialized
				//file before creating a new one
				Remove(cacheKey);
			}
			
			string[] files = new string[1];
			files[0] = GetFileName(cacheKey);
			
			CacheDependency fileDependency = new CacheDependency(files, null, dependency);
			if (persistAppRestart && DataCache.CachePersistenceEnabled)
			{
				CreateCacheFile(files[0], o);
			}
			else if (Globals.WebFarmEnabled)
			{
				CreateCacheFile(files[0]);
			}
			else
			{
				fileDependency = dependency;
			}
			
			Cache.Insert(cacheKey, o, fileDependency, absoluteExpiration, slidingExpiration);
		}
		
		public override void Insert (string cacheKey, object o, CacheDependency dependency, DateTime absoluteExpiration, TimeSpan slidingExpiration, 
			CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback, bool persistAppRestart)
		{
			if (persistAppRestart)
			{
				//remove the cache key which
				//will remove the serialized
				//file before creating a new one
				Remove(cacheKey);
			}
			
			string[] files = new string[1];
			files[0] = GetFileName(cacheKey);
			
			CacheDependency fileDependency = new CacheDependency(files, null, dependency);
			if (persistAppRestart && DataCache.CachePersistenceEnabled)
			{
				CreateCacheFile(files[0], o);
			}
			else if (Globals.WebFarmEnabled)
			{
				CreateCacheFile(files[0]);
			}
			else
			{
				fileDependency = dependency;
			}
			
			Cache.Insert(cacheKey, o, fileDependency, absoluteExpiration, slidingExpiration, priority, onRemoveCallback);
			
		}
		
		public override object Remove(string cacheKey)
		{
			object o = cache.Remove(cacheKey);
			if ( o != null)
			{
				string file = GetFileName(cacheKey);
				if (Globals.WebFarmEnabled)
				{
					DeleteCacheFile(file);
				}
			}
			return o;
		}
		
		public override void RemovePersistentCacheItem (string cacheKey)
		{
			if (Cache.Remove(cacheKey) != null)
			{
				if (DataCache.CachePersistenceEnabled)
				{
					string file = GetFileName(cacheKey);
					DeleteCacheFile(file);
				}
			}
			
		}
		
		public override string PurgeCache()
		{
			string[] files;
			files = Directory.GetFiles(cachingDirectory);
			int totalFiles = files.Length;
			int purgedFiles;
			purgedFiles = PurgeCacheFiles(files);
			return string.Format("Purged {0} of {1} cache synchronization files.", purgedFiles.ToString(), totalFiles.ToString());
		}
		
		private int PurgeCacheFiles(string[] files)
		{
			int purgedFiles = 0;
			foreach (string file in files)
			{
				DateTime lastWrite;
				lastWrite = File.GetLastWriteTime(file);
				if (lastWrite < DateTime.Now.Subtract(new TimeSpan(2, 0, 0)))
				{
					string fileName;
					fileName = Path.GetFileName(file);
					string cacheKey;
					cacheKey = fileName.Substring(0, fileName.Length - cacheFileExtension.Length);
					if (DataCache.GetCache(cacheKey) == null)
					{
						File.Delete(file);
						purgedFiles ++;
					}
				}
			}
			return purgedFiles;
		}
		
		#endregion
		
		#region "Private Methods"
		
		private static string GetFileName(string fileName)
		{
			byte[] fileNameBytes = System.Text.Encoding.ASCII.GetBytes(fileName);
			string finalFileName = Convert.ToBase64String(fileNameBytes);
			if (finalFileName.IndexOf("/") > - 1)
			{
				finalFileName = finalFileName.Replace("/", "-");
			}
			return cachingDirectory + finalFileName + cacheFileExtension;
		}

		private static void CreateCacheFile (string fileName)
		{
			StreamWriter streamWriter;
			if (! File.Exists(fileName))
			{
				streamWriter = File.CreateText(fileName);
				if (streamWriter != null)
				{
					streamWriter.Close();
				}
			}
		}
		
		private static void CreateCacheFile (string fileName, object o)
		{
			string objectString = XmlUtils.Serialize(o);
			
			StreamWriter streamWriter;
			if (! File.Exists(fileName))
			{
				streamWriter = File.CreateText(fileName);
				streamWriter.Write(objectString);
				if (streamWriter != null)
				{
					streamWriter.Close();
				}
			}
		}
		
		private static void DeleteCacheFile (string fileName)
		{
			if (File.Exists(fileName))
			{
				File.Delete(fileName);
			}
		}
		
		#endregion
		
	}
	
}