protected void EnsureClientsInitialized(bool useSPN = false)
 {
     if (!m_initialized)
     {
         lock (m_lock)
         {
             if (!m_initialized)
             {
                 var handler = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
                 if (useSPN)
                 {
                     m_ResourcesClient = ComputeManagementTestUtilities.GetResourceManagementClientWithSpn(handler);
                     m_CrpClient = ComputeManagementTestUtilities.GetComputeManagementClientWithSpn(handler);
                     m_SrpClient = ComputeManagementTestUtilities.GetStorageManagementClientSpn(handler);
                     m_NrpClient = ComputeManagementTestUtilities.GetNetworkResourceProviderClientSpn(handler);
                 }
                 else
                 {
                     m_ResourcesClient = ComputeManagementTestUtilities.GetResourceManagementClient(handler);
                     m_CrpClient = ComputeManagementTestUtilities.GetComputeManagementClient(handler);
                     m_SrpClient = ComputeManagementTestUtilities.GetStorageManagementClient(handler);
                     m_NrpClient = ComputeManagementTestUtilities.GetNetworkResourceProviderClient(handler);
                 }
                 m_subId = m_CrpClient.Credentials.SubscriptionId;
                 m_location = ComputeManagementTestUtilities.DefaultLocation;
             }
         }
     }
 }
        public static PublicIpAddress CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location,
                                                                   NetworkResourceProviderClient nrpClient)
        {
            var publicIp = new PublicIpAddress()
            {
                Location = location,
                Tags     = new Dictionary <string, string>()
                {
                    { "key", "value" }
                },
                PublicIpAllocationMethod = IpAllocationMethod.Dynamic,
                DnsSettings = new PublicIpAddressDnsSettings()
                {
                    DomainNameLabel = domainNameLabel
                }
            };

            // Put nic1PublicIpAddress
            var putPublicIpAddressResponse = nrpClient.PublicIpAddresses.CreateOrUpdate(resourceGroupName, name, publicIp);

            Assert.Equal(HttpStatusCode.OK, putPublicIpAddressResponse.StatusCode);
            Assert.Equal("Succeeded", putPublicIpAddressResponse.Status);
            var getPublicIpAddressResponse = nrpClient.PublicIpAddresses.Get(resourceGroupName, name);

            return(getPublicIpAddressResponse.PublicIpAddress);
        }
        public static PublicIpAddress CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location,
            NetworkResourceProviderClient nrpClient)
        {
            var publicIp = new PublicIpAddress()
            {
                Location = location,
                Tags = new Dictionary<string, string>()
                    {
                       {"key","value"}
                    },
                PublicIpAllocationMethod = IpAllocationMethod.Dynamic,
                DnsSettings = new PublicIpAddressDnsSettings()
                {
                    DomainNameLabel = domainNameLabel
                }
            };

            // Put nic1PublicIpAddress
            var putPublicIpAddressResponse = nrpClient.PublicIpAddresses.CreateOrUpdate(resourceGroupName, name, publicIp);
            Assert.Equal(HttpStatusCode.OK, putPublicIpAddressResponse.StatusCode);
            Assert.Equal("Succeeded", putPublicIpAddressResponse.Status);
            var getPublicIpAddressResponse = nrpClient.PublicIpAddresses.Get(resourceGroupName, name);

            return getPublicIpAddressResponse.PublicIpAddress;
        }
 protected void EnsureClientsInitialized(bool useSPN = false)
 {
     if (!m_initialized)
     {
         lock (m_lock)
         {
             if (!m_initialized)
             {
                 var handler = new RecordedDelegatingHandler {
                     StatusCodeToReturn = HttpStatusCode.OK
                 };
                 if (useSPN)
                 {
                     m_ResourcesClient = ComputeManagementTestUtilities.GetResourceManagementClientWithSpn(handler);
                     m_CrpClient       = ComputeManagementTestUtilities.GetComputeManagementClientWithSpn(handler);
                     m_SrpClient       = ComputeManagementTestUtilities.GetStorageManagementClientSpn(handler);
                     m_NrpClient       = ComputeManagementTestUtilities.GetNetworkResourceProviderClientSpn(handler);
                 }
                 else
                 {
                     m_ResourcesClient = ComputeManagementTestUtilities.GetResourceManagementClient(handler);
                     m_CrpClient       = ComputeManagementTestUtilities.GetComputeManagementClient(handler);
                     m_SrpClient       = ComputeManagementTestUtilities.GetStorageManagementClient(handler);
                     m_NrpClient       = ComputeManagementTestUtilities.GetNetworkResourceProviderClient(handler);
                 }
                 m_subId    = m_CrpClient.Credentials.SubscriptionId;
                 m_location = ComputeManagementTestUtilities.DefaultLocation;
             }
         }
     }
 }
        public static NetworkInterface CreateNetworkInterface(
            string name,
            string resourceGroupName,
            string publicIpAddressId,
            string subnetId,
            string location,
            string ipConfigName,
            NetworkResourceProviderClient client)
        {
            var nicParameters = new NetworkInterface()
            {
                Location = location,
                Name     = name,
                Tags     = new Dictionary <string, string>()
                {
                    { "key", "value" }
                },
                IpConfigurations = new List <NetworkInterfaceIpConfiguration>()
                {
                    new NetworkInterfaceIpConfiguration()
                    {
                        Name = ipConfigName,
                        PrivateIpAllocationMethod = IpAllocationMethod.Dynamic,

                        Subnet = new ResourceId()
                        {
                            Id = subnetId
                        }
                    }
                }
            };

            if (!string.IsNullOrEmpty(publicIpAddressId))
            {
                nicParameters.IpConfigurations[0].PublicIpAddress = new ResourceId()
                {
                    Id = publicIpAddressId
                };
            }

            // Test NIC apis
            var putNicResponse = client.NetworkInterfaces.CreateOrUpdate(resourceGroupName, name, nicParameters);

            Assert.Equal(HttpStatusCode.OK, putNicResponse.StatusCode);

            var getNicResponse = client.NetworkInterfaces.Get(resourceGroupName, name);

            Assert.Equal(getNicResponse.NetworkInterface.Name, name);
            Assert.Equal(getNicResponse.NetworkInterface.ProvisioningState, Microsoft.Azure.Management.Resources.Models.ProvisioningState.Succeeded);

            return(getNicResponse.NetworkInterface);
        }
        public static NetworkInterface CreateNetworkInterface(
            string name,
            string resourceGroupName,
            string publicIpAddressId,
            string subnetId,
            string location,
            string ipConfigName,
            NetworkResourceProviderClient client)
        {
            var nicParameters = new NetworkInterface()
            {
                Location = location,
                Name = name,
                Tags = new Dictionary<string, string>()
                        {
                           {"key","value"}
                        },
                IpConfigurations = new List<NetworkInterfaceIpConfiguration>()
                {
                    new NetworkInterfaceIpConfiguration()
                    {
                         Name = ipConfigName,
                         PrivateIpAllocationMethod = IpAllocationMethod.Dynamic,
                         
                         Subnet = new ResourceId()
                         {
                             Id = subnetId
                         }
                    }
                }
            };

            if (!string.IsNullOrEmpty(publicIpAddressId))
            {
                nicParameters.IpConfigurations[0].PublicIpAddress = new ResourceId() { Id = publicIpAddressId };
            }

            // Test NIC apis
            var putNicResponse = client.NetworkInterfaces.CreateOrUpdate(resourceGroupName, name, nicParameters);
            Assert.Equal(HttpStatusCode.OK, putNicResponse.StatusCode);

            var getNicResponse = client.NetworkInterfaces.Get(resourceGroupName, name);
            Assert.Equal(getNicResponse.NetworkInterface.Name, name);
            Assert.Equal(getNicResponse.NetworkInterface.ProvisioningState, Microsoft.Azure.Management.Resources.Models.ProvisioningState.Succeeded);

            return getNicResponse.NetworkInterface;
        }
        public static VirtualNetwork CreateVirtualNetwork(string vnetName, string subnetName, string resourceGroupName, string location, NetworkResourceProviderClient client)
        {
            var vnet = new VirtualNetwork()
            {
                Location = location,

                AddressSpace = new AddressSpace()
                    {
                        AddressPrefixes = new List<string>()
                        {
                            "10.0.0.0/16",
                        }
                    },
                    DhcpOptions = new DhcpOptions()
                    {
                        DnsServers = new List<string>()
                        {
                            "10.1.1.1",
                            "10.1.2.4"
                        }
                    },
                    Subnets = new List<Subnet>()
                        {
                            new Subnet()
                            {
                                Name = subnetName,
                                AddressPrefix = "10.0.0.0/24",
                            }
                        }
            };

            var putVnetResponse = client.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet);
            Assert.Equal(HttpStatusCode.OK, putVnetResponse.StatusCode);
            var getVnetResponse = client.VirtualNetworks.Get(resourceGroupName, vnetName);

            return getVnetResponse.VirtualNetwork;
        }
        public void ApplicationGatewayApiTest()
        {
            var handler = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };            

            using (var context = UndoContext.Current)
            {
                context.Start();

                var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(handler);
                networkResourceProviderClient = NetworkManagementTestUtilities.GetNetworkResourceProviderClient(handler);
                
                location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/applicationgateways");

                resourceGroupName = TestUtilities.GenerateName("csmrg");
                resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
                    new ResourceGroup
                    {
                        Location = location
                    });

                Init();
                
                var appGw = CreateApplicationGatewayWithSsl();

                // Put AppGw
                var putAppGwResponse = networkResourceProviderClient.ApplicationGateways.CreateOrUpdate(resourceGroupName, appGw.Name, appGw);                
                Assert.Equal(HttpStatusCode.OK, putAppGwResponse.StatusCode);
                Assert.Equal("Succeeded", putAppGwResponse.Status);
                
                // Get AppGw
                var getResp = networkResourceProviderClient.ApplicationGateways.Get(resourceGroupName, appGw.Name);
                CompareApplicationGateway(appGw, getResp.ApplicationGateway);

                // List AppGw
                var listAppGw = networkResourceProviderClient.ApplicationGateways.List(resourceGroupName);
                Assert.Equal(1, listAppGw.ApplicationGateways.Count);

                // List all AppGw
                var listAllAppGw = networkResourceProviderClient.ApplicationGateways.ListAll();
                Assert.Equal(1, listAllAppGw.ApplicationGateways.Count);

                //Add one more gateway
                // Put AppGw
                var appGw2 = CreateApplicationGateway();
                putAppGwResponse = networkResourceProviderClient.ApplicationGateways.CreateOrUpdate(resourceGroupName, appGw2.Name, appGw2);
                Assert.Equal(HttpStatusCode.OK, putAppGwResponse.StatusCode);
                Assert.Equal("Succeeded", putAppGwResponse.Status);

                // Get AppGw
                getResp = networkResourceProviderClient.ApplicationGateways.Get(resourceGroupName, appGw2.Name);
                CompareApplicationGateway(appGw2, getResp.ApplicationGateway);

                // List AppGw
                listAppGw = networkResourceProviderClient.ApplicationGateways.List(resourceGroupName);
                Assert.Equal(2, listAppGw.ApplicationGateways.Count);

                // List all AppGw
                listAllAppGw = networkResourceProviderClient.ApplicationGateways.ListAll();
                Assert.Equal(2, listAllAppGw.ApplicationGateways.Count);

                //Start AppGw
                var startResult = networkResourceProviderClient.ApplicationGateways.Start(resourceGroupName, appGw.Name);
                Assert.Equal(HttpStatusCode.OK, startResult.StatusCode);
                Assert.Equal("Succeeded", startResult.Status);

                startResult = networkResourceProviderClient.ApplicationGateways.Start(resourceGroupName, appGw2.Name);
                Assert.Equal(HttpStatusCode.OK, startResult.StatusCode);
                Assert.Equal("Succeeded", startResult.Status);
                
                //Stop AppGw
                var stopResult = networkResourceProviderClient.ApplicationGateways.Stop(resourceGroupName, appGw.Name);
                Assert.Equal(HttpStatusCode.OK, stopResult.StatusCode);
                Assert.Equal("Succeeded", stopResult.Status);

                stopResult = networkResourceProviderClient.ApplicationGateways.Stop(resourceGroupName, appGw2.Name);
                Assert.Equal(HttpStatusCode.OK, stopResult.StatusCode);
                Assert.Equal("Succeeded", stopResult.Status);
                
                // Delete AppGw
                var deleteResult = networkResourceProviderClient.ApplicationGateways.Delete(resourceGroupName, appGw.Name);
                Assert.Equal(HttpStatusCode.OK, deleteResult.StatusCode);

                deleteResult = networkResourceProviderClient.ApplicationGateways.Delete(resourceGroupName, appGw2.Name);
                Assert.Equal(HttpStatusCode.OK, deleteResult.StatusCode);

                // Verify Delete
                listAppGw = networkResourceProviderClient.ApplicationGateways.List(resourceGroupName);
                Assert.Equal(0, listAppGw.ApplicationGateways.Count);
            }
        }        
        public static VirtualNetwork CreateVirtualNetwork(string vnetName, string subnetName, string resourceGroupName, string location, NetworkResourceProviderClient client)
        {
            var vnet = new VirtualNetwork()
            {
                Location = location,

                AddressSpace = new AddressSpace()
                {
                    AddressPrefixes = new List <string>()
                    {
                        "10.0.0.0/16",
                    }
                },
                DhcpOptions = new DhcpOptions()
                {
                    DnsServers = new List <string>()
                    {
                        "10.1.1.1",
                        "10.1.2.4"
                    }
                },
                Subnets = new List <Subnet>()
                {
                    new Subnet()
                    {
                        Name          = subnetName,
                        AddressPrefix = "10.0.0.0/24",
                    }
                }
            };

            var putVnetResponse = client.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet);

            Assert.Equal(HttpStatusCode.OK, putVnetResponse.StatusCode);
            var getVnetResponse = client.VirtualNetworks.Get(resourceGroupName, vnetName);

            return(getVnetResponse.VirtualNetwork);
        }
        public void ApplicationGatewayApiTest()
        {
            var handler = new RecordedDelegatingHandler {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            using (var context = UndoContext.Current)
            {
                context.Start();

                var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(handler);
                networkResourceProviderClient = NetworkManagementTestUtilities.GetNetworkResourceProviderClient(handler);

                location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/applicationgateways");

                resourceGroupName = TestUtilities.GenerateName("csmrg");
                resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
                                                              new ResourceGroup
                {
                    Location = location
                });

                Init();

                var appGw = CreateApplicationGatewayWithSsl();

                // Put AppGw
                var putAppGwResponse = networkResourceProviderClient.ApplicationGateways.CreateOrUpdate(resourceGroupName, appGw.Name, appGw);
                Assert.Equal(HttpStatusCode.OK, putAppGwResponse.StatusCode);
                Assert.Equal("Succeeded", putAppGwResponse.Status);

                // Get AppGw
                var getResp = networkResourceProviderClient.ApplicationGateways.Get(resourceGroupName, appGw.Name);
                CompareApplicationGateway(appGw, getResp.ApplicationGateway);

                // List AppGw
                var listAppGw = networkResourceProviderClient.ApplicationGateways.List(resourceGroupName);
                Assert.Equal(1, listAppGw.ApplicationGateways.Count);

                // List all AppGw
                var listAllAppGw = networkResourceProviderClient.ApplicationGateways.ListAll();
                Assert.Equal(1, listAllAppGw.ApplicationGateways.Count);

                //Add one more gateway
                // Put AppGw
                var appGw2 = CreateApplicationGateway();
                putAppGwResponse = networkResourceProviderClient.ApplicationGateways.CreateOrUpdate(resourceGroupName, appGw2.Name, appGw2);
                Assert.Equal(HttpStatusCode.OK, putAppGwResponse.StatusCode);
                Assert.Equal("Succeeded", putAppGwResponse.Status);

                // Get AppGw
                getResp = networkResourceProviderClient.ApplicationGateways.Get(resourceGroupName, appGw2.Name);
                CompareApplicationGateway(appGw2, getResp.ApplicationGateway);

                // List AppGw
                listAppGw = networkResourceProviderClient.ApplicationGateways.List(resourceGroupName);
                Assert.Equal(2, listAppGw.ApplicationGateways.Count);

                // List all AppGw
                listAllAppGw = networkResourceProviderClient.ApplicationGateways.ListAll();
                Assert.Equal(2, listAllAppGw.ApplicationGateways.Count);

                //Start AppGw
                var startResult = networkResourceProviderClient.ApplicationGateways.Start(resourceGroupName, appGw.Name);
                Assert.Equal(HttpStatusCode.OK, startResult.StatusCode);
                Assert.Equal("Succeeded", startResult.Status);

                startResult = networkResourceProviderClient.ApplicationGateways.Start(resourceGroupName, appGw2.Name);
                Assert.Equal(HttpStatusCode.OK, startResult.StatusCode);
                Assert.Equal("Succeeded", startResult.Status);

                //Stop AppGw
                var stopResult = networkResourceProviderClient.ApplicationGateways.Stop(resourceGroupName, appGw.Name);
                Assert.Equal(HttpStatusCode.OK, stopResult.StatusCode);
                Assert.Equal("Succeeded", stopResult.Status);

                stopResult = networkResourceProviderClient.ApplicationGateways.Stop(resourceGroupName, appGw2.Name);
                Assert.Equal(HttpStatusCode.OK, stopResult.StatusCode);
                Assert.Equal("Succeeded", stopResult.Status);

                // Delete AppGw
                var deleteResult = networkResourceProviderClient.ApplicationGateways.Delete(resourceGroupName, appGw.Name);
                Assert.Equal(HttpStatusCode.OK, deleteResult.StatusCode);

                deleteResult = networkResourceProviderClient.ApplicationGateways.Delete(resourceGroupName, appGw2.Name);
                Assert.Equal(HttpStatusCode.OK, deleteResult.StatusCode);

                // Verify Delete
                listAppGw = networkResourceProviderClient.ApplicationGateways.List(resourceGroupName);
                Assert.Equal(0, listAppGw.ApplicationGateways.Count);
            }
        }
Beispiel #11
0
        public string AddPublicIp(string publicIpName)
        {
            azureLogin.Authenticate();
            using (var networkClient = new NetworkResourceProviderClient(azureLogin.Credentials))
            {
                var nicName = publicIpName + "_nic";

                var pia = new PublicIpAddress()
                {
                    Location = demo.Location,
                    PublicIpAllocationMethod = "Dynamic",
                };
                HandleResult("Create Public IP", () => networkClient.PublicIpAddresses.CreateOrUpdate(demo.Group, publicIpName, pia));

                var ni = new NetworkInterface()
                {
                    Name = nicName,
                    Location = demo.Location,
                    IpConfigurations = new List<NetworkInterfaceIpConfiguration>()
                    {
                        new NetworkInterfaceIpConfiguration()
                        {
                            Name = nicName + "config",
                            PublicIpAddress = GetPublicIpId(publicIpName),
                            Subnet = GetSubnetId(demo.Network),
                        }
                    }
                };
                HandleResult("Create Network Interface", () => networkClient.NetworkInterfaces.CreateOrUpdate(demo.Group, nicName, ni));
            }
            return publicIpName;
        }
Beispiel #12
0
        public void CreateVirtualNetwork(string ruleName, string[] sourceAddresses, int[] destPorts)
        {
            azureLogin.Authenticate();
            using (var networkClient = new NetworkResourceProviderClient(azureLogin.Credentials))
            {
                var subnetName = demo.Network + "_sub";
                var netSecName = demo.Network + "_sec";

                var nsg = new NetworkSecurityGroup()
                {
                    Name = netSecName,
                    Location = demo.Location,
                    SecurityRules = new List<SecurityRule>(),
                };
                
                var prio = 0;
                foreach (var sourceAddress in sourceAddresses)
                {
                    foreach (var destPort in destPorts)
                    {
                        prio += 100;
                        nsg.SecurityRules.Add(new SecurityRule()
                        {
                            Name = ruleName + "_" + destPort + "_" + sourceAddress,
                            Access = "Allow",
                            Direction = "Inbound",
                            Protocol = "Tcp",
                            SourceAddressPrefix = sourceAddress,
                            SourcePortRange = "*",
                            DestinationAddressPrefix = "*",
                            DestinationPortRange = destPort > 0 ? destPort.ToString() : "*",
                            Priority = prio,
                        });
                    }
                }

                HandleResult("Create Network Security Group", 
                    () => networkClient.NetworkSecurityGroups.CreateOrUpdate(demo.Group, netSecName, nsg));

                var vn = new VirtualNetwork()
                {
                    Location = demo.Location,
                    AddressSpace = new AddressSpace()
                    {
                        AddressPrefixes = new List<string> { demo.AddressSpace },
                    },
                    Subnets = new List<Subnet>()
                    {
                        new Subnet()
                        {
                            Name = subnetName,
                            AddressPrefix = demo.AddressSpace,
                            NetworkSecurityGroup = GetNetwokSecurityGroupId(demo.Network),
                        }
                    },
                };
                HandleResult("Create Virtual Network", 
                    () => networkClient.VirtualNetworks.CreateOrUpdate(demo.Group, demo.Network, vn));
            }
        }