Support sync and async commands

Author: ethanhann

src/InEngine.Commands/AlwaysFail.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Threading.Tasks;
 using InEngine.Core;
 using InEngine.Core.Exceptions;
 
@@ -10,10 +9,7 @@ namespace InEngine.Commands;
 /// </summary>
 public class AlwaysFail : AbstractCommand
 {
-    public override async Task Run()
-    {
-        await Task.Run(() => throw new CommandFailedException("This command always fails."));
-    }
+    public override void Run() => throw new CommandFailedException("This command always fails.");
 
     public override void Failed(Exception exception)
     {

src/InEngine.Commands/AlwaysSucceed.cs

@@ -1,5 +1,4 @@
-using System.Threading.Tasks;
-using InEngine.Core;
+using InEngine.Core;
 
 namespace InEngine.Commands;
 
@@ -8,8 +7,5 @@ namespace InEngine.Commands;
 /// </summary>
 public class AlwaysSucceed : AbstractCommand
 {
-    public override async Task Run()
-    {
-        await Task.Run(() => Info("This command always succeeds."));
-    }
+    public override void Run() => Info("This command always succeeds.");
 }

src/InEngine.Commands/Sample/Minimal.cs

@@ -14,8 +14,5 @@ namespace InEngine.Commands.Sample;
  */
 public class Minimal : AbstractCommand
 {
-    public override async Task Run()
-    {
-        await Task.Run(() => Console.WriteLine("This is an example of a minimal command."));
-    }
+    public override void Run() => Line("This is an example of a minimal command.");
 }

src/InEngine.Commands/Sample/Pause.cs

@@ -1,13 +1,9 @@
 using System.Threading;
 using InEngine.Core;
-using System.Threading.Tasks;
 
 namespace InEngine.Commands.Sample;
 
 public class Pause : AbstractCommand
 {
-    public override async Task Run()
-    {
-        await Task.Run(() => Thread.Sleep(3000));
-    }
+    public override void Run() => Thread.Sleep(3000);
 }

src/InEngine.Commands/Sample/SayHello.cs

@@ -1,13 +1,8 @@
 using InEngine.Core;
-using System;
-using System.Threading.Tasks;
 
 namespace InEngine.Commands.Sample;
 
 public class SayHello : AbstractCommand
 {
-    public override async Task Run()
-    {
-        await Task.Run(() => Console.WriteLine("hello"));
-    }
+    public override void Run() => Line("hello");
 }

src/InEngine.Commands/Sample/ShowProgress.cs

@@ -13,10 +13,10 @@ public class ShowProgress : AbstractCommand
      * Note that the override keyword is necessary in the Run method 
      * signature as the base class method is virtual.
      */
-    public override async Task Run()
+    public override async Task RunAsync()
     {
         // Define the ticks (aka steps) for the command...
-        var maxTicks = 100000;
+        const int maxTicks = 100000;
         SetProgressBarMaxTicks(maxTicks);
 
         // Do some work...

src/InEngine.Core.Test/Commands/ChainTest.cs

@@ -27,10 +27,10 @@ public void ShouldRunChainOfCommands()
         };
         Subject.Commands = commands;
 
-        Subject.Run();
+        Subject.RunAsync();
 
-        mockCommand1.Verify(x => x.Run(), Times.Once());
-        mockCommand2.Verify(x => x.Run(), Times.Once());
+        mockCommand1.Verify(x => x.RunAsync(), Times.Once());
+        mockCommand2.Verify(x => x.RunAsync(), Times.Once());
     }
 
     [Test]
@@ -47,10 +47,10 @@ public void ShouldRunChainOfCommandsAndFail()
         };
         Subject.Commands = commands;
 
-        Assert.That(Subject.Run, Throws.TypeOf<CommandChainFailedException>());
+        Assert.That(Subject.RunAsync, Throws.TypeOf<CommandChainFailedException>());
 
-        mockCommand1.Verify(x => x.Run(), Times.Once());
-        mockCommand2.Verify(x => x.Run(), Times.Never());
+        mockCommand1.Verify(x => x.RunAsync(), Times.Once());
+        mockCommand2.Verify(x => x.RunAsync(), Times.Never());
     }
 
     [Test]
@@ -62,7 +62,7 @@ public void ShouldRunChainOfDifferentCommands()
             new Echo() { VerbatimText = "Hello, world!" },
         };
 
-        Subject.Run();
+        Subject.RunAsync();
     }
 
     [Test]
@@ -74,6 +74,6 @@ public void ShouldRunChainOfDifferentCommandsAsAbstractCommand()
             new Echo(verbatimText: "Hello, world!"),
         };
 
-        Subject.Run();
+        Subject.RunAsync();
     }
 }

src/InEngine.Core/AbstractCommand.cs

@@ -24,11 +24,12 @@ public abstract class AbstractCommand : IJob, IWrite, IHasCommandLifeCycle, IHas
     public int SecondsBeforeTimeout { get; set; } = 300;
 
     private MailSettings mailSettings;
+
     public MailSettings MailSettings
     {
         get => mailSettings;
         set => CommandLifeCycle.MailSettings = mailSettings = value;
-    } 
+    }
 
     protected AbstractCommand()
     {
@@ -38,21 +39,26 @@ protected AbstractCommand()
         SchedulerGroup = GetType().AssemblyQualifiedName;
     }
 
-    public abstract Task Run();
+    public virtual void Run()
+    {
+    }
+
+    public virtual async Task RunAsync() => await Task.Run(Run).ConfigureAwait(false);
 
     public virtual async Task RunWithLifeCycle()
     {
         try
         {
             CommandLifeCycle.FirePreActions(this);
             if (SecondsBeforeTimeout <= 0)
-                await Run();
+                await RunAsync();
             else
             {
-                var task = Task.Run(Run);
+                var task = Task.Run(RunAsync);
                 if (!task.Wait(TimeSpan.FromSeconds(SecondsBeforeTimeout)))
                     throw new Exception($"Scheduled command timed out after {SecondsBeforeTimeout} second(s).");
             }
+
             CommandLifeCycle.FirePostActions(this);
         }
         catch (Exception exception)
@@ -65,32 +71,39 @@ public virtual async Task RunWithLifeCycle()
     }
 
     public virtual void Failed(Exception exception)
-    {}
+    {
+    }
 
     #region ProgressBar
+
     public void SetProgressBarMaxTicks(int maxTicks) => ProgressBar = new ProgressBar(maxTicks);
 
     public void UpdateProgress(int tick) => ProgressBar.Refresh(tick, Name);
 
     #endregion
 
     #region Scheduling
+
     public virtual async Task Execute(IJobExecutionContext context)
     {
         if (context != null)
         {
             var properties = GetType().GetProperties();
-            context.MergedJobDataMap.ToList().ForEach(x => {
+            context.MergedJobDataMap.ToList().ForEach(x =>
+            {
                 var property = properties.FirstOrDefault(y => y.Name == x.Key);
                 if (property != null)
                     property.SetValue(this, x.Value);
             });
         }
+
         await RunWithLifeCycle();
     }
+
     #endregion
 
     #region Console output
+
     public IWrite Info(object val) => Write.Info(val);
     public IWrite Warning(object val) => Write.Warning(val);
     public IWrite Error(object val) => Write.Error(val);

src/InEngine.Core/Commands/Chain.cs

@@ -11,14 +11,14 @@ public class Chain : AbstractCommand
 {
     public IList<AbstractCommand> Commands { get; set; } = new List<AbstractCommand>();
 
-    public override async Task Run()
+    public override async Task RunAsync()
     {
         foreach (var x in Commands.ToList())
         {
             try
             {
                 x.WriteSummaryToConsole();
-                await x.Run();
+                await x.RunAsync();
             }
             catch (Exception exception)
             {

src/InEngine.Core/Commands/Echo.cs

@@ -1,5 +1,4 @@
-using System.Threading.Tasks;
-using CommandLine;
+using CommandLine;
 
 namespace InEngine.Core.Commands;
 
@@ -17,5 +16,5 @@ public Echo()
     [Option("text", HelpText = "The text to echo.")]
     public string VerbatimText { get; init; }
 
-    public override async Task Run() => await Task.Run(() => Line(VerbatimText));
+    public override void Run() =>  Line(VerbatimText);
 }