schedulingprovider.cs

SharpNuke源代码

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

using DotNetNuke.Common.Utilities;
using DotNetNuke.Services.Scheduling;

//
// 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.Scheduling.DNNScheduling
{
	
	public class DNNScheduler : SchedulingProvider
	{
		
		private const string providerType = "schedulingprovider";
		
		public override string GetProviderPath()
		{
			return ProviderPath;
		}
		
		public override void Start ()
		{
			if (Enabled)
			{
				Scheduler.CoreScheduler coreScheduler = new Scheduler.CoreScheduler(Debug, MaxThreads);
				Scheduler.CoreScheduler.KeepRunning = true;
				Scheduler.CoreScheduler.KeepThreadAlive = true;
				Scheduler.CoreScheduler.Start();
			}
		}
		
		public override void ExecuteTasks ()
		{
			if (Enabled)
			{
				Scheduler.CoreScheduler coreScheduler = new Scheduler.CoreScheduler(Debug, MaxThreads);
				Scheduler.CoreScheduler.KeepRunning = true;
				Scheduler.CoreScheduler.KeepThreadAlive = false;
				Scheduler.CoreScheduler.Start();
			}
		}
		
		public override void ReStart (string sourceOfRestart)
		{
			Halt(sourceOfRestart);
			StartAndWaitForResponse();
		}
		
		public override void StartAndWaitForResponse ()
		{
			if (Enabled)
			{
				Thread newThread = new Thread(new ThreadStart( Start));
				newThread.IsBackground = true;
				newThread.Start();
				
				//wait for up to 30 seconds for thread
				//to start up
				for (int i = 0; i <= 30; i++)
				{
					if (GetScheduleStatus() != ScheduleStatus.STOPPED)
					{
						return;
					}
					Thread.Sleep(1000);
				}
			}
		}
		
		public override void Halt (string sourceOfHalt)
		{
			Scheduler.CoreScheduler coreScheduler = new Scheduler.CoreScheduler(Debug, MaxThreads);
			Scheduler.CoreScheduler.Halt(sourceOfHalt);
			Scheduler.CoreScheduler.KeepRunning = false;
		}
		
		public override void PurgeScheduleHistory ()
		{
			Scheduler.CoreScheduler coreScheduler = new Scheduler.CoreScheduler(MaxThreads);
			Scheduler.CoreScheduler.PurgeScheduleHistory();
		}
		
		public override void RunEventSchedule (EventName eventName)
		{
			if (Enabled)
			{
				Scheduler.CoreScheduler coreScheduler = new Scheduler.CoreScheduler(Debug, MaxThreads);
				Scheduler.CoreScheduler.RunEventSchedule(eventName);
			}
		}
		
		public override ArrayList GetSchedule()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetSchedule();
		}

		public override ArrayList GetSchedule(string server)
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetSchedule(server);
		}
		
		public override ScheduleItem GetSchedule(int scheduleID)
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetSchedule(scheduleID);
		}
		
		public override ScheduleItem GetSchedule(string typeFullName, string server)
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetSchedule(typeFullName, server);
		}
		
		public override ScheduleItem GetNextScheduledTask(string server)
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetNextScheduledTask(server);
		}
		
		public override ArrayList GetScheduleHistory(int scheduleID)
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetScheduleHistory(scheduleID);
		}
		
		public override ArrayList GetScheduleQueue()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetScheduleQueue();
		}
		
		public override ArrayList GetScheduleProcessing()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetScheduleProcessing();
		}
		
		public override ScheduleStatus GetScheduleStatus()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetScheduleStatus();
		}
		
		public override int AddSchedule(ScheduleItem scheduleItem)
		{
			Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
			
			SchedulingController schedulingController = new SchedulingController();
			int i = schedulingController.AddSchedule(scheduleItem.TypeFullName, scheduleItem.TimeLapse, 
				scheduleItem.TimeLapseMeasurement, scheduleItem.RetryTimeLapse, scheduleItem.RetryTimeLapseMeasurement, 
				scheduleItem.RetainHistoryNum, scheduleItem.AttachToEvent, scheduleItem.CatchUpEnabled, scheduleItem.Enabled, 
				scheduleItem.ObjectDependencies, scheduleItem.Servers);
			
			ScheduleHistoryItem scheduleHistoryItem = new ScheduleHistoryItem(scheduleItem);
			scheduleHistoryItem.NextStart = DateTime.Now;
			scheduleHistoryItem.ScheduleID = i;
			
			if (scheduleHistoryItem.TimeLapse != Null.NullInteger&& scheduleHistoryItem.TimeLapseMeasurement != Null.NullString && scheduleHistoryItem.Enabled)
			{
				scheduleHistoryItem.ScheduleSource = ScheduleSource.STARTED_FROM_SCHEDULE_CHANGE;
				Scheduler.CoreScheduler.AddToScheduleQueue(scheduleHistoryItem);
			}
			DataCache.RemoveCache("ScheduleLastPolled");
			return i;
			
		}
		
		public override void UpdateSchedule (ScheduleItem scheduleItem)
		{
			Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
			
			SchedulingController schedulingController = new SchedulingController();
			schedulingController.UpdateSchedule(scheduleItem.ScheduleID, scheduleItem.TypeFullName, 
				scheduleItem.TimeLapse, scheduleItem.TimeLapseMeasurement, scheduleItem.RetryTimeLapse, scheduleItem.RetryTimeLapseMeasurement, 
				scheduleItem.RetainHistoryNum, scheduleItem.AttachToEvent, scheduleItem.CatchUpEnabled, scheduleItem.Enabled, 
				scheduleItem.ObjectDependencies, scheduleItem.Servers);
			
			ScheduleHistoryItem scheduleHistoryItem = new ScheduleHistoryItem(scheduleItem);
			
			if (scheduleHistoryItem.TimeLapse != Null.NullInteger && scheduleHistoryItem.TimeLapseMeasurement != Null.NullString && scheduleHistoryItem.Enabled)
			{
				scheduleHistoryItem.ScheduleSource = ScheduleSource.STARTED_FROM_SCHEDULE_CHANGE;
				Scheduler.CoreScheduler.AddToScheduleQueue(scheduleHistoryItem);
			}
			DataCache.RemoveCache("ScheduleLastPolled");
		}
		
		public override void DeleteSchedule (ScheduleItem scheduleItem)
		{
			SchedulingController schedulingController = new SchedulingController();
			schedulingController.DeleteSchedule(scheduleItem.ScheduleID);
			Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
			DataCache.RemoveCache("ScheduleLastPolled");
		}
		
		public override Hashtable GetScheduleItemSettings(int scheduleID)
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetScheduleItemSettings(scheduleID);
		}
		
		public override int GetFreeThreadCount()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetFreeThreadCount();
		}
		
		public override int GetActiveThreadCount()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetActiveThreadCount();
		}
		
		public override int GetMaxThreadCount()
		{
			SchedulingController schedulingController = new SchedulingController();
			return schedulingController.GetMaxThreadCount();
		}
	}
	
	
}