Changeset 2487

Timestamp:

3/13/2012 11:37:30 PM (15 months ago)

Author:

lowjoel

Message:

• Move the task execution machinery to the Task object, so that Tasks can execute independently of an Executor. The Executor instance now just manages task lists and schedules when tasks are supposed to run.
• Report progress updates by pushing information to the SteppedProgressManager? instance associated with each erasure target. Furthermore, do not manipulate the state of the Task object, instead, let the Task object manage its own Progress state.

Location:

branches/eraser6/pluginsRewrite

Files:

• Eraser.Manager/DirectExecutor.cs (modified) (2 diffs)
• Eraser.Manager/Task.cs (modified) (6 diffs)
• Eraser.Plugins/ProgressManager.cs (modified) (16 diffs)

branches/eraser6/pluginsRewrite/Eraser.Manager/DirectExecutor.cs

@@ -254 +254 @@
                 if (task != null)
                 {
+                    LogSink sessionLog = new LogSink();
+                    task.Log.Add(sessionLog);
+
                     //Start a new log session to separate this session's events
                     //from previous ones.
-                    LogSink sessionLog = new LogSink();
-                    task.Log.Add(sessionLog);
-                    using (new LogSession(sessionLog))
+                    try
                     {
-                        ExecuteTask(task);
+                        using (new LogSession(sessionLog))
+                        {
+                            //Set the currently executing task.
+                            currentTask = task;
+
+                            //Prevent the system from sleeping.
+                            Power.ExecutionState = ExecutionState.Continuous |
+                                ExecutionState.SystemRequired;
+
+                            task.Execute();
+                        }
+                    }
+                    finally
+                    {
+                        //Allow the system to sleep again.
+                        Power.ExecutionState = ExecutionState.Continuous;
+
+                        //If the task is a recurring task, reschedule it for the next execution
+                        //time since we are done with this one.
+                        if (task.Schedule is RecurringSchedule)
+                            ScheduleTask(task);
+
+                        //Remove the actively executing task from our instance variable
+                        currentTask = null;
                     }
                 }
@@ -266 +290 @@
                 //Wait for half a minute to check for the next scheduled task.
                 schedulerInterrupt.WaitOne(30000, false);
-            }
-        }
-
-        /// <summary>
-        /// Executes the given task.
-        /// </summary>
-        /// <param name="task">The task to execute.</param>
-        private void ExecuteTask(Task task)
-        {
-            //Set the currently executing task.
-            currentTask = task;
-
-            //Prevent the system from sleeping.
-            Power.ExecutionState = ExecutionState.Continuous | ExecutionState.SystemRequired;
-
-            try
-            {
-                //Broadcast the task started event.
-                task.Canceled = false;
-                task.OnTaskStarted();
-
-                //Run the task
-                foreach (IErasureTarget target in task.Targets)
-                    try
-                    {
-                        target.Execute();
-                    }
-                    catch (FatalException)
-                    {
-                        throw;
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        throw;
-                    }
-                    catch (SharingViolationException)
-                    {
-                    }
-            }
-            catch (FatalException e)
-            {
-                Logger.Log(e.Message, LogLevel.Fatal);
-            }
-            catch (OperationCanceledException e)
-            {
-                Logger.Log(e.Message, LogLevel.Fatal);
-            }
-            catch (SharingViolationException)
-            {
-            }
-            finally
-            {
-                //Allow the system to sleep again.
-                Power.ExecutionState = ExecutionState.Continuous;
-
-                //If the task is a recurring task, reschedule it since we are done.
-                if (task.Schedule is RecurringSchedule)
-                {
-                    ((RecurringSchedule)task.Schedule).Reschedule(DateTime.Now);
-                    ScheduleTask(task);
-                }
-
-                //And the task finished event.
-                task.OnTaskFinished();
-
-                //If the task is an execute on restart task or run immediately task, it is
-                //only run once and can now be restored to a manually run task
-                if (task.Schedule == Schedule.RunOnRestart || task.Schedule == Schedule.RunNow)
-                    task.Schedule = Schedule.RunManually;
-
-                //Remove the actively executing task from our instance variable
-                currentTask = null;
             }
         }

branches/eraser6/pluginsRewrite/Eraser.Manager/Task.cs

@@ -41 +41 @@
     public class Task : ITask, ISerializable
     {
+        #region ErasureTargetProgressManagerStep
+        /// <summary>
+        /// Returns the progress of an erasure target, since that comprises the
+        /// steps of the Task Progress.
+        /// </summary>
+        private class ErasureTargetProgressManagerStep : SteppedProgressManagerStepBase
+        {
+            /// <summary>
+            /// Constructor.
+            /// </summary>
+            /// <param name="target">The erasure target represented by this object.</param>
+            /// <param name="steps">The number of targets in the task.</param>
+            public ErasureTargetProgressManagerStep(IErasureTarget target, int targets)
+                : base(1.0f / targets)
+            {
+                Target = target;
+            }
+
+            public override ProgressManagerBase Progress
+            {
+                get
+                {
+                    return Target.Progress;
+                }
+                set
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+
+            private IErasureTarget Target;
+        }
+        #endregion
+
         #region Serialization code
         protected Task(SerializationInfo info, StreamingContext context)
@@ -88 +122 @@
 
         /// <summary>
-        /// Cancels the task from running, or, if the task is queued for running,
-        /// removes the task from the queue.
-        /// </summary>
-        public void Cancel()
-        {
-            Executor.UnqueueTask(this);
-            Canceled = true;
-        }
-
-        /// <summary>
         /// The Executor object which is managing this task.
         /// </summary>
@@ -152 +176 @@
                 return S._("{0} and {1} other targets", result, Targets.Count - 3);
             }
-        }
-
-        /// <summary>
-        /// Gets the status of the task - whether it is being executed.
-        /// </summary>
-        public bool Executing { get; private set; }
-
-        /// <summary>
-        /// Gets whether this task is currently queued to run. This is true only
-        /// if the queue it is in is an explicit request, i.e will run when the
-        /// executor is idle.
-        /// </summary>
-        public bool Queued
-        {
-            get
-            {
-                return Executor.IsTaskQueued(this);
-            }
-        }
-
-        /// <summary>
-        /// Gets whether the task has been cancelled from execution.
-        /// </summary>
-        public bool Canceled
-        {
-            get;
-            internal set;
         }
 
@@ -242 +239 @@
         }
 
+        /// <summary>
+        /// Gets the status of the task - whether it is being executed.
+        /// </summary>
+        public bool Executing { get; private set; }
+
+        /// <summary>
+        /// Gets whether this task is currently queued to run. This is true only
+        /// if the queue it is in is an explicit request, i.e will run when the
+        /// executor is idle.
+        /// </summary>
+        public bool Queued
+        {
+            get
+            {
+                if (Executor == null)
+                    throw new InvalidOperationException();
+
+                return Executor.IsTaskQueued(this);
+            }
+        }
+
+        /// <summary>
+        /// Gets whether the task has been cancelled from execution.
+        /// </summary>
+        public bool Canceled
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Cancels the task from running, or, if the task is queued for running,
+        /// removes the task from the queue.
+        /// </summary>
+        public void Cancel()
+        {
+            Executor.UnqueueTask(this);
+            Canceled = true;
+        }
+
+        /// <summary>
+        /// Executes the task in the context of the calling thread.
+        /// </summary>
+        public void Execute()
+        {
+            OnTaskStarted();
+            Executing = true;
+            Canceled = false;
+            Progress = new SteppedProgressManager();
+
+            try
+            {
+                //Run the task
+                foreach (IErasureTarget target in Targets)
+                    try
+                    {
+                        Progress.Steps.Add(new ErasureTargetProgressManagerStep(
+                            target, Targets.Count));
+                        target.Execute();
+                    }
+                    catch (FatalException)
+                    {
+                        throw;
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        throw;
+                    }
+                    catch (SharingViolationException)
+                    {
+                    }
+            }
+            catch (FatalException e)
+            {
+                Logger.Log(e.Message, LogLevel.Fatal);
+            }
+            catch (OperationCanceledException e)
+            {
+                Logger.Log(e.Message, LogLevel.Fatal);
+            }
+            catch (SharingViolationException)
+            {
+            }
+            finally
+            {
+                //If the task is a recurring task, reschedule it since we are done.
+                if (Schedule is RecurringSchedule)
+                {
+                    ((RecurringSchedule)Schedule).Reschedule(DateTime.Now);
+                }
+
+                //If the task is an execute on restart task or run immediately task, it is
+                //only run once and can now be restored to a manually run task
+                if (Schedule == Schedule.RunOnRestart || Schedule == Schedule.RunNow)
+                    Schedule = Schedule.RunManually;
+
+                Progress = null;
+                Executing = false;
+                OnTaskFinished();
+            }
+        }
+
         private Executor executor;
         private Schedule schedule;
@@ -274 +373 @@
         /// Broadcasts the task execution start event.
         /// </summary>
-        internal void OnTaskStarted()
+        private void OnTaskStarted()
         {
             if (TaskStarted != null)
                 TaskStarted(this, EventArgs.Empty);
-            Executing = true;
-            Progress = new SteppedProgressManager();
         }
 
@@ -285 +382 @@
         /// Broadcasts the task execution completion event.
         /// </summary>
-        internal void OnTaskFinished()
-        {
-            Progress = null;
-            Executing = false;
+        private void OnTaskFinished()
+        {
             if (TaskFinished != null)
                 TaskFinished(this, EventArgs.Empty);

branches/eraser6/pluginsRewrite/Eraser.Plugins/ProgressManager.cs

@@ -351 +351 @@
         /// The class which manages the steps which comprise the overall progress.
         /// </summary>
-        private class StepsList : IList<SteppedProgressManagerStep>
+        private class StepsList : IList<SteppedProgressManagerStepBase>
         {
             public StepsList(SteppedProgressManager manager)
             {
-                List = new List<SteppedProgressManagerStep>();
+                List = new List<SteppedProgressManagerStepBase>();
                 ListLock = manager.ListLock;
             }
@@ -361 +361 @@
             #region IList<SteppedProgressManagerStep> Members
 
-            public int IndexOf(SteppedProgressManagerStep item)
+            public int IndexOf(SteppedProgressManagerStepBase item)
             {
                 lock (ListLock)
@@ -367 +367 @@
             }
 
-            public void Insert(int index, SteppedProgressManagerStep item)
+            public void Insert(int index, SteppedProgressManagerStepBase item)
             {
                 lock (ListLock)
@@ -385 +385 @@
             }
 
-            public SteppedProgressManagerStep this[int index]
+            public SteppedProgressManagerStepBase this[int index]
             {
                 get
@@ -407 +407 @@
             #region ICollection<SteppedProgressManagerStep> Members
 
-            public void Add(SteppedProgressManagerStep item)
+            public void Add(SteppedProgressManagerStepBase item)
             {
                 lock (ListLock)
@@ -425 +425 @@
             }
 
-            public bool Contains(SteppedProgressManagerStep item)
+            public bool Contains(SteppedProgressManagerStepBase item)
             {
                 lock (ListLock)
@@ -431 +431 @@
             }
 
-            public void CopyTo(SteppedProgressManagerStep[] array, int arrayIndex)
+            public void CopyTo(SteppedProgressManagerStepBase[] array, int arrayIndex)
             {
                 lock (ListLock)
@@ -451 +451 @@
             }
 
-            public bool Remove(SteppedProgressManagerStep item)
+            public bool Remove(SteppedProgressManagerStepBase item)
             {
                 int index = List.IndexOf(item);
@@ -464 +464 @@
             #region IEnumerable<SteppedProgressManagerStep> Members
 
-            public IEnumerator<SteppedProgressManagerStep> GetEnumerator()
+            public IEnumerator<SteppedProgressManagerStepBase> GetEnumerator()
             {
                 return List.GetEnumerator();
@@ -502 +502 @@
             /// The list storing the steps for this instance.
             /// </summary>
-            private List<SteppedProgressManagerStep> List;
+            private List<SteppedProgressManagerStepBase> List;
 
             /// <summary>
@@ -621 +621 @@
         /// The list of steps involved in completion of the task.
         /// </summary>
-        public IList<SteppedProgressManagerStep> Steps
+        public IList<SteppedProgressManagerStepBase> Steps
         {
             get;
@@ -631 +631 @@
         /// no steps are executing (also when the task is complete)
         /// </summary>
-        public SteppedProgressManagerStep CurrentStep
+        public SteppedProgressManagerStepBase CurrentStep
         {
             get
@@ -640 +640 @@
                         return null;
 
-                    foreach (SteppedProgressManagerStep step in Steps)
+                    foreach (SteppedProgressManagerStepBase step in Steps)
                         if (step.Progress.Progress < 1.0f)
                             return step;
@@ -680 +680 @@
     /// Represents one step in the list of steps to complete.
     /// </summary>
-    public class SteppedProgressManagerStep
+    public abstract class SteppedProgressManagerStepBase
+    {
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="weight">The weight of this step. The weight is a decimal
+        /// number in the range [0.0, 1.0] which represents the percentage of the
+        /// entire process this particular step is.</param>
+        protected SteppedProgressManagerStepBase(float weight)
+            : this(weight, null)
+        {
+        }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="weight">The weight of this step. The weight is a decimal
+        /// number in the range [0.0, 1.0] which represents the percentage of the
+        /// entire process this particular step is.</param>
+        /// <param name="name">A user-specified value of the name of this step.
+        /// This value is not used by the class at all.</param>
+        protected SteppedProgressManagerStepBase(float weight, string name)
+        {
+            if (float.IsInfinity(weight) || float.IsNaN(weight))
+                throw new ArgumentException("The weight of a progress manager step must be " +
+                    "a valid floating-point value.");
+
+            Weight = weight;
+            Name = name;
+        }
+
+        /// <summary>
+        /// The <see cref="ProgressManagerBase"/> instance which measures the
+        /// progress of the step.
+        /// </summary>
+        public abstract ProgressManagerBase Progress
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// The weight associated with this step.
+        /// </summary>
+        public float Weight
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// The name of this step.
+        /// </summary>
+        public string Name
+        {
+            get;
+            set;
+        }
+    }
+
+    public class SteppedProgressManagerStep : SteppedProgressManagerStepBase
     {
         /// <summary>
@@ -706 +766 @@
         /// This value is not used by the class at all.</param>
         public SteppedProgressManagerStep(ProgressManagerBase progress, float weight, string name)
-        {
-            if (float.IsInfinity(weight) || float.IsNaN(weight))
-                throw new ArgumentException("The weight of a progress manager step must be " +
-                    "a valid floating-point value.");
-
+            : base(weight, name)
+        {
             Progress = progress;
-            Weight = weight;
-            Name = name;
         }
 
@@ -720 +775 @@
         /// progress of the step.
         /// </summary>
-        public ProgressManagerBase Progress
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        /// The weight associated with this step.
-        /// </summary>
-        public float Weight
-        {
-            get;
-            private set;
-        }
-
-        /// <summary>
-        /// The name of this step.
-        /// </summary>
-        public string Name
+        public override ProgressManagerBase Progress
         {
             get;