State

sergey-shandar · sergey-shandar · commit b18f0d155b7f · 2017-11-13T13:33:33.000-08:00
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Compute/ComputePolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Compute/ComputePolicy.cs
@@ -8,10 +8,10 @@ namespace Microsoft.Azure.Experiments.Compute
 {
     public static class ComputePolicy
     {
-        public static ResourcePolicy<ResourceName, Config> Create<Config, Operations>(
+        public static ResourcePolicy<Config> Create<Config, Operations>(
             Func<IComputeManagementClient, Operations> getOperations,
-            Func<Operations, ResourceName, CancellationToken, Task<Config>> getAsync,
-            Func<Operations, ResourceName, Config, CancellationToken, Task<Config>> createOrUpdateAsync)
+            Func<GetAsyncParams<Operations>, Task<Config>> getAsync,
+            Func<CreateOrUpdateAsyncParams<Operations, Config>, Task<Config>> createOrUpdateAsync)
             where Config : Resource
             => ResourcePolicy.Create(
                 getOperations,
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Compute/VirtualMachinePolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Compute/VirtualMachinePolicy.cs
@@ -6,18 +6,16 @@ namespace Microsoft.Azure.Experiments.Compute
 {
     public static class VirtualMachinePolicy
     {
-        public static ResourcePolicy<ResourceName, VirtualMachine> Policy { get; }
+        public static ResourcePolicy<VirtualMachine> Policy { get; }
             = ComputePolicy.Create(
                 client => client.VirtualMachines,
-                (operations, name, cancellationTokent)
-                    => operations.GetAsync(
-                        name.ResourceGroupName, name.Name, cancellationToken: cancellationTokent),
-                (operations, name, config, cancellationTokent)
-                    => operations.CreateOrUpdateAsync(
-                        name.ResourceGroupName, name.Name, config, cancellationTokent));
+                p => p.Operations.GetAsync(
+                    p.ResourceGroupName, p.Name, null, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(
+                    p.ResourceGroupName, p.Name, p.Config, p.CancellationToken));
 
-        public static ResourceConfig<ResourceName, VirtualMachine> CreateVirtualMachineConfig(
-            this ResourceConfig<string, ResourceGroup> resourceGroup, string name)
+        public static ResourceConfig<VirtualMachine> CreateVirtualMachineConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
             => Policy.CreateConfig(resourceGroup, name);
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/CreateOrUpdateAsyncParams.cs b/experiments/Azure.Experiments/Azure.Experiments/CreateOrUpdateAsyncParams.cs
@@ -2,6 +2,18 @@
 
 namespace Microsoft.Azure.Experiments
 {
+    public static class CreateOrUpdateAsyncParams
+    {
+        public static CreateOrUpdateAsyncParams<Operations, Config> Create<Operations, Config>(
+            Operations operations,
+            string resourceGroupName,
+            string name,
+            Config config,
+            CancellationToken cancellationToken)
+            => new CreateOrUpdateAsyncParams<Operations, Config>(
+                operations, resourceGroupName, name, config, cancellationToken);
+    }
+
     public sealed class CreateOrUpdateAsyncParams<TOperations, TConfig>
     {
         public TOperations Operations { get; }
@@ -16,13 +28,14 @@ public sealed class CreateOrUpdateAsyncParams<TOperations, TConfig>
 
         public CreateOrUpdateAsyncParams(
             TOperations operations,
-            ResourceName name,
+            string resourceGroupName,
+            string name,
             TConfig config,
             CancellationToken cancellationToken)
         {
             Operations = operations;
-            ResourceGroupName = name.ResourceGroupName;
-            Name = name.Name;
+            ResourceGroupName = resourceGroupName;
+            Name = name;
             Config = config;
             CancellationToken = cancellationToken;
         }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/GetAsyncParams.cs b/experiments/Azure.Experiments/Azure.Experiments/GetAsyncParams.cs
@@ -2,7 +2,17 @@
 
 namespace Microsoft.Azure.Experiments
 {
-    public sealed class GetAsyncParams<TOperations>
+    public static class GetAsyncParams
+    {
+        public static GetAsyncParams<Operations> Create<Operations>(
+            Operations operations,
+            string resourceGroupName,
+            string name,
+            CancellationToken cancellationToken)
+            => new GetAsyncParams<Operations>(operations, resourceGroupName, name, cancellationToken);
+    }
+
+    public class GetAsyncParams<TOperations>
     {
         public TOperations Operations { get; }
 
@@ -13,11 +23,14 @@ public sealed class GetAsyncParams<TOperations>
         public CancellationToken CancellationToken { get; }
 
         public GetAsyncParams(
-            TOperations operations, ResourceName name, CancellationToken cancellationToken)
+            TOperations operations,
+            string resourceGroupName,
+            string name,
+            CancellationToken cancellationToken)
         {
             Operations = operations;
-            ResourceGroupName = name.ResourceGroupName;
-            Name = name.Name;
+            ResourceGroupName = resourceGroupName;
+            Name = name;
             CancellationToken = cancellationToken;
         }
     }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/IResourceConfig.cs b/experiments/Azure.Experiments/Azure.Experiments/IResourceConfig.cs
@@ -1,6 +1,21 @@
 ﻿namespace Microsoft.Azure.Experiments
 {
+    public interface IResourceConfigVisitor<Result>
+    {
+        Result Visit<Config>(ResourceConfig<Config> config)
+            where Config : class;
+        Result Visit<Config, ParentConfig>(NestedResourceConfig<Config, ParentConfig> config)
+            where Config : class
+            where ParentConfig : class;
+    }
+
     public interface IResourceConfig
-    {            
+    {
+        Result Apply<Result>(IResourceConfigVisitor<Result> visitor);
+    }
+
+    public interface IResourceConfig<Config> : IResourceConfig
+        where Config : class
+    {
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/IState.cs b/experiments/Azure.Experiments/Azure.Experiments/IState.cs
@@ -2,5 +2,7 @@
 {
     public interface IState
     {
+        Config Get<Config>(IResourceConfig<Config> config)
+            where Config : class;
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/NestedResourceConfig.cs b/experiments/Azure.Experiments/Azure.Experiments/NestedResourceConfig.cs
@@ -0,0 +1,21 @@
+﻿namespace Microsoft.Azure.Experiments
+{
+    public sealed class NestedResourceConfig<Config, ParentConfig> : IResourceConfig<Config>
+        where Config : class
+        where ParentConfig : class
+    {
+        public NestedResourcePolicy<Config, ParentConfig> Policy { get; }
+
+        public IResourceConfig<ParentConfig> Parent { get; }
+
+        public NestedResourceConfig(
+            NestedResourcePolicy<Config, ParentConfig> policy, IResourceConfig<ParentConfig> parent)
+        {
+            Policy = policy;
+            Parent = parent;
+        }
+
+        public Result Apply<Result>(IResourceConfigVisitor<Result> visitor)
+            => visitor.Visit(this);
+    }
+}
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Network/NetworkInterfacePolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Network/NetworkInterfacePolicy.cs
@@ -0,0 +1,21 @@
+﻿using Microsoft.Azure.Management.Network;
+using Microsoft.Azure.Management.Network.Models;
+using Microsoft.Azure.Management.ResourceManager.Models;
+
+namespace Microsoft.Azure.Experiments.Network
+{
+    public static class NetworkInterfacePolicy
+    {
+        public static ResourcePolicy<NetworkInterface> Policy { get; }
+            = NetworkPolicy.Create(
+                client => client.NetworkInterfaces,
+                p => p.Operations.GetAsync(
+                    p.ResourceGroupName, p.Name, null, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(
+                    p.ResourceGroupName, p.Name, p.Config, p.CancellationToken));
+
+        public static ResourceConfig<NetworkInterface> CreateNetworkSecurityGroupConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
+            => Policy.CreateConfig(resourceGroup, name);
+    }
+}
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Network/NetworkPolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Network/NetworkPolicy.cs
@@ -1,14 +1,13 @@
 ﻿using Microsoft.Azure.Management.Network;
 using Microsoft.Azure.Management.Network.Models;
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.Azure.Experiments.Network
 {
     public static class NetworkPolicy
     {
-        public static ResourcePolicy<ResourceName, Config> Create<Config, Operations>(
+        public static ResourcePolicy<Config> Create<Config, Operations>(
             Func<INetworkManagementClient, Operations> getOperations,
             Func<GetAsyncParams<Operations>, Task<Config>> getAsync,
             Func<CreateOrUpdateAsyncParams<Operations, Config>, Task<Config>> createOrUpdateAsync)
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Network/NetworkSecurityGroupPolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Network/NetworkSecurityGroupPolicy.cs
@@ -6,16 +6,16 @@ namespace Microsoft.Azure.Experiments.Network
 {
     public static class NetworkSecurityGroupPolicy
     {
-        public static ResourcePolicy<ResourceName, NetworkSecurityGroup> Policy { get; }
+        public static ResourcePolicy<NetworkSecurityGroup> Policy { get; }
             = NetworkPolicy.Create(
                 client => client.NetworkSecurityGroups,
                 p => p.Operations.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
                 p => p.Operations.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Config, p.CancellationToken));
 
-        public static ResourceConfig<ResourceName, NetworkSecurityGroup> CreateNetworkSecurityGroupConfig(
-            this ResourceConfig<string, ResourceGroup> resourceGroup, string name)
+        public static ResourceConfig<NetworkSecurityGroup> CreateNetworkSecurityGroupConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
             => Policy.CreateConfig(resourceGroup, name);
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Network/PublicIPAddressPolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Network/PublicIPAddressPolicy.cs
@@ -6,16 +6,16 @@ namespace Microsoft.Azure.Experiments.Network
 {
     public static class PublicIPAddressPolicy
     {
-        public static ResourcePolicy<ResourceName, PublicIPAddress> Policy { get; }
+        public static ResourcePolicy<PublicIPAddress> Policy { get; }
             = NetworkPolicy.Create(
                 client => client.PublicIPAddresses,
                 p => p.Operations.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
                 p => p.Operations.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Config, p.CancellationToken));
 
-        public static ResourceConfig<ResourceName, PublicIPAddress> CreatePublicIPAddressConfig(
-            this ResourceConfig<string, ResourceGroup> resourceGroup, string name)
+        public static ResourceConfig<PublicIPAddress> CreatePublicIPAddressConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
             => Policy.CreateConfig(resourceGroup, name);
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/Network/VirtualNetworkPolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/Network/VirtualNetworkPolicy.cs
@@ -6,16 +6,16 @@ namespace Microsoft.Azure.Experiments.Network
 {
     public static class VirtualNetworkPolicy
     {
-        public static ResourcePolicy<ResourceName, VirtualNetwork> Policy { get; }
+        public static ResourcePolicy<VirtualNetwork> Policy { get; }
             = NetworkPolicy.Create(
                 client => client.VirtualNetworks,
                 p => p.Operations.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
                 p => p.Operations.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Config, p.CancellationToken));
 
-        public static ResourceConfig<ResourceName, VirtualNetwork> CreateVirtualNetworkConfig(
-            this ResourceConfig<string, ResourceGroup> resourceGroup, string name)
+        public static ResourceConfig<VirtualNetwork> CreateVirtualNetworkConfig(
+            this ResourceConfig<ResourceGroup> resourceGroup, string name)
             => Policy.CreateConfig(resourceGroup, name);
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/ResourceConfig.cs b/experiments/Azure.Experiments/Azure.Experiments/ResourceConfig.cs
@@ -5,52 +5,63 @@
 
 namespace Microsoft.Azure.Experiments
 {
-    public class ResourceConfig<TName, Config> : IResourceConfig
+    public sealed class ResourceConfig<Config> : IResourceConfig<Config>
+        where Config : class
     {
-        public ResourcePolicy<TName, Config> Policy { get; }
+        public ResourcePolicy<Config> Policy { get; }
 
-        public TName Name { get; }
+        public string ResourceGroupName { get; }
+
+        public string Name { get; }
 
         public Func<IState, Config> CreateConfig { get; }
 
         public IEnumerable<IResourceConfig> Dependencies { get; }
 
         public ResourceConfig(
-            ResourcePolicy<TName, Config> policy,
-            TName name,
+            ResourcePolicy<Config> policy,
+            string resourceGroupName,
+            string name,
             Func<IState, Config> createConfig,
             IEnumerable<IResourceConfig> dependencies)
         {
             Policy = policy;
+            ResourceGroupName = resourceGroupName;
             Name = name;
             CreateConfig = createConfig;
             Dependencies = dependencies;
         }
+
+        public Result Apply<Result>(IResourceConfigVisitor<Result> visitor)
+            => visitor.Visit(this);
     }
 
     public static class ResourceConfig
     {
-        public static ResourceConfig<Name, Config> CreateConfig<Name, Config>(
-            this ResourcePolicy<Name, Config> policy,
-            Name name,
+        public static ResourceConfig<Config> CreateConfig<Config>(
+            this ResourcePolicy<Config> policy,
+            string resourceGroupName,
+            string name,
             Func<IState, Config> createConfig = null,
             IEnumerable<IResourceConfig> dependencies = null)
-            where Config : new()
-            => new ResourceConfig<Name, Config>(
+            where Config : class, new()
+            => new ResourceConfig<Config>(
                 policy,
+                resourceGroupName,
                 name,
                 createConfig ?? (_ => new Config()),
                 dependencies.EmptyIfNull());
 
-        public static ResourceConfig<ResourceName, Config> CreateConfig<Config>(
-            this ResourcePolicy<ResourceName, Config> policy,
-            ResourceConfig<string, ResourceGroup> resourceGroup,
+        public static ResourceConfig<Config> CreateConfig<Config>(
+            this ResourcePolicy<Config> policy,
+            ResourceConfig<ResourceGroup> resourceGroup,
             string name,
             Func<IState, Config> createConfig = null,
             IEnumerable<IResourceConfig> dependencies = null)
-            where Config : new()
+            where Config : class, new()
             => policy.CreateConfig(
-                new ResourceName(resourceGroup.Name, name),
+                resourceGroup.Name, 
+                name,
                 createConfig,
                 dependencies.EmptyIfNull().Concat(new[] { resourceGroup }));
     }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/ResourceManager/ResourceGroupPolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/ResourceManager/ResourceGroupPolicy.cs
@@ -5,18 +5,15 @@ namespace Microsoft.Azure.Experiments.ResourceManager
 {
     public static class ResourceGroupPolicy
     {
-        public static ResourcePolicy<string, ResourceGroup> Policy { get; }
-            = ResourcePolicy.Create<
-                string, ResourceGroup, IResourceManagementClient, IResourceGroupsOperations>(
+        public static ResourcePolicy<ResourceGroup> Policy { get; }
+            = ResourcePolicy.Create<ResourceGroup, IResourceManagementClient, IResourceGroupsOperations>(
                 client => client.ResourceGroups,
-                (operations, name, cancellationToken)
-                    => operations.GetAsync(name, cancellationToken),
-                (operations, name, config, cancellationToken)
-                    => operations.CreateOrUpdateAsync(name, config, cancellationToken),
+                p => p.Operations.GetAsync(p.Name, p.CancellationToken),
+                p => p.Operations.CreateOrUpdateAsync(p.Name, p.Config, p.CancellationToken),
                 config => config.Location,
                 (config, location) => config.Location = location);
 
-        public static ResourceConfig<string, ResourceGroup> CreateResourceGroupConfig(string name)
-            => Policy.CreateConfig(name);
+        public static ResourceConfig<ResourceGroup> CreateResourceGroupConfig(string name)
+            => Policy.CreateConfig(name, name);
     }
 }
diff --git a/experiments/Azure.Experiments/Azure.Experiments/ResourcePolicy.cs b/experiments/Azure.Experiments/Azure.Experiments/ResourcePolicy.cs
diff --git a/experiments/Azure.Experiments/Azure.Experiments/State.cs b/experiments/Azure.Experiments/Azure.Experiments/State.cs

Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ namespace Microsoft.Azure.Experiments.Compute`
`8`	`8`	`{`
`9`	`9`	`public static class ComputePolicy`
`10`	`10`	`{`
`11`		`- public static ResourcePolicy<ResourceName, Config> Create<Config, Operations>(`
	`11`	`+ public static ResourcePolicy<Config> Create<Config, Operations>(`
`12`	`12`	`Func<IComputeManagementClient, Operations> getOperations,`
`13`		`- Func<Operations, ResourceName, CancellationToken, Task<Config>> getAsync,`
`14`		`- Func<Operations, ResourceName, Config, CancellationToken, Task<Config>> createOrUpdateAsync)`
	`13`	`+ Func<GetAsyncParams<Operations>, Task<Config>> getAsync,`
	`14`	`+ Func<CreateOrUpdateAsyncParams<Operations, Config>, Task<Config>> createOrUpdateAsync)`
`15`	`15`	`where Config : Resource`
`16`	`16`	`=> ResourcePolicy.Create(`
`17`	`17`	`getOperations,`
Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,7 @@`
`2`	`2`	`{`
`3`	`3`	`public interface IState`
`4`	`4`	`{`
	`5`	`+ Config Get<Config>(IResourceConfig<Config> config)`
	`6`	`+ where Config : class;`
`5`	`7`	`}`
`6`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,16 +6,16 @@ namespace Microsoft.Azure.Experiments.Network`
`6`	`6`	`{`
`7`	`7`	`public static class NetworkSecurityGroupPolicy`
`8`	`8`	`{`
`9`		`- public static ResourcePolicy<ResourceName, NetworkSecurityGroup> Policy { get; }`
	`9`	`+ public static ResourcePolicy<NetworkSecurityGroup> Policy { get; }`
`10`	`10`	`= NetworkPolicy.Create(`
`11`	`11`	`client => client.NetworkSecurityGroups,`
`12`	`12`	`p => p.Operations.GetAsync(`
`13`	`13`	`p.ResourceGroupName, p.Name, null, p.CancellationToken),`
`14`	`14`	`p => p.Operations.CreateOrUpdateAsync(`
`15`	`15`	`p.ResourceGroupName, p.Name, p.Config, p.CancellationToken));`
`16`	`16`
`17`		`- public static ResourceConfig<ResourceName, NetworkSecurityGroup> CreateNetworkSecurityGroupConfig(`
`18`		`- this ResourceConfig<string, ResourceGroup> resourceGroup, string name)`
	`17`	`+ public static ResourceConfig<NetworkSecurityGroup> CreateNetworkSecurityGroupConfig(`
	`18`	`+ this ResourceConfig<ResourceGroup> resourceGroup, string name)`
`19`	`19`	`=> Policy.CreateConfig(resourceGroup, name);`
`20`	`20`	`}`
`21`	`21`	`}`