Merge branch '3.4-dev'

Author: ethanhann

src/InEngine.Core/AbstractCommand.cs

@@ -9,6 +9,7 @@ namespace InEngine.Core
 {
     abstract public class AbstractCommand : ICommand, IFailed, IJob, IWrite
     {
+        public LifecycleActions LifecycleActions { get; set; }
         public Write Write { get; set; }
         public ProgressBar ProgressBar { get; internal set; }
         public string Name { get; set; }
@@ -20,7 +21,8 @@ protected AbstractCommand()
             ScheduleId = Guid.NewGuid().ToString();
             Name = GetType().FullName;
             SchedulerGroup = GetType().AssemblyQualifiedName;
-            Write = new Write();;
+            Write = new Write();
+            LifecycleActions = new LifecycleActions();
         }
 
         public virtual void Run()
@@ -55,7 +57,9 @@ public void Execute(IJobExecutionContext context)
 
             try
             {
+                LifecycleActions.BeforeAction?.Invoke(this);
                 Run();
+                LifecycleActions.AfterAction?.Invoke(this);
             }
             catch (Exception exception)
             {

src/InEngine.Core/Exceptions/DuplicateScheduledCommandException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace InEngine.Core.Exceptions
+{
+    public class DuplicateScheduledCommandException : Exception
+    {
+        public DuplicateScheduledCommandException(string commandName, string schedulerId, string schedulerGroup) 
+            : base($"A command was scheduled multiple times with the same ID ({schedulerId}) in the same group ({schedulerGroup}). Ensure IDs are unique in a group.")
+        {}
+    }
+}

src/InEngine.Core/Queuing/Jobs.cs

@@ -23,7 +23,10 @@ private void ScheduleQueueConsumerJobs(Schedule schedule, int consumers, bool us
                 schedule.Job(new Consume() {
                     ScheduleId = $"{(useSecondaryQueue ? "secondary" : "primary")}:{index.ToString()}",
                     UseSecondaryQueue = useSecondaryQueue
-                }).EverySecond();
+                })
+                .EverySecond()
+                .Before(x => Console.Write("Before..."))
+                .After(x => Console.Write("After..."));
         }
     }
 }

src/InEngine.Core/Scheduling/JobGroup.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace InEngine.Core.Scheduling
+{
+    public class JobGroup
+    {
+        public string Name { get; set; }
+        public IDictionary<string, JobRegistration> Registrations { get; set; } = new Dictionary<string, JobRegistration>();
+    }
+}

src/InEngine.Core/Scheduling/JobRegistration.cs

@@ -0,0 +1,22 @@
+using Quartz;
+
+namespace InEngine.Core.Scheduling
+{
+    public class JobRegistration
+    {
+        public AbstractCommand Command { get; set; }
+        public IJobDetail JobDetail { get; set; }
+        public ITrigger Trigger { get; set; }
+
+        public JobRegistration()
+        {}
+
+        public JobRegistration(AbstractCommand command, IJobDetail jobDetail, ITrigger trigger)
+            : this()
+        {
+            Command = command;
+            JobDetail = jobDetail;
+            Trigger = trigger;
+        }
+    }
+}

src/InEngine.Core/Scheduling/LifecycleActionApi.cs

@@ -0,0 +1,10 @@
+using System;
+namespace InEngine.Core.Scheduling
+{
+    public class LifecycleActionApi
+    {
+        public LifecycleActionApi()
+        {
+        }
+    }
+}

src/InEngine.Core/Scheduling/LifecycleActions.cs

@@ -0,0 +1,22 @@
+using System;
+namespace InEngine.Core.Scheduling
+{
+    public class LifecycleActions
+    {
+        public JobRegistration JobRegistration { get; set; }
+        public Action<AbstractCommand> BeforeAction { get; set; }
+        public Action<AbstractCommand> AfterAction { get; set; }
+
+        public LifecycleActions Before(Action<AbstractCommand> action)
+        {
+            JobRegistration.Command.LifecycleActions.BeforeAction = action;
+            return this;
+        }
+
+        public LifecycleActions After(Action<AbstractCommand> action)
+        {
+            JobRegistration.Command.LifecycleActions.AfterAction = action;
+            return this;
+        }
+    }
+}

src/InEngine.Core/Scheduling/Occurence.cs

@@ -6,7 +6,7 @@ namespace InEngine.Core.Scheduling
 {
     public class Occurence
     {
-        public IScheduler Scheduler { get; set; } = StdSchedulerFactory.GetDefaultScheduler();
+        public Schedule Schedule { get; set; }
         public AbstractCommand Command { get; set; }
         public IJobDetail JobDetail { get; set; }
 
@@ -16,32 +16,36 @@ public static TriggerBuilder MakeTriggerBuilder(AbstractCommand command)
                 throw new ArgumentNullException(command.GetType().Name, "The command to schedule cannot be null.");
             return TriggerBuilder
                 .Create()
-                .WithIdentity($"{command.Name}:job:{command.ScheduleId}", command.SchedulerGroup);            
+                .WithIdentity($"{command.Name}:job:{command.ScheduleId}", command.SchedulerGroup);
         }
 
         public void RegisterJob(Action<DailyTimeIntervalScheduleBuilder> action)
         {
-            Scheduler.ScheduleJob(JobDetail, MakeTriggerBuilder(Command).WithDailyTimeIntervalSchedule(action).Build());
+            Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithDailyTimeIntervalSchedule(action).Build());
         }
 
         public void RegisterJob(string cronExpression)
         {
-            Scheduler.ScheduleJob(JobDetail, MakeTriggerBuilder(Command).WithCronSchedule(cronExpression).Build());
+            Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithCronSchedule(cronExpression).Build());
         }
 
         public void RegisterJob(Action<SimpleScheduleBuilder> action)
         {
-            Scheduler.ScheduleJob(JobDetail, MakeTriggerBuilder(Command).WithSimpleSchedule(action).Build());
+            Schedule.RegisterJob(Command, JobDetail, MakeTriggerBuilder(Command).WithSimpleSchedule(action).Build());
         }
 
         public void Cron(string cronExpression)
         {
             RegisterJob(cronExpression);
         }
 
-        public void EverySecond()
+        public LifecycleActions EverySecond()
         {
             RegisterJob(x => x.WithIntervalInSeconds(1).RepeatForever());
+            return new LifecycleActions()
+            {
+                Command = Command
+            };
         }
 
         public void EveryMinute()

src/InEngine.Core/Scheduling/Schedule.cs

@@ -1,4 +1,7 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using InEngine.Core.Exceptions;
 using Quartz;
 using Quartz.Impl;
 
@@ -7,6 +10,7 @@ namespace InEngine.Core.Scheduling
     public class Schedule
     {
         public IScheduler Scheduler { get; set; } = StdSchedulerFactory.GetDefaultScheduler();
+        public IDictionary<string, JobGroup> JobGroups { get; set; } = new Dictionary<string, JobGroup>();
 
         public Occurence Job(AbstractCommand command)
         {
@@ -19,12 +23,40 @@ public Occurence Job(AbstractCommand command)
                    .ToList()
                    .ForEach(x => jobDetail.JobDataMap.Add(x.Name, x.GetValue(command)));
 
-            return new Occurence() {
+            return new Occurence()
+            {
+                Schedule = this,
                 JobDetail = jobDetail,
                 Command = command
             };
         }
 
+        public JobRegistration RegisterJob(AbstractCommand command, IJobDetail jobDetail, ITrigger trigger)
+        {
+            if (!JobGroups.ContainsKey(command.SchedulerGroup))
+                JobGroups.Add(command.SchedulerGroup, new JobGroup());
+                
+            if (JobGroups[command.SchedulerGroup].Registrations.ContainsKey(command.ScheduleId))
+                throw new DuplicateScheduledCommandException(command.Name, command.ScheduleId, command.SchedulerGroup);
+
+            var registration = new JobRegistration(command, jobDetail, trigger);
+            JobGroups[command.SchedulerGroup].Registrations.Add(command.ScheduleId, registration);
+            return registration;
+        }
+
+        public void Initialize()
+        {
+            Plugin.Load<IJobs>().ForEach(x => {
+                x.Make<IJobs>().ForEach(y => y.Schedule(this));
+            });
+
+            JobGroups.AsEnumerable().ToList().ForEach(x => {
+                x.Value.Registrations.AsEnumerable().ToList().ForEach(y => {
+                    Scheduler.ScheduleJob(y.Value.JobDetail, y.Value.Trigger);
+                });
+            });
+        }
+
         public void Start()
         {
             Scheduler.Start();