dottext阅读之系统调度分析

    记得很早以前下载过DUDU的dottext.但当时由于看说明配置过于繁杂没弄.由于最近有一个博客系统的项目.又打开dottext研究了下,发现它里面的搜索是基于Lucene.Net.并且搜索文件的更新是增量式.因为自己在以前公司做过关于Lucene的项目.当时每次更新索引都是编写的CS结构程序重新生成,然后更新到服务器,非常麻烦.于是自己对于dottext系统中如何直接在WEB中对该模块进行调度很感兴趣.在网上搜索了下有没有前人对这一块进行过分析,发现baidu,google均只能找到很有限的资料.只好这二天空余时间就自己研究了下,在这里就我的理解分析下dottext系统中的调度模块!

     好,入正题.拿到一个系统,进行分析.先大概看一下它解决方案下的项目.该解决方案下有六个项目,基本很好理解.然后打开WEB项目下的配置文件!从中发现

<Events>
            <Event type = "Dottext.Search.SearchEngineSchedule, Dottext.Search" minutes = "1" key = "SearchEngine" />
            <Event type = "Dottext.Framework.Tracking.StatsQueueSchedule, Dottext.Framework" minutes = "5" key = "StatsQueue" />
</Events>

 有朋友可能会说,你为什么会先看到这个配置,因为很简单.我首先对他的事件调度很感兴趣,大致阅览配置文件,只有这一部分看上去非常像,另外再看到Event type就是在Dottext.Search项目下.可以确定搜索的索引文件生成.就是靠这个事件.

这里的Events并不是web.config本身的属性,往上看会发现这里的Events配置节点处于BlogConfigurationSettings配置节点下.这是一个自定义的配置节.到上面去找他的处理器

<configSections>
    <!--声明了自定义配置节处理程序-->
        <section name="BlogConfigurationSettings" type="Dottext.Framework.Util.XmlSerializerSectionHandler, Dottext.Framework" />
        <section name="HandlerConfiguration" type="Dottext.Framework.Util.XmlSerializerSectionHandler, Dottext.Framework" />
        <section name="SearchConfiguration" type="Dottext.Framework.Util.XmlSerializerSectionHandler, Dottext.Framework" />
        <section name="microsoft.web.services" type="Microsoft.Web.Services.Configuration.WebServicesConfiguration, Microsoft.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        <section name="codeHighlighter" type="ActiproSoftware.CodeHighlighter.CodeHighlighterConfigurationSectionHandler, ActiproSoftware.CodeHighlighter" />
    </configSections>

发现BlogConfigurationSettings配置节是由自己写的Dottext.Framework.Util.XmlSerializerSectionHandler处理.这里有兴趣可以进去看看.

//自定义的配置节处理器必须实现IConfigurationSectionHandler接口
    public class XmlSerializerSectionHandler : IConfigurationSectionHandler 
    {
        public object Create(object parent, object configContext, System.Xml.XmlNode section) 
        {
            XPathNavigator nav = section.CreateNavigator();
            string typename = (string) nav.Evaluate("string(@type)");//是从当前XML（配置文件是一个符合xml要求的文档）节点处，获取”type”属性
            Type t = Type.GetType(typename);//然后按照属性描述，获得一个.net的类型
            /*这种生成类的方法是区别于new 方法生成具体类的另外途径，好处就是灵活根据具
             * 体环境内容（甚至是用户交互输入的类型描述字符串）就可以生成获得托管类型。（此处反射细节请参考MSDN）。
             * 坏处就是可能隐藏着类型错误，运行时出错，导致不可预料（好像这个词在windows编程时代相当的常见）例外甚至系统崩溃。
             */ 

            //当然，上面仅仅创建了类型是不够用的，还需要通过一定途径来确定生成类的具体状态，
            //这有用到OOP语言的重要特性—序列化，将一个对象存储器来，以及从存储中还原具体对象的机制。

            //这里使用的是System提供的 XmlSerializer 类的反序列化方法Deserialize。反序列化后面还有很多
            //代码涉及到，我认为现在就大致理解为“通过这个反序列化，我们刚刚得到的类实例中的属性、成员变
            //量获得了赋值，进入到某个状态，就好像我们此处运行了new 语法和进行了对象的构造以及赋值”即可。更进一步的可以从权威资料MSDN获取。

            XmlSerializer ser = new XmlSerializer(t);
            return ser.Deserialize(new XmlNodeReader(section));
        }

上面为方便一些朋友理解,我加上了注释!它的作用是将类的实例属性持久化到web.config.当程序运行时再从web.config文件取出属性还原类实例!当然,也方便修改!而外部调用是直接用系统提供的方法获取.如下

//.NET1.1方式
BlogConfigurationSettings bs = (BlogConfigurationSettings)System.Configuration.ConfigurationSettings.GetConfig("BlogConfigurationSettings");
//.NET2.0方式
BlogConfigurationSettings bs = (BlogConfigurationSettings)System.Configuration.ConfigurationManager.GetSection("BlogConfigurationSettings");

这样就可以从配置文件中获取到一个BlogConfigurationSettings实例!他的属性值均来自配置文件!这就是通常所说的序列化.给开发可以带来很大便利!但使用者也要清楚.序列化和反序列化是比较耗性能的!所以在使用时应该注意代码书写方式.否则用的不当将带来性能问题!
     好了,我们现在去看Dottext.Search.SearchEngineSchedule.cs这个感兴趣的类文件

public class SearchEngineSchedule : Dottext.Framework.ScheduledEvents.IEvent
    {
        public SearchEngineSchedule()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        #region IEvent Members

        public void Execute(object state)
        {
            Log log = new Log();
            log.Title = "Search Index";
            log.Message = string.Format("Daily ({0}) Build",log.StartDate.ToShortDateString());

            IndexManager.RebuildSafeIndex(30);

            log.EndDate = DateTime.Now;
            
            LogManager.Create(log);
            
        }

        #endregion
    }

我们发现这个类实现了Dottext.Framework.ScheduledEvents.IEvent这样一个接口.而其中只有一个Execute方法.我们初步猜这个方法就是具体调度要执行的任务代码.它里面有一些日志的记录以及具体的更新索引文件!我们先不关心该方法的体.现在想知道他如何实现调度的!去看看IEvent接口!

namespace Dottext.Framework.ScheduledEvents
{
    /// <summary>
    /// Interface for defining an event.
    /// </summary>
    public interface IEvent
    {
        void Execute(object state);
    }
}

这个接口很简单,就定义了一个Execute方法!再看看他同命名空间下有哪些其他文件!
1.Event.cs 事件实体 它里面主要定义事件的一些属性,如是否应该执行,最后执行时间,对应的执行方法的类等等.

using System;
using System.Xml.Serialization;
using Dottext.Framework.Providers;

namespace Dottext.Framework.ScheduledEvents
{
    /**//// <summary>
    /// Event is the configuration of an IEvent. 
    /// </summary>
    [Serializable]
    public class Event
    {
        public Event()
        {

        }

        private IEvent _ievent =null;

        /**//// <summary>
        /// The current implementation of IEvent
        /// </summary>
        [XmlIgnoreAttribute]
        public IEvent IEventInstance
        {
            get
            {
                LoadIEvent();
                return _ievent;
            }
        }

        /**//// <summary>
        /// Private method for loading an instance of IEvent
        /// </summary>
        private void LoadIEvent()
        {
            if(_ievent == null)
            {
                if(this.ScheduleType == null)
                {
                    throw new BlogProviderException("A Scheduled Event (IEvent) does not have its type property defined");
                }
                _ievent = (IEvent)Activator.CreateInstance(Type.GetType(this.ScheduleType));
                if(_ievent == null)
                {
                    throw new BlogProviderException(string.Format("The Scheduled Event {0} could not be loaded",this.ScheduleType));
                }
            }
        }

        private string _key;
        
        /**//// <summary>
        /// A unique key used to query the database. The name of the Server will also be used to ensure the "Key" is 
        /// unique in a cluster
        /// </summary>
        [XmlAttribute("key")]
        public string Key
        {
            get {return this._key;}
            set {this._key = value;}
        }

        private int _timeOfDay =-1;
        
        /**//// <summary>
        /// Absolute time in mintues from midnight. Can be used to assure event is only 
        /// executed once per-day and as close to the specified
        /// time as possible. Example times: 0 = midnight, 27 = 12:27 am, 720 = Noon
        /// </summary>
        [XmlAttribute("timeOfDay")]
        public int TimeOfDay
        {
            get {return this._timeOfDay;}
            set {this._timeOfDay = value;}
        }

        private int _minutes = 60;
        
        /**//// <summary>
        /// The scheduled event interval time in minutes. If TimeOfDay has a value >= 0, Minutes will be ignored. 
        /// This values should not be less than the Timer interval.
        /// </summary>
        [XmlAttribute("minutes")]
        public int Minutes
        {
            get 
            {
                if(this._minutes < EventManager.TimerMinutesInterval)
                {
                    return EventManager.TimerMinutesInterval;
                }
                return this._minutes;
            }
            set {this._minutes = value;    }
        }

        private string _scheduleType;
        
        /**//// <summary>
        /// The Type of class which implements IEvent
        /// </summary>
        [XmlAttribute("type")]
        public string ScheduleType
        {
            get {return this._scheduleType;}
            set {this._scheduleType = value;}
        }

        private DateTime _lastCompleted;
        
        /**//// <summary>
        /// Last Date and Time this event was processed/completed.
        /// </summary>
        [XmlIgnoreAttribute]
        public DateTime LastCompleted
        {
            get {return this._lastCompleted;}
            set 
            {
                dateWasSet = true;
                this._lastCompleted = value;
            }
        }

        //internal testing variable
        bool dateWasSet = false;

        [XmlIgnoreAttribute]
        public bool ShouldExecute
        {
            get
            {
                if(!dateWasSet) //if the date was not set (and it can not be configured), check the data store
                {
                    LastCompleted = DTOProvider.Instance().GetLastExecuteScheduledEventDateTime(this.Key,Environment.MachineName);
                }

                //If we have a TimeOfDay value, use it and ignore the Minutes interval
                if(this.TimeOfDay > -1)
                {
                    //Now
                    DateTime dtNow = DateTime.Now;  //now
                    //We are looking for the current day @ 12:00 am
                    DateTime dtCompare = new DateTime(dtNow.Year,dtNow.Month,dtNow.Day);
                    //Check to see if the LastCompleted date is less than the 12:00 am + TimeOfDay minutes
                    return LastCompleted < dtCompare.AddMinutes(this.TimeOfDay);
                    
                }
                else
                {
                    //Is the LastCompleted date + the Minutes interval less than now?
                    return LastCompleted.AddMinutes(this.Minutes) < DateTime.Now;
                }
            }
        }

        /**//// <summary>
        /// Call this method BEFORE processing the ScheduledEvent. This will help protect against long running events 
        /// being fired multiple times. Note, it is not absolute protection. App restarts will cause events to look like
        /// they were completed, even if they were not. Again, ScheduledEvents are helpfulbut not 100% reliable
        /// </summary>
        public void UpdateTime()
        {
            this.LastCompleted = DateTime.Now;
            DTOProvider.Instance().SetLastExecuteScheduledEventDateTime(this.Key,Environment.MachineName,this.LastCompleted);
        }
    }
}

2.EventHttpModule.cs

public class EventHttpModule : System.Web.IHttpModule
    {
        static Timer eventTimer;//这里很重要

        public EventHttpModule()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        #region IHttpModule Members

        //Init方法是实现了IHttpModule中的方法,它在应用程序接受到请求时就会执行
        public void Init(System.Web.HttpApplication application)
        {
            if (eventTimer == null)
            {
                /* 这里是关键 用了一个Timer来实现定时执行任务 初始访问 1分钟后 会调用ScheduledEventWorkCallback
                 * 方法.之后 每EventManager.TimerMinutesInterval分钟执行一次.具体看配置
                 * 这里有几点需要注意 eventTimer 变量不能定义在本方法内部,一定要是一个类中的静态变量
                 * 否则,当线程执行完本方法后,.NET GC垃圾回收机制,会随时将它回收,达不到应用效果.
                 * 将eventTimer定义为静态的并且在这里有一个引用.这样可以保证它一直是活动的
                 * 当然有情况会断掉,一是IIS服务器关闭了,二是IIS进程回收也会停止
                 */                
                eventTimer = new Timer(new TimerCallback(ScheduledEventWorkCallback), application.Context, 60000, EventManager.TimerMinutesInterval * 60000);
            }
        }

        private void ScheduledEventWorkCallback(object sender)
        {
            try
            {                
                EventManager.Execute();
            }
            catch(Exception ex)
            {
                LogManager.CreateExceptionLog(ex,"Failed ScheduledEventCallBack");
            }

        }

        public void Dispose()
        {
            eventTimer = null;
        }

        #endregion
    }

上面我注释的比较详细.ScheduledEventWorkCallback方法主要调用了EventManager.Execute()方法来执行任务.具体的什么任务在EventHttpModule不关心.这也不属于它的职责!另外需要本类正常运行是需要在web.config中配置一下httpModules

<httpModules>
            <add name="UrlReWriteModule" type="Dottext.Common.UrlManager.UrlReWriteModule, Dottext.Common" />
            <add name="EventHttpModule" type="Dottext.Framework.ScheduledEvents.EventHttpModule, Dottext.Framework" />
            <!--<add name="MsftBlogsHttpModule" type= "AspNetWeb.MsftBlogsHttpModule, MsftBlogsHttpModule" />-->
        </httpModules>

上面的EventHttpModule是配置本类的!这样在系统接受到请求时会进过EventHttpModule.在里面触发timer.以后就会定期的执行!
3.EventManager.cs

/// <summary>
    /// EventManager is called from the EventHttpModule (or another means of scheduling a Timer). Its sole purpose
    /// is to iterate over an array of Events and deterimine of the Event's IEvent should be processed. All events are
    /// added to the managed threadpool.
    /// 它是任务的管理器,负责取出并调用线程池中线程来执行这些任务 
    /// </summary>
    public class EventManager
    {
        private EventManager()
        {
        }

        public static readonly int TimerMinutesInterval = 5;


        public static void Execute()
        {
            //第一步 取出所有需要执行的任务
            Event[] items = Config.Settings.ScheduledItems;//这里系统是从配置文件中读取到所有的Events子节点Event
            Event item = null;
            
            //第二步 将这些任务一个个放入线程池队列中等待执行
            if(items != null)
            {                
                for(int i = 0; i<items.Length; i++)
                {
                    item = items[i];
                    if(item.ShouldExecute)
                    {
                        item.UpdateTime();
                        IEvent e = item.IEventInstance;//接口编程,将实例转成IEvent接口
                        //将任务放入线程池队列中等待执行 接口IEvent的Execute方法
                        ManagedThreadPool.QueueUserWorkItem(new WaitCallback(e.Execute));
                    }
                }
            }
        }
    }

EventManager的现职很明确并单一.就是负责调出任务并放入线程池等待执行!
关于ManagedThreadPool.cs 线程池的管理器!下一篇文章再写