MessageLoop, kind of.

Author: sergey-shandar

src/ResourceManager/Common/Commands.Common.Strategies/IShouldProcess.cs

@@ -12,11 +12,13 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
+using System.Threading.Tasks;
+
 namespace Microsoft.Azure.Commands.Common.Strategies
 {
     public interface IShouldProcess
     {
-        bool ShouldCreate<TModel>(ResourceConfig<TModel> config, TModel model)
+        Task<bool> ShouldCreate<TModel>(ResourceConfig<TModel> config, TModel model)
             where TModel : class;
     }
 }

src/ResourceManager/Common/Commands.Common.Strategies/UpdateStateExtensions.cs

@@ -78,7 +78,7 @@ await _OperationContext.GetOrAdd(
                                 .Select(UpdateStateAsyncDispatch);
                             await Task.WhenAll(tasks);
                             // call the CreateOrUpdateAsync function for the resource.
-                            if (_ShouldProcess.ShouldCreate(config, model))
+                            if (await _ShouldProcess.ShouldCreate(config, model))
                             {
                                 _ProgressReport.Report(config, 0.0);
                                 var result = await config.CreateOrUpdateAsync(

src/ResourceManager/Compute/Commands.Compute/Commands.Compute.csproj

@@ -290,6 +290,9 @@
     <Compile Include="StorageServices\CloudPageBlobObjectFactory.cs" />
     <Compile Include="StorageServices\SaveAzureVhdCommand.cs" />
     <Compile Include="StorageServices\StorageCredentialsFactory.cs" />
+    <Compile Include="Strategies\MessageLoop.cs" />
+    <Compile Include="Strategies\ProgressReport.cs" />
+    <Compile Include="Strategies\ShouldProcess.cs" />
     <Compile Include="Usage\GetAzureVMUsageCommand.cs" />
     <Compile Include="Usage\VirtualMachineUsageBaseCmdlet.cs" />
     <Compile Include="VirtualMachineSizes\GetAzureVMSizeCommand.cs" />

src/ResourceManager/Compute/Commands.Compute/Strategies/MessageLoop.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Commands.Compute.Strategies
+{
+    internal sealed class MessageLoop
+    {
+        readonly ConcurrentQueue<Task> _Tasks = new ConcurrentQueue<Task>();
+
+        public async Task<T> Invoke<T>(Func<T> func)
+        {
+            var task = new Task<T>(func);
+            _Tasks.Enqueue(task);
+            while (!task.IsCompleted)
+            {
+                await Task.Yield();
+            }
+            return task.Result;
+        }
+
+        public void BeginInvoke(Action action)
+            => _Tasks.Enqueue(new Task(action));
+
+        public void Wait(Task task)
+        {
+            while (!task.IsCompleted)
+            {
+                HandleActions();
+                Thread.Yield();
+            }
+            HandleActions();
+        }
+
+        void HandleActions()
+        {
+            Task task;
+            while (_Tasks.TryDequeue(out task))
+            {
+                task.RunSynchronously();
+            }
+        }
+    }
+}

src/ResourceManager/Compute/Commands.Compute/Strategies/ProgressReport.cs

@@ -0,0 +1,24 @@
+using Microsoft.Azure.Commands.Common.Strategies;
+using System.Management.Automation;
+
+namespace Microsoft.Azure.Commands.Compute.Strategies
+{
+    sealed class ProgressReport : IProgressReport
+    {
+        readonly Cmdlet _Cmdlet;
+
+        readonly MessageLoop _MessageLoop;
+
+        public ProgressReport(Cmdlet cmdlet, MessageLoop messageLoop)
+        {
+            _Cmdlet = cmdlet;
+            _MessageLoop = messageLoop;
+        }
+
+        public void Report<TModel>(ResourceConfig<TModel> config, double progress)
+            where TModel : class
+            => _MessageLoop.BeginInvoke(() => _Cmdlet.WriteVerbose(progress == 0 
+                ? "Creating " + config.Name + " " + config.Strategy.Type + "..."
+                : config.Name + " " + config.Strategy.Type + " is created."));
+    }
+}

src/ResourceManager/Compute/Commands.Compute/Strategies/ShouldProcess.cs

@@ -0,0 +1,25 @@
+using Microsoft.Azure.Commands.Common.Strategies;
+using System.Management.Automation;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Commands.Compute.Strategies
+{
+    internal sealed class ShouldProcess : IShouldProcess
+    {
+        readonly Cmdlet _Cmdlet;
+
+        readonly MessageLoop _MessageLoop;
+
+        public ShouldProcess(Cmdlet cmdlet, MessageLoop messageLoop)
+        {
+            _Cmdlet = cmdlet;
+            _MessageLoop = messageLoop;
+        }
+
+        public async Task<bool> ShouldCreate<TModel>(ResourceConfig<TModel> config, TModel model)
+            where TModel : class
+            => await _MessageLoop.Invoke(
+                () => _Cmdlet.ShouldProcess(
+                    config.Name, VerbsCommon.New + " " + config.Strategy.Type));
+    }
+}

src/ResourceManager/Compute/Commands.Compute/VirtualMachine/Operation/NewAzureVMCommand.cs

@@ -22,6 +22,7 @@
 using Microsoft.Azure.Commands.Common.Strategies.ResourceManager;
 using Microsoft.Azure.Commands.Compute.Common;
 using Microsoft.Azure.Commands.Compute.Models;
+using Microsoft.Azure.Commands.Compute.Strategies;
 using Microsoft.Azure.Commands.ResourceManager.Common.ArgumentCompleters;
 using Microsoft.Azure.Management.Compute;
 using Microsoft.Azure.Management.Compute.Models;
@@ -32,11 +33,13 @@
 using Microsoft.Rest;
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Linq;
 using System.Management.Automation;
 using System.Net;
 using System.Reflection;
 using System.Threading;
+using System.Threading.Tasks;
 using CM = Microsoft.Azure.Management.Compute.Models;
 
 namespace Microsoft.Azure.Commands.Compute
@@ -166,6 +169,8 @@ public override void ExecuteCmdlet()
             }
         }
 
+        readonly MessageLoop _MessageLoop = new MessageLoop();
+
         private sealed class Client : IClient
         {
             public string SubscriptionId { get; }
@@ -184,41 +189,7 @@ public T GetClient<T>()
                     Context, AzureEnvironment.Endpoint.ResourceManager);
         }
 
-        private sealed class ShouldProcessType : IShouldProcess
-        {
-            readonly Cmdlet _Cmdlet;
-
-            public ShouldProcessType(Cmdlet cmdlet)
-            {
-                _Cmdlet = cmdlet;
-            }
-
-            public bool ShouldCreate<TModel>(ResourceConfig<TModel> config, TModel model)
-                where TModel : class
-                => _Cmdlet.ShouldProcess(config.Name, VerbsCommon.New + " " + config.Strategy.Type);
-        }
-
-        private sealed class ProgressReportType : IProgressReport
-        {
-            readonly Cmdlet _Cmdlet;
-
-            public ProgressReportType(Cmdlet cmdlet)
-            {
-                _Cmdlet = cmdlet;
-            }
-
-            public void Report<TModel>(ResourceConfig<TModel> config, double progress) 
-                where TModel : class
-            {
-            }
-            /*
-                => _Cmdlet.WriteVerbose(
-                    progress == 0 ? "Creating " + config.Name + " " + config.Strategy.Type + "..."
-                    : config.Name + " " + config.Strategy.Type + " is created.");
-                    */
-        }
-
-        public void StrategyExecuteCmdlet()
+        public async Task StrategyExecuteCmdletAsync()
         {
             ResourceGroupName = ResourceGroupName ?? Name;
             VirtualNetworkName = VirtualNetworkName ?? Name;
@@ -261,10 +232,7 @@ public void StrategyExecuteCmdlet()
 
             // get state
             var client = new Client(DefaultProfile.DefaultContext);
-            var current = virtualMachine
-                .GetStateAsync(client, new CancellationToken())
-                .GetAwaiter()
-                .GetResult();
+            var current = await virtualMachine.GetStateAsync(client, new CancellationToken());
 
             if (Location == null)
             {
@@ -279,18 +247,19 @@ public void StrategyExecuteCmdlet()
             var target = virtualMachine.GetTargetState(current, client.SubscriptionId, Location);
 
             // apply target state
-            var result = virtualMachine
+            var result = await virtualMachine
                 .UpdateStateAsync(
                     client,
                     target,
                     new CancellationToken(),
-                    new ShouldProcessType(this),
-                    new ProgressReportType(this))
-                .GetAwaiter()
-                .GetResult();
+                    new ShouldProcess(this, _MessageLoop),
+                    new ProgressReport(this, _MessageLoop));
             WriteObject(result);
         }
 
+        public void StrategyExecuteCmdlet()
+            => _MessageLoop.Wait(StrategyExecuteCmdletAsync());
+
         public void DefaultExecuteCmdlet()
         {
             base.ExecuteCmdlet();