Resource strategies.

Author: sergey-shandar

src/ResourceManager/Common/Commands.Common.Strategies/Commands.Common.Strategies.csproj

@@ -65,6 +65,8 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AsyncOperationVisitor.cs" />
+    <Compile Include="Compute\ComputeStrategy.cs" />
+    <Compile Include="Compute\VirtualMachineStrategy.cs" />
     <Compile Include="CreateOrUpdateAsyncOperation.cs" />
     <Compile Include="CreateOrUpdateAsyncParams.cs" />
     <Compile Include="Extensions.cs" />
@@ -77,6 +79,13 @@
     <Compile Include="IState.cs" />
     <Compile Include="NestedResourceConfig.cs" />
     <Compile Include="NestedResourceStrategy.cs" />
+    <Compile Include="Network\NetworkInterfaceStrategy.cs" />
+    <Compile Include="Network\NetworkSecurityGroupPolicy.cs" />
+    <Compile Include="Network\NetworkStrategy.cs" />
+    <Compile Include="Network\PublicIPAddressStrategy.cs" />
+    <Compile Include="Network\SubnetStrategy.cs" />
+    <Compile Include="Network\VirtualNetworkStrategy.cs" />
+    <Compile Include="ResourceManager\ResourceGroupStrategy.cs" />
     <Compile Include="TargetState.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ResourceConfig.cs" />

src/ResourceManager/Common/Commands.Common.Strategies/Compute/ComputeStrategy.cs

@@ -0,0 +1,24 @@
+using Microsoft.Azure.Management.Compute;
+using Microsoft.Azure.Management.Compute.Models;
+using System;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Commands.Common.Strategies.Compute
+{
+    public static class ComputePolicy
+    {
+        public static ResourceStrategy<Model> Create<Model, Operations>(
+            string header,
+            Func<IComputeManagementClient, Operations> getOperations,
+            Func<GetAsyncParams<Operations>, Task<Model>> getAsync,
+            Func<CreateOrUpdateAsyncParams<Operations, Model>, Task<Model>> createOrUpdateAsync)
+            where Model : Resource
+            => ResourceStrategy.Create(
+                new[] { "Microsoft.Compute", header },
+                getOperations,
+                getAsync,
+                createOrUpdateAsync,
+                config => config.Location,
+                (config, location) => config.Location = location);
+    }
+}

src/ResourceManager/Common/Commands.Common.Strategies/Compute/VirtualMachineStrategy.cs

@@ -0,0 +1,66 @@
+using Microsoft.Azure.Management.Compute;
+using Microsoft.Azure.Management.Compute.Models;
+using Microsoft.Azure.Management.Network.Models;
+using Microsoft.Azure.Management.ResourceManager.Models;
+
+namespace Microsoft.Azure.Commands.Common.Strategies.Compute
+{
+    public static class VirtualMachineStrategy
+    {
+        public static ResourceStrategy<VirtualMachine> Strategy { get; }
+            = ComputePolicy.Create(
+                "virtualMachines",
+                client => client.VirtualMachines,
+                p => p.Operations.GetAsync(
+                    p.ResourceGroupName, p.Name, null, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(
+                    p.ResourceGroupName, p.Name, p.Model, p.CancellationToken));
+
+        public static ResourceConfig<VirtualMachine> CreateVirtualMachineConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup,
+            string name,
+            ResourceConfig<NetworkInterface> networkInterface,
+            string adminUsername,
+            string adminPassword)
+            => Strategy.CreateConfig(
+                resourceGroup,
+                name, 
+                subscription => new VirtualMachine
+                {
+                    OsProfile = new OSProfile
+                    {
+                        ComputerName = name,
+                        WindowsConfiguration = new WindowsConfiguration
+                        {
+                        },
+                        AdminUsername = adminUsername,
+                        AdminPassword = adminPassword,
+                    },
+                    NetworkProfile = new NetworkProfile
+                    {
+                        NetworkInterfaces = new[]
+                        {
+                            new NetworkInterfaceReference
+                            {
+                                Id = networkInterface.GetId(subscription).IdToString()
+                            }
+                        }
+                    },
+                    HardwareProfile = new HardwareProfile
+                    {
+                        VmSize = "Standard_DS1_v2"
+                    },
+                    StorageProfile = new StorageProfile
+                    {
+                        ImageReference = new ImageReference
+                        {
+                            Publisher = "MicrosoftWindowsServer",
+                            Offer = "WindowsServer",
+                            Sku = "2016-Datacenter",
+                            Version = "latest"
+                        }
+                    },
+                },
+                new[] { networkInterface });
+    }
+}

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

@@ -30,7 +30,7 @@ public override async Task<object> Visit<Model>(ResourceConfig<Model> config)
                 }
                 var tasks = config.Dependencies.Select(GetOrAddUntyped);
                 await Task.WhenAll(tasks);
-                return await config.Policy.CreateOrUpdateAsync(CreateOrUpdateAsyncParams.Create(
+                return await config.Strategy.CreateOrUpdateAsync(CreateOrUpdateAsyncParams.Create(
                     Client,
                     config.ResourceGroupName,
                     config.Name,

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

@@ -26,7 +26,7 @@ public override async Task<object> Visit<Model>(ResourceConfig<Model> config)
                 Model info;
                 try
                 {
-                    info = await config.Policy.GetAsync(GetAsyncParams.Create(
+                    info = await config.Strategy.GetAsync(GetAsyncParams.Create(
                         Client, config.ResourceGroupName, config.Name, CancellationToken));
                 }
                 catch (CloudException e) when (e.Response.StatusCode == HttpStatusCode.NotFound)

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

@@ -22,7 +22,7 @@ public NestedResourceStrategy(
         }
     }
 
-    public static class NestedResourceStraegy
+    public static class NestedResourceStrategy
     {
         public static NestedResourceStrategy<Model, ParentModel> Create<Model, ParentModel>(
             string header,

src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkInterfaceStrategy.cs

@@ -0,0 +1,48 @@
+using Microsoft.Azure.Management.Network;
+using Microsoft.Azure.Management.Network.Models;
+using Microsoft.Azure.Management.ResourceManager.Models;
+
+namespace Microsoft.Azure.Commands.Common.Strategies.Network
+{
+    public static class NetworkInterfaceStrategy
+    {
+        public static ResourceStrategy<NetworkInterface> Strategy { get; }
+            = NetworkStrategy.Create(
+                "networkInterfaces",
+                client => client.NetworkInterfaces,
+                p => p.Operations.GetAsync(
+                    p.ResourceGroupName, p.Name, null, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(
+                    p.ResourceGroupName, p.Name, p.Model, p.CancellationToken));
+
+        public static ResourceConfig<NetworkInterface> CreateNetworkInterfaceConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup,
+            string name,
+            NestedResourceConfig<Subnet, VirtualNetwork> subnet,
+            ResourceConfig<PublicIPAddress> publicIPAddress,
+            ResourceConfig<NetworkSecurityGroup> networkSecurityGroup)
+            => Strategy.CreateConfig(
+                resourceGroup,
+                name,
+                subscription => new NetworkInterface
+                {
+                    IpConfigurations = new []
+                    {
+                        new NetworkInterfaceIPConfiguration
+                        {
+                            Name = name,
+                            Subnet = new Subnet { Id = subnet.GetId(subscription).IdToString() },
+                            PublicIPAddress = new PublicIPAddress
+                            {
+                                Id = publicIPAddress.GetId(subscription).IdToString()
+                            }
+                        }
+                    },
+                    NetworkSecurityGroup = new NetworkSecurityGroup
+                    {
+                        Id = networkSecurityGroup.GetId(subscription).IdToString()
+                    }
+                },
+                new IResourceConfig[] { subnet, publicIPAddress, networkSecurityGroup });
+    }
+}

src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkSecurityGroupPolicy.cs

@@ -0,0 +1,22 @@
+using Microsoft.Azure.Management.Network;
+using Microsoft.Azure.Management.Network.Models;
+using Microsoft.Azure.Management.ResourceManager.Models;
+
+namespace Microsoft.Azure.Commands.Common.Strategies.Network
+{
+    public static class NetworkSecurityGroupStrategy
+    {
+        public static ResourceStrategy<NetworkSecurityGroup> Strategy { get; }
+            = NetworkStrategy.Create(
+                "networkSecurityGroups",
+                client => client.NetworkSecurityGroups,
+                p => p.Operations.GetAsync(
+                    p.ResourceGroupName, p.Name, null, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(
+                    p.ResourceGroupName, p.Name, p.Model, p.CancellationToken));
+
+        public static ResourceConfig<NetworkSecurityGroup> CreateNetworkSecurityGroupConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
+            => Strategy.CreateConfig(resourceGroup, name);
+    }
+}

src/ResourceManager/Common/Commands.Common.Strategies/Network/NetworkStrategy.cs

@@ -0,0 +1,24 @@
+using Microsoft.Azure.Management.Network;
+using Microsoft.Azure.Management.Network.Models;
+using System;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Commands.Common.Strategies.Network
+{
+    public static class NetworkStrategy
+    {
+        public static ResourceStrategy<Model> Create<Model, Operations>(
+            string header,
+            Func<INetworkManagementClient, Operations> getOperations,
+            Func<GetAsyncParams<Operations>, Task<Model>> getAsync,
+            Func<CreateOrUpdateAsyncParams<Operations, Model>, Task<Model>> createOrUpdateAsync)
+            where Model : Resource
+            => ResourceStrategy.Create(
+                new [] { "Microsoft.Network", header },
+                getOperations,
+                getAsync,
+                createOrUpdateAsync, 
+                model => model.Location, 
+                (model, location) => model.Location = location);
+    }
+}

src/ResourceManager/Common/Commands.Common.Strategies/Network/PublicIPAddressStrategy.cs

@@ -0,0 +1,22 @@
+using Microsoft.Azure.Management.Network;
+using Microsoft.Azure.Management.Network.Models;
+using Microsoft.Azure.Management.ResourceManager.Models;
+
+namespace Microsoft.Azure.Commands.Common.Strategies.Network
+{
+    public static class PublicIPAddressStrategy
+    {
+        public static ResourceStrategy<PublicIPAddress> Strategy { get; }
+            = NetworkStrategy.Create(
+                "publicIPAddresses",
+                client => client.PublicIPAddresses,
+                p => p.Operations.GetAsync(
+                    p.ResourceGroupName, p.Name, null, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(
+                    p.ResourceGroupName, p.Name, p.Model, p.CancellationToken));
+
+        public static ResourceConfig<PublicIPAddress> CreatePublicIPAddressConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
+            => Strategy.CreateConfig(resourceGroup, name);
+    }
+}