ShouldProcess

sergey-shandar · sergey-shandar · commit ace1441b01cf · 2017-11-27T17:28:21.000-08:00
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Commands.Common.Strategies.csproj b/src/ResourceManager/Common/Commands.Common.Strategies/Commands.Common.Strategies.csproj
@@ -71,6 +71,7 @@
     <Compile Include="Compute\Images.cs" />
     <Compile Include="IResourceConfig.cs" />
     <Compile Include="IResourceConfigVisitor.cs" />
+    <Compile Include="IShouldProcess.cs" />
     <Compile Include="StateOperationContext.cs" />
     <Compile Include="Compute\ComputeStrategy.cs" />
     <Compile Include="Compute\VirtualMachineStrategy.cs" />
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Compute/ComputeStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Compute/ComputeStrategy.cs
@@ -8,12 +8,14 @@ namespace Microsoft.Azure.Commands.Common.Strategies.Compute
     public static class ComputePolicy
     {
         public static ResourceStrategy<TModel> Create<TModel, TOperations>(
+            string type,
             string header,
             Func<ComputeManagementClient, TOperations> getOperations,
             Func<TOperations, GetAsyncParams, Task<TModel>> getAsync,
             Func<TOperations, CreateOrUpdateAsyncParams<TModel>, Task<TModel>> createOrUpdateAsync)
             where TModel : Resource
             => ResourceStrategy.Create(
+                type,
                 new[] { "Microsoft.Compute", header },
                 getOperations,
                 getAsync,
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Compute/VirtualMachineStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Compute/VirtualMachineStrategy.cs
@@ -9,6 +9,7 @@ public static class VirtualMachineStrategy
     {
         public static ResourceStrategy<VirtualMachine> Strategy { get; }
             = ComputePolicy.Create(
+                "virtual machine",
                 "virtualMachines",
                 client => client.VirtualMachines,
                 (o, p) => o.GetAsync(
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/IShouldProcess.cs b/src/ResourceManager/Common/Commands.Common.Strategies/IShouldProcess.cs
@@ -0,0 +1,8 @@
+﻿namespace Microsoft.Azure.Commands.Common.Strategies
+{
+    public interface IShouldProcess
+    {
+        bool ShouldCreate<TModel>(ResourceConfig<TModel> config, TModel model)
+            where TModel : class;
+    }
+}
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkInterfaceStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkInterfaceStrategy.cs
@@ -8,6 +8,7 @@ public static class NetworkInterfaceStrategy
     {
         public static ResourceStrategy<NetworkInterface> Strategy { get; }
             = NetworkStrategy.Create(
+                "network interface",
                 "networkInterfaces",
                 client => client.NetworkInterfaces,
                 (o, p) => o.GetAsync(
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkSecurityGroupPolicy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkSecurityGroupPolicy.cs
@@ -9,6 +9,7 @@ public static class NetworkSecurityGroupStrategy
     {
         public static ResourceStrategy<NetworkSecurityGroup> Strategy { get; }
             = NetworkStrategy.Create(
+                "network security group",
                 "networkSecurityGroups",
                 client => client.NetworkSecurityGroups,
                 (o, p) => o.GetAsync(
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkStrategy.cs
@@ -8,12 +8,14 @@ namespace Microsoft.Azure.Commands.Common.Strategies.Network
     public static class NetworkStrategy
     {
         public static ResourceStrategy<TModel> Create<TModel, TOperations>(
+            string type,
             string header,
             Func<NetworkManagementClient, TOperations> getOperations,
             Func<TOperations, GetAsyncParams, Task<TModel>> getAsync,
             Func<TOperations, CreateOrUpdateAsyncParams<TModel>, Task<TModel>> createOrUpdateAsync)
             where TModel : Resource
             => ResourceStrategy.Create(
+                type,
                 new [] { "Microsoft.Network", header },
                 getOperations,
                 getAsync,
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Network/PublicIPAddressStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Network/PublicIPAddressStrategy.cs
@@ -8,6 +8,7 @@ public static class PublicIPAddressStrategy
     {
         public static ResourceStrategy<PublicIPAddress> Strategy { get; }
             = NetworkStrategy.Create(
+                "public IP address",
                 "publicIPAddresses",
                 client => client.PublicIPAddresses,
                 (o, p) => o.GetAsync(
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Network/SubnetStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Network/SubnetStrategy.cs
@@ -9,7 +9,7 @@ public static class SubnetPolicy
         public static NestedResourceStrategy<Subnet, VirtualNetwork> Strategy { get; }
             = NestedResourceStrategy.Create<Subnet, VirtualNetwork>(
                 "subnets",
-                (vn, name) => vn.Subnets?.FirstOrDefault(s => s.Name == name),
+                (vn, name) => vn.Subnets?.FirstOrDefault(s => s?.Name == name),
                 (vn, name, subnet) =>
                 {
                     subnet.Name = name;
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Network/VirtualNetworkStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Network/VirtualNetworkStrategy.cs
@@ -9,6 +9,7 @@ public static class VirtualNetworkStrategy
     {
         public static ResourceStrategy<VirtualNetwork> Strategy { get; }
             = NetworkStrategy.Create(
+                "virtual network",
                 "virtualNetworks",
                 client => client.VirtualNetworks,
                 (o, p) => o.GetAsync(
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/ResourceManager/ResourceGroupStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/ResourceManager/ResourceGroupStrategy.cs
@@ -8,6 +8,7 @@ public static class ResourceGroupStrategy
     {
         public static ResourceStrategy<ResourceGroup> Strategy { get; }
             = ResourceStrategy.Create(
+                "resource group",
                 _ => Enumerable.Empty<string>(),
                 (ResourceManagementClient client) => client.ResourceGroups,
                 (o, p) => o.GetAsync(p.Name, p.CancellationToken),
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/ResourceStrategy.cs b/src/ResourceManager/Common/Commands.Common.Strategies/ResourceStrategy.cs
@@ -8,6 +8,8 @@ namespace Microsoft.Azure.Commands.Common.Strategies
 {
     public sealed class ResourceStrategy<TModel> : IEntityStrategy
     {
+        public string Type { get; }
+
         public Func<string, IEnumerable<string>> GetId { get; }
 
         public Func<IClient, GetAsyncParams, Task<TModel>> GetAsync { get; }
@@ -20,12 +22,14 @@ public Func<IClient, CreateOrUpdateAsyncParams<TModel>, Task<TModel>> CreateOrUp
         public Action<TModel, string> SetLocation { get; }
 
         public ResourceStrategy(
+            string type,
             Func<string, IEnumerable<string>> getId,
             Func<IClient, GetAsyncParams, Task<TModel>> getAsync,
             Func<IClient, CreateOrUpdateAsyncParams<TModel>, Task<TModel>> createOrUpdateAsync,
             Func<TModel, string> getLocation,
             Action<TModel, string> setLocation)
         {
+            Type = type;
             GetId = getId;
             GetAsync = getAsync;
             CreateOrUpdateAsync = createOrUpdateAsync;
@@ -37,6 +41,7 @@ public ResourceStrategy(
     public static class ResourceStrategy
     {
         public static ResourceStrategy<TModel> Create<TModel, TClient, TOperation>(
+            string type,
             Func<string, IEnumerable<string>> getId,
             Func<TClient, TOperation> getOperations,
             Func<TOperation, GetAsyncParams, Task<TModel>> getAsync,
@@ -47,6 +52,7 @@ public static ResourceStrategy<TModel> Create<TModel, TClient, TOperation>(
         {
             Func<IClient, TOperation> toOperations = client => getOperations(client.GetClient<TClient>());
             return new ResourceStrategy<TModel>(
+                type,
                 getId,
                 (client, p) => getAsync(toOperations(client), p),
                 (client, p) => createOrUpdateAsync(toOperations(client), p),
@@ -55,6 +61,7 @@ public static ResourceStrategy<TModel> Create<TModel, TClient, TOperation>(
         }
 
         public static ResourceStrategy<TModel> Create<TModel, TClient, TOperation>(
+            string type,
             IEnumerable<string> headers,
             Func<TClient, TOperation> getOperations,
             Func<TOperation, GetAsyncParams, Task<TModel>> getAsync,
@@ -63,6 +70,7 @@ public static ResourceStrategy<TModel> Create<TModel, TClient, TOperation>(
             Action<TModel, string> setLocation)
             where TClient : ServiceClient<TClient>
             => Create(
+                type,
                 name => new[] { "providers" }.Concat(headers).Concat(new[] { name }),
                 getOperations,
                 getAsync,
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/StateExtensions.cs b/src/ResourceManager/Common/Commands.Common.Strategies/StateExtensions.cs
@@ -16,7 +16,10 @@ public static TModel Get<TModel, TParentModel>(
             this IState state, NestedResourceConfig<TModel, TParentModel> config)
             where TModel : class
             where TParentModel : class
-            => config.Strategy.Get(state.GetDispatch(config.Parent), config.Name);
+        {
+            var parentModel = state.GetDispatch(config.Parent);
+            return parentModel == null ? null : config.Strategy.Get(parentModel, config.Name);
+        }
 
         /// <summary>
         /// Get a model of the given entity model from the given state.
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/UpdateStateExtensions.cs b/src/ResourceManager/Common/Commands.Common.Strategies/UpdateStateExtensions.cs
@@ -11,10 +11,12 @@ public static async Task<IState> UpdateStateAsync<TModel>(
             this ResourceConfig<TModel> config,
             IClient client,
             IState target,
-            CancellationToken cancellationToken)
+            CancellationToken cancellationToken,
+            IShouldProcess shouldProcess)
             where TModel : class
         {
-            var context = new Context(new StateOperationContext(client, cancellationToken), target);
+            var context = new Context(
+                new StateOperationContext(client, cancellationToken), target, shouldProcess);
             await context.UpdateStateAsync(config);
             return context.Result;
         }
@@ -27,10 +29,14 @@ sealed class Context
 
             readonly IState _Target;
 
-            public Context(StateOperationContext operationContext, IState target)
+            readonly IShouldProcess _ShouldProcess;
+
+            public Context(
+                StateOperationContext operationContext, IState target, IShouldProcess shouldProcess)
             {
                 _OperationContext = operationContext;
                 _Target = target;
+                _ShouldProcess = shouldProcess;
             }
 
             public async Task UpdateStateAsync<TModel>(ResourceConfig<TModel> config)
@@ -49,16 +55,16 @@ await _OperationContext.GetOrAdd(
                                 .Select(UpdateStateAsyncDispatch);
                             await Task.WhenAll(tasks);
                             // call the CreateOrUpdateAsync function for the resource.
-                            try
+                            if (_ShouldProcess.ShouldCreate(config, model))
                             {
                                 return await config.CreateOrUpdateAsync(
                                     _OperationContext.Client,
                                     model,
                                     _OperationContext.CancellationToken);
                             }
-                            catch (Exception e)
+                            else
                             {
-                                throw e;
+                                return null;
                             }
                         });
                 }
diff --git a/src/ResourceManager/Compute/Commands.Compute/VirtualMachine/Operation/NewAzureVMCommand.cs b/src/ResourceManager/Compute/Commands.Compute/VirtualMachine/Operation/NewAzureVMCommand.cs
@@ -184,6 +184,20 @@ 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 + " " + config.Strategy.Type, VerbsCommon.New);
+        }
+
         public void StrategyExecuteCmdlet()
         {
             ResourceGroupName = ResourceGroupName ?? Name;
@@ -240,14 +254,12 @@ public void StrategyExecuteCmdlet()
 
             var target = virtualMachine.GetTargetState(current, client.SubscriptionId, Location);
 
-            if (ShouldProcess(Name, VerbsCommon.New))
-            {
-                var result = virtualMachine
-                    .UpdateStateAsync(client, target, new CancellationToken())
-                    .GetAwaiter()
-                    .GetResult();
-                WriteObject(result);
-            }
+            var result = virtualMachine
+                .UpdateStateAsync(
+                    client, target, new CancellationToken(), new ShouldProcessType(this))
+                .GetAwaiter()
+                .GetResult();
+            WriteObject(result);
         }
 
         public void DefaultExecuteCmdlet()

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ public static class VirtualMachineStrategy`
`9`	`9`	`{`
`10`	`10`	`public static ResourceStrategy<VirtualMachine> Strategy { get; }`
`11`	`11`	`= ComputePolicy.Create(`
	`12`	`+ "virtual machine",`
`12`	`13`	`"virtualMachines",`
`13`	`14`	`client => client.VirtualMachines,`
`14`	`15`	`(o, p) => o.GetAsync(`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ public static class NetworkInterfaceStrategy`
`8`	`8`	`{`
`9`	`9`	`public static ResourceStrategy<NetworkInterface> Strategy { get; }`
`10`	`10`	`= NetworkStrategy.Create(`
	`11`	`+ "network interface",`
`11`	`12`	`"networkInterfaces",`
`12`	`13`	`client => client.NetworkInterfaces,`
`13`	`14`	`(o, p) => o.GetAsync(`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ public static class NetworkSecurityGroupStrategy`
`9`	`9`	`{`
`10`	`10`	`public static ResourceStrategy<NetworkSecurityGroup> Strategy { get; }`
`11`	`11`	`= NetworkStrategy.Create(`
	`12`	`+ "network security group",`
`12`	`13`	`"networkSecurityGroups",`
`13`	`14`	`client => client.NetworkSecurityGroups,`
`14`	`15`	`(o, p) => o.GetAsync(`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ public static class PublicIPAddressStrategy`
`8`	`8`	`{`
`9`	`9`	`public static ResourceStrategy<PublicIPAddress> Strategy { get; }`
`10`	`10`	`= NetworkStrategy.Create(`
	`11`	`+ "public IP address",`
`11`	`12`	`"publicIPAddresses",`
`12`	`13`	`client => client.PublicIPAddresses,`
`13`	`14`	`(o, p) => o.GetAsync(`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public static class SubnetPolicy`
`9`	`9`	`public static NestedResourceStrategy<Subnet, VirtualNetwork> Strategy { get; }`
`10`	`10`	`= NestedResourceStrategy.Create<Subnet, VirtualNetwork>(`
`11`	`11`	`"subnets",`
`12`		`- (vn, name) => vn.Subnets?.FirstOrDefault(s => s.Name == name),`
	`12`	`+ (vn, name) => vn.Subnets?.FirstOrDefault(s => s?.Name == name),`
`13`	`13`	`(vn, name, subnet) =>`
`14`	`14`	`{`
`15`	`15`	`subnet.Name = name;`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ public static class ResourceGroupStrategy`
`8`	`8`	`{`
`9`	`9`	`public static ResourceStrategy<ResourceGroup> Strategy { get; }`
`10`	`10`	`= ResourceStrategy.Create(`
	`11`	`+ "resource group",`
`11`	`12`	`_ => Enumerable.Empty<string>(),`
`12`	`13`	`(ResourceManagementClient client) => client.ResourceGroups,`
`13`	`14`	`(o, p) => o.GetAsync(p.Name, p.CancellationToken),`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,12 @@ public static async Task<IState> UpdateStateAsync<TModel>(`
`11`	`11`	`this ResourceConfig<TModel> config,`
`12`	`12`	`IClient client,`
`13`	`13`	`IState target,`
`14`		`- CancellationToken cancellationToken)`
	`14`	`+ CancellationToken cancellationToken,`
	`15`	`+ IShouldProcess shouldProcess)`
`15`	`16`	`where TModel : class`
`16`	`17`	`{`
`17`		`- var context = new Context(new StateOperationContext(client, cancellationToken), target);`
	`18`	`+ var context = new Context(`
	`19`	`+ new StateOperationContext(client, cancellationToken), target, shouldProcess);`
`18`	`20`	`await context.UpdateStateAsync(config);`
`19`	`21`	`return context.Result;`
`20`	`22`	`}`
`@@ -27,10 +29,14 @@ sealed class Context`
`27`	`29`
`28`	`30`	`readonly IState _Target;`
`29`	`31`
`30`		`- public Context(StateOperationContext operationContext, IState target)`
	`32`	`+ readonly IShouldProcess _ShouldProcess;`
	`33`	`+`
	`34`	`+ public Context(`
	`35`	`+ StateOperationContext operationContext, IState target, IShouldProcess shouldProcess)`
`31`	`36`	`{`
`32`	`37`	`_OperationContext = operationContext;`
`33`	`38`	`_Target = target;`
	`39`	`+ _ShouldProcess = shouldProcess;`
`34`	`40`	`}`
`35`	`41`
`36`	`42`	`public async Task UpdateStateAsync<TModel>(ResourceConfig<TModel> config)`
`@@ -49,16 +55,16 @@ await _OperationContext.GetOrAdd(`
`49`	`55`	`.Select(UpdateStateAsyncDispatch);`
`50`	`56`	`await Task.WhenAll(tasks);`
`51`	`57`	`// call the CreateOrUpdateAsync function for the resource.`
`52`		`- try`
	`58`	`+ if (_ShouldProcess.ShouldCreate(config, model))`
`53`	`59`	`{`
`54`	`60`	`return await config.CreateOrUpdateAsync(`
`55`	`61`	`_OperationContext.Client,`
`56`	`62`	`model,`
`57`	`63`	`_OperationContext.CancellationToken);`
`58`	`64`	`}`
`59`		`- catch (Exception e)`
	`65`	`+ else`
`60`	`66`	`{`
`61`		`- throw e;`
	`67`	`+ return null;`
`62`	`68`	`}`
`63`	`69`	`});`
`64`	`70`	`}`