/// <summary> /// Provisions all the components in the <see cref="DevOpsFlexDbContext"/>. /// </summary> /// <param name="context">The database context that we want to provision components from.</param> /// <param name="subscriptionId">The subscription Id where we want to provision in.</param> /// <param name="settingsPath">The path to the settings file with the management certificate.</param> /// <returns>The async <see cref="Task"/> wrapper.</returns> public static Task[] ProvisionAll(this DevOpsFlexDbContext context, string subscriptionId, string settingsPath) { Contract.Requires(context != null); Contract.Requires(!string.IsNullOrEmpty(subscriptionId)); Contract.Requires(!string.IsNullOrEmpty(settingsPath)); var azureSubscription = new AzureSubscription(settingsPath, subscriptionId); var azureCert = new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate)); var computeClient = new ComputeManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)); var networkClient = new NetworkManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)); var sbClient = new ServiceBusManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)); var sqlClient = new SqlManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)); var storageClient = new StorageManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)); var webSiteClient = new WebSiteManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)); var foo = context.Components.Include(o => o.System).OfType <AzureCloudService>().ToList().ProvisionAllAsync(computeClient) .Concat(context.Components.Include(o => o.System).OfType <AzureCloudService>().ToList().ReserveAllIpsAsync(networkClient)) .Concat(context.Components.Include(o => o.System).OfType <AzureServiceBusNamespace>().ToList().ProvisionAllAsync(sbClient)) .Concat(context.Components.Include(o => o.System).OfType <SqlAzureDb>().ToList().ProvisionAllAsync(sqlClient)) .Concat(context.Components.Include(o => o.System).OfType <AzureStorageContainer>().ToList().ProvisionAllAsync(storageClient)) .Concat(context.Components.Include(o => o.System).OfType <AzureWebSite>().ToList().ProvisionAllAsync(webSiteClient)) .ToArray(); return(foo); }
protected void InitializeClients(MockContext context) { if (!m_initialized) { lock (m_lock) { if (!m_initialized) { _resourceManagementClient = EventHubManagementHelper.GetResourceManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); _EventHubManagementClient = EventHubManagementHelper.GetEventHubManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); _KeyVaultManagementClient = EventHubManagementHelper.GetKeyVaultManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); _NetworkManagementClient = EventHubManagementHelper.GetNetworkManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); _IdentityManagementClient = EventHubManagementHelper.GetIdentityManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); } } } }
public static VirtualNetwork CreateVirtualNetwork( string resourceGroupName, NetworkManagementClient networkClient) { var virtualNetworkName = TestUtilities.GenerateName("hydratestdnsvn"); var subnetName = TestUtilities.GenerateName("hydratestdnssubnet"); var vnet = new VirtualNetwork { AddressSpace = new AddressSpace { AddressPrefixes = new List <string> { "10.0.0.0/16" } }, Subnets = new List <Subnet> { new Subnet { Name = subnetName, AddressPrefix = "10.0." + RandomGenerator.Next(0, 255) + ".0/24" } }, Location = ResourceLocation }; var putVnetResponse = networkClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, virtualNetworkName, vnet); Assert.Equal("Succeeded", putVnetResponse.ProvisioningState); var getVnetResponse = networkClient.VirtualNetworks.Get(resourceGroupName, virtualNetworkName); return(getVnetResponse); }
public string GetPrivateIp(string nicName) { var retry = 5; var i = 0; while (i < retry) { using (var client = new NetworkManagementClient(_credentials)) { try { client.SubscriptionId = _servicePrincipal.Subscription; var network = NetworkInterfacesOperationsExtensions.GetAsync(client.NetworkInterfaces, GroupName, nicName).GetAwaiter().GetResult(); string ip = network.IpConfigurations[0].PrivateIPAddress; return(ip); } catch (Exception e) { if (i + 1 == retry) { throw; } else { Util.Log($"Encounter error {e.Message} and retry"); } } }; i++; } throw new Exception("Fail to get private IP"); }
private void SetupManagementClients(MockContext context) { ServiceFabricClient = GetServiceFabricManagementClient(context); if (HttpMockServer.Mode == HttpRecorderMode.Record) { ServiceFabricClient.LongRunningOperationRetryTimeout = 20; } ServiceFabricManagedClustersClient = GetServiceFabricManagedClustersManagementClient(context); if (HttpMockServer.Mode == HttpRecorderMode.Record) { ServiceFabricManagedClustersClient.LongRunningOperationRetryTimeout = 20; } ComputeManagementClient = GetComputeManagementClient(context); KeyVaultManagementClient = GetKeyVaultManagementClient(context); StorageManagementClient = GetStorageManagementClient(context); NetworkManagementClient = GetNetworkManagementClient(context); NewResourceManagementClient = GetNewResourceManagementClient(context); _helper.SetupManagementClients( ServiceFabricClient, ServiceFabricManagedClustersClient, ComputeManagementClient, KeyVaultManagementClient, StorageManagementClient, NetworkManagementClient, NewResourceManagementClient); }
public async Task <PublicIPAddress> CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location, NetworkManagementClient nrpClient) { PublicIPAddress publicIp = new PublicIPAddress() { Location = location, Tags = new Dictionary <string, string>() { { "key", "value" } }, PublicIPAllocationMethod = IPAllocationMethod.Dynamic, DnsSettings = new PublicIPAddressDnsSettings() { DomainNameLabel = domainNameLabel } }; // Put nic1PublicIpAddress Operation <PublicIPAddress> putPublicIpAddressOperation = await nrpClient.PublicIPAddresses.StartCreateOrUpdateAsync(resourceGroupName, name, publicIp); Response <PublicIPAddress> putPublicIpAddressResponse = await WaitForCompletionAsync(putPublicIpAddressOperation); Assert.AreEqual("Succeeded", putPublicIpAddressResponse.Value.ProvisioningState.ToString()); Response <PublicIPAddress> getPublicIpAddressResponse = await nrpClient.PublicIPAddresses.GetAsync(resourceGroupName, name); return(getPublicIpAddressResponse); }
public string GetIpAddress(string group, string name, string id, Microsoft.Azure.Management.ResourceManager.Fluent.Authentication.AzureCredentials credentials) { var computeManagementClient = new ComputeManagementClient(credentials) { SubscriptionId = id }; var vmResult = computeManagementClient.VirtualMachines.Get(group, name); var firstNic = vmResult.NetworkProfile.NetworkInterfaces.First(); var nicNameParts = firstNic.Id.Split('/'); string networkIntefaceName = nicNameParts.Last(); using (var client = new NetworkManagementClient(credentials)) { client.SubscriptionId = id; string publicNicId = string.Empty; var nic = client.NetworkInterfaces.ListAll().FirstOrDefault(x => x.Name == networkIntefaceName); if (nic != null) { publicNicId = nic.IpConfigurations[0].PublicIPAddress.Id; var publicIp = client.PublicIPAddresses.ListAll().FirstOrDefault(x => x.Id == publicNicId); if (publicIp != null) { var publicIP = publicIp.IpAddress; return(publicIP); } else { return("UNKNOWN"); } } return("UNKNOWN"); } }
public VirtualNetwork CreateVirtualNetwork(TokenCredentials credential, string groupName, string subscriptionId, string location, string vnetName, string subnetName) { Console.WriteLine("Creating the virtual network..."); var networkManagementClient = new NetworkManagementClient(credential) { SubscriptionId = subscriptionId }; var subnet = new Subnet { Name = subnetName, AddressPrefix = "10.0.0.0/24" }; var address = new AddressSpace { AddressPrefixes = new List <string> { "10.0.0.0/16" } }; return(networkManagementClient.VirtualNetworks.CreateOrUpdate( groupName, vnetName, new VirtualNetwork { Location = location, AddressSpace = address, Subnets = new List <Subnet> { subnet } } )); }
public static NetworkInterface CreateNetworkInterface(TokenCredentials credential, string groupName, string subscriptionId, string location, string subnetName, string vnetName, string ipName, string nicName) { Console.WriteLine("Creating the network interface..."); var networkManagementClient = new NetworkManagementClient(credential) { SubscriptionId = subscriptionId }; var subnetResponse = networkManagementClient.Subnets.Get( groupName, vnetName, subnetName ); var pubipResponse = networkManagementClient.PublicIPAddresses.Get(groupName, ipName); return(networkManagementClient.NetworkInterfaces.CreateOrUpdate( groupName, nicName, new NetworkInterface { Location = location, IpConfigurations = new List <NetworkInterfaceIPConfiguration> { new NetworkInterfaceIPConfiguration { Name = nicName, PublicIPAddress = pubipResponse, Subnet = subnetResponse } } } )); }
/// <summary> /// Gets network configuration from MS azure using management API call. /// </summary> /// <param name="credentials">Subscription Cloud Credentials</param> /// <param name="serviceUrl">service url of subscription</param> /// <returns>Network configuration for subscription</returns> private NetworkGetConfigurationResponse GetNetworkConfigurationFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.VirtualNetwork.ToString()); Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted); using (var vnetClient = new NetworkManagementClient(credentials, serviceUrl)) { try { NetworkGetConfigurationResponse ventConfig = vnetClient.Networks.GetConfiguration(); Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureCompleted, ResourceType.VirtualNetwork.ToString()); Logger.Info(methodName, ProgressResources.ExecutionCompleted, ResourceType.VirtualNetwork.ToString()); return(ventConfig); } catch (CloudException cex) { if (cex.ErrorCode == Constants.ResourceNotFound) { return(null); } else { Logger.Error(methodName, cex); throw cex; } } } }
internal static void CreatePrivateZones( DnsManagementClient dnsClient, ResourceGroup resourceGroup, IList <string> zonesNames, ResourceManagementClient resourcesClient, NetworkManagementClient networkManagementClient) { var location = ResourceGroupHelper.GetResourceLocation(resourcesClient, "microsoft.network/dnszones"); foreach (var zonesName in zonesNames) { var registrationVnets = Enumerable.Range(0, 1).Select(i => ResourceGroupHelper.CreateVirtualNetwork(resourceGroup.Name, networkManagementClient)).ToList(); var resolutionVnets = Enumerable.Range(0, 1).Select(i => ResourceGroupHelper.CreateVirtualNetwork(resourceGroup.Name, networkManagementClient)).ToList(); ResourceGroupHelper.CreatePrivateZone( dnsClient, zonesName, location, registrationVnets.Select(vNet => new SubResource { Id = vNet.Id }).ToList(), resolutionVnets.Select(vNet => new SubResource { Id = vNet.Id }).ToList(), resourceGroup); } }
public async Task <Config.Subnet> CreateSubnetAsync( Guid subscriptionId, string location, string resourceGroupName, string vnetName, string subnetName, string subnetAddressRange, string environmentName) { await RegisterProvider(subscriptionId, "Microsoft.Network"); var accessToken = await GetAccessToken(); var token = new TokenCredentials(accessToken); var networkClient = new NetworkManagementClient(token) { SubscriptionId = subscriptionId.ToString() }; var newSubnet = new Subnet(name: subnetName, addressPrefix: subnetAddressRange); var subnetResult = await networkClient.Subnets.CreateOrUpdateAsync(resourceGroupName, vnetName, subnetName, newSubnet); var subnet = await GetSubnetAsync(subscriptionId, location, resourceGroupName, vnetName, subnetName); subnet.ExistingResource = false; return(subnet); }
public static async Task <NetworkInterface> CreateNetworkInterfaceAsync(TokenCredentials credential, string groupName, string subscriptionId, string location, string subnetName, string vnetName, string ipName, string nicName) { var networkManagementClient = new NetworkManagementClient(credential) { SubscriptionId = subscriptionId, BaseUri = new Uri("https://management.chinacloudapi.cn") }; var subnet = await networkManagementClient.Subnets.GetAsync(groupName, vnetName, subnetName ); var publicIP = await networkManagementClient.PublicIPAddresses.GetAsync( groupName, ipName ); Console.WriteLine("Creating the network interface..."); return(await networkManagementClient.NetworkInterfaces.CreateOrUpdateAsync(groupName, nicName, new NetworkInterface { Location = location, IpConfigurations = new List <NetworkInterfaceIPConfiguration> { new NetworkInterfaceIPConfiguration { Name = nicName, PublicIPAddress = publicIP, Subnet = subnet } } } )); }
/// <summary> /// Creates or updates an existing Azure Route Table with a list of IP addresses that will be bound for the Internet as /// next hop. /// <summary> public async Task CreateRouteTableAsync( string group, string routeTableName, IEnumerable <string> addresses, string virtualFirewallIp, string vnet, string[] subnets) { RouteTableFactory factory = new RouteTableFactory( Region, routeTableName, virtualFirewallIp, addresses); RouteTable table = factory.Create(); table.Id = CreateRouteTableResourceId(group, routeTableName); if ((table.Routes.Count() - 1) <= 0) { System.Console.WriteLine("No routes to add."); return; } if (subnets != null) { System.Console.WriteLine("Getting subnets to associate with route table."); AssociateSubnets(table, group, vnet, subnets); } Console.WriteLine("Adding {0} routes.", table.Routes.Count()); NetworkManagementClient client = new NetworkManagementClient(Subscription, new DefaultAzureCredential()); await client.RouteTables.StartCreateOrUpdateAsync(group, routeTableName, table); }
/// <summary> /// Get Or create subnet. /// </summary> /// <param name="resourceGroup">Object representing a resource group.</param> /// <param name="virtualNetwork">Object representing a virtual network.</param> /// <param name="subnetName">The name of the subnet.</param> /// <returns>Subnet object.</returns> public Subnet GetOrCreateSubnet(ResourceGroup resourceGroup, VirtualNetwork virtualNetwork, string subnetName) { notes.Add("GetOrCreateSubnet"); NetworkManagementClient networkManagementClient = this.GetClient <NetworkManagementClient>(); Subnet subNet = null; try { subNet = networkManagementClient.Subnets.Get(resourceGroup.Name, virtualNetwork.Name, subnetName); } catch (CloudException ex) { if (ex.Body.Code != "NotFound") { throw; } } if (subNet == null) { var snet = new Subnet() { Name = subnetName, AddressPrefix = "10.0.0.0/24", }; subNet = networkManagementClient.Subnets.CreateOrUpdate(resourceGroup.Name, virtualNetwork.Name, subnetName, snet); } return(subNet); }
/// <summary> /// Get or create virtual network. /// </summary> /// <param name="resourceGroup">Object representing a resource group.</param> /// <param name="virtualNetworkName">The name of the virtual network.</param> /// <returns>VirtualNetwork object.</returns> public VirtualNetwork GetOrCreateVirtualNetwork(ResourceGroup resourceGroup, string virtualNetworkName) { notes.Add("Get or Create Vnet"); NetworkManagementClient networkManagementClient = this.GetClient <NetworkManagementClient>(); VirtualNetwork virtualNetwork = null; try { virtualNetwork = networkManagementClient.VirtualNetworks.Get(resourceGroup.Name, virtualNetworkName); } catch (CloudException ex) { if (ex.Body.Code != "ResourceNotFound") { throw; } } if (virtualNetwork == null) { var vnet = new VirtualNetwork() { Location = resourceGroup.Location, AddressSpace = new AddressSpace() { AddressPrefixes = new List <string> { "10.0.0.0/16" }, }, }; virtualNetwork = networkManagementClient.VirtualNetworks.CreateOrUpdate(resourceGroup.Name, virtualNetworkName, vnet); } return(virtualNetwork); }
public static PublicIPAddress CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location, NetworkManagementClient 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("Succeeded", putPublicIpAddressResponse.ProvisioningState); var getPublicIpAddressResponse = nrpClient.PublicIPAddresses.Get(resourceGroupName, name); return(getPublicIpAddressResponse); }
/// <summary> /// Provisions all the components in the <see cref="DevOpsFlexDbContext"/>. /// </summary> /// <param name="context">The database context that we want to provision components from.</param> /// <param name="subscriptionId">The subscription Id where we want to provision in.</param> /// <param name="settingsPath">The path to the settings file with the management certificate.</param> /// <returns>The async <see cref="Task"/> wrapper.</returns> public static async Task ProvisionAllAsync(this DevOpsFlexDbContext context, string subscriptionId, string settingsPath) { Contract.Requires(context != null); Contract.Requires(string.IsNullOrEmpty(subscriptionId)); Contract.Requires(string.IsNullOrEmpty(settingsPath)); var azureSubscription = new AzureSubscription(settingsPath, subscriptionId); var azureCert = new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate)); using (var computeClient = new ComputeManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert))) using (var networkClient = new NetworkManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert))) using (var sbClient = new ServiceBusManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert))) using (var sqlClient = new SqlManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert))) using (var storageClient = new StorageManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert))) using (var webSiteClient = new WebSiteManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert))) { var tasks = new[] { context.Components.OfType <AzureCloudService>().ToList().ProvisionAllAsync(computeClient), context.Components.OfType <AzureCloudService>().ToList().ReserveAllIpsAsync(networkClient), context.Components.OfType <AzureServiceBusNamespace>().ToList().ProvisionAllAsync(sbClient), context.Components.OfType <SqlAzureDb>().ToList().ProvisionAllAsync(sqlClient), context.Components.OfType <AzureStorageContainer>().ToList().ProvisionAllAsync(storageClient), context.Components.OfType <AzureWebSite>().ToList().ProvisionAllAsync(webSiteClient) }; await Task.WhenAll(tasks); } }
protected void EnsureClientsInitialized(MockContext context) { if (!m_initialized) { lock (m_lock) { if (!m_initialized) { m_ResourcesClient = ComputeManagementTestUtilities.GetResourceManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); m_CrpClient = ComputeManagementTestUtilities.GetComputeManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); m_SrpClient = ComputeManagementTestUtilities.GetStorageManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); m_NrpClient = ComputeManagementTestUtilities.GetNetworkManagementClient(context, new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }); m_subId = m_CrpClient.SubscriptionId; if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"))) { m_location = ComputeManagementTestUtilities.DefaultLocation; } else { m_location = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION").Replace(" ", "").ToLower(); } } } } }
public static async Task <VirtualNetwork> CreateVirtualNetworkAsync(TokenCredentials credential, string groupName, string subscriptionId, string location, string vnetName, string subnetName) { var networkManagementClient = new NetworkManagementClient(credential) { SubscriptionId = subscriptionId, BaseUri = new Uri("https://management.chinacloudapi.cn") }; var subnet = new Subnet { Name = subnetName, AddressPrefix = "10.0.0.0/24" }; var address = new AddressSpace { AddressPrefixes = new List <string> { "10.0.0.0/16" } }; Console.WriteLine("Creating the virtual network..."); return(await networkManagementClient.VirtualNetworks.CreateOrUpdateAsync( groupName, vnetName, new VirtualNetwork { Location = location, AddressSpace = address, Subnets = new List <Subnet> { subnet } } )); }
public async Task <RouteFilter> CreateDefaultRouteFilter(string resourceGroupName, string filterName, string location, NetworkManagementClient nrpClient, bool containsRule = false) { var filter = new RouteFilter() { Location = location, Tags = { { "key", "value" } } }; if (containsRule) { RouteFilterRule rule = new RouteFilterRule() { Name = "test", Access = ExpressRouteTests.Filter_Access, Communities = { ExpressRouteTests.Filter_Commmunity }, Location = location }; filter.Rules.Add(rule); } // Put route filter Operation <RouteFilter> filterOperation = await nrpClient.RouteFilters.StartCreateOrUpdateAsync(resourceGroupName, filterName, filter); Response <RouteFilter> filterResponse = await WaitForCompletionAsync(filterOperation); Assert.AreEqual("Succeeded", filterResponse.Value.ProvisioningState.ToString()); Response <RouteFilter> getFilterResponse = await nrpClient.RouteFilters.GetAsync(resourceGroupName, filterName); return(getFilterResponse); }
public static async Task <VirtualNetwork> CreateVirtualNetwork(string vnetName, string subnetName, string resourceGroupName, string location, NetworkManagementClient client) { VirtualNetwork vnet = new VirtualNetwork() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = { "10.0.0.0/16", } }, DhcpOptions = new DhcpOptions() { DnsServers = { "10.1.1.1", "10.1.2.4" } }, Subnets = { new Subnet() { Name = subnetName, AddressPrefix = "10.0.0.0/24", } } }; await client.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet); Response <VirtualNetwork> getVnetResponse = await client.VirtualNetworks.GetAsync(resourceGroupName, vnetName); return(getVnetResponse); }
/// <summary> /// Gets network configuration from MS azure using management API call. /// Changed in v2.0 /// </summary> /// <param name="credentials">Source subscription credentials</param> /// <param name="serviceUrl">Subscription service Url</param> /// <returns>Network configuration for subscription</returns> private NetworkGetConfigurationResponse GetNetworkConfigurationFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted, ResourceType.VirtualNetwork.ToString()); dcMigration.ReportProgress(ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted); NetworkGetConfigurationResponse ventConfig = null; using (var vnetClient = new NetworkManagementClient(credentials, serviceUrl)) { try { ventConfig = vnetClient.Networks.GetConfiguration(); Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureCompleted, ResourceType.VirtualNetwork.ToString()); return(ventConfig); } catch (CloudException cex) { if (ventConfig == null) { return(ventConfig); } if (string.Compare(cex.Error.ToString(), Constants.ResourceNotFound, StringComparison.CurrentCultureIgnoreCase) == 0) { return(null); } else { Logger.Error(methodName, cex, ResourceType.VirtualNetwork.ToString()); throw; } } } }
public async Task <ExpressRouteCircuit> CreateDefaultExpressRouteCircuit(string resourceGroupName, string circuitName, string location, NetworkManagementClient nrpClient) { ExpressRouteCircuitSku sku = new ExpressRouteCircuitSku { Name = "Premium_MeteredData", Tier = "Premium", Family = "MeteredData" }; ExpressRouteCircuitServiceProviderProperties provider = new ExpressRouteCircuitServiceProviderProperties { BandwidthInMbps = Convert.ToInt32(ExpressRouteTests.Circuit_BW), PeeringLocation = ExpressRouteTests.Circuit_Location, ServiceProviderName = ExpressRouteTests.Circuit_Provider }; ExpressRouteCircuit circuit = new ExpressRouteCircuit() { Location = location, Tags = { { "key", "value" } }, Sku = sku, ServiceProviderProperties = provider }; // Put circuit Operation <ExpressRouteCircuit> circuitOperation = await nrpClient.ExpressRouteCircuits.StartCreateOrUpdateAsync(resourceGroupName, circuitName, circuit); Response <ExpressRouteCircuit> circuitResponse = await WaitForCompletionAsync(circuitOperation); Assert.AreEqual("Succeeded", circuitResponse.Value.ProvisioningState.ToString()); Response <ExpressRouteCircuit> getCircuitResponse = await nrpClient.ExpressRouteCircuits.GetAsync(resourceGroupName, circuitName); return(getCircuitResponse); }
public void TestAllScenariosPrivateEndpointConnection() { using (SqlManagementTestContext context = new SqlManagementTestContext(this)) { sqlClient = context.GetClient <SqlManagementClient>(); networkClient = context.GetClient <NetworkManagementClient>(); var location = TestEnvironmentUtilities.DefaultEuapPrimaryLocationId; ResourceGroup resourceGroup = context.CreateResourceGroup(location); Server server = context.CreateServer(resourceGroup, location); VirtualNetwork vnet = CreateVirtualNetwork(resourceGroup, location); IList <PrivateEndpointConnection> pecs = CreatePrivateEndpoints(resourceGroup, location, server, vnet, n: 2); PrivateEndpointConnection pec1 = pecs[0]; pec1.PrivateLinkServiceConnectionState.Status = "Approved"; sqlClient.PrivateEndpointConnections.CreateOrUpdate(resourceGroup.Name, server.Name, pec1.Name, pec1); PrivateEndpointConnection pec1r = sqlClient.PrivateEndpointConnections.Get(resourceGroup.Name, server.Name, pec1.Name); SqlManagementTestUtilities.ValidatePrivateEndpointConnection(pec1, pec1r); PrivateEndpointConnection pec2 = pecs[1]; pec2.PrivateLinkServiceConnectionState.Status = "Rejected"; sqlClient.PrivateEndpointConnections.CreateOrUpdate(resourceGroup.Name, server.Name, pec2.Name, pec2); PrivateEndpointConnection pec2r = sqlClient.PrivateEndpointConnections.Get(resourceGroup.Name, server.Name, pec2.Name); SqlManagementTestUtilities.ValidatePrivateEndpointConnection(pec2, pec2r); sqlClient.PrivateEndpointConnections.Delete(resourceGroup.Name, server.Name, pec1.Name); Assert.Throws <Microsoft.Rest.Azure.CloudException>(() => sqlClient.PrivateEndpointConnections.Get(resourceGroup.Name, server.Name, pec1.Name)); sqlClient.PrivateEndpointConnections.Delete(resourceGroup.Name, server.Name, pec2.Name); Assert.Throws <Microsoft.Rest.Azure.CloudException>(() => sqlClient.PrivateEndpointConnections.Get(resourceGroup.Name, server.Name, pec2.Name)); } }
public async Task <List <AzureSubnet> > GetSubnets(string subscriptionId, string location) { var cacheKey = CacheKeys.MakeKey(CacheKeys.SubnetList, subscriptionId, location); var cached = HttpContext.Session.Get <List <AzureSubnet> >(cacheKey); if (cached != null) { return(cached); } var accessToken = await GetAccessToken(); var token = new TokenCredentials(accessToken); var networkClient = new NetworkManagementClient(token) { SubscriptionId = subscriptionId }; var vNets = await networkClient.VirtualNetworks.ListAllAsync(); var subnets = vNets .Where(vnet => string.IsNullOrWhiteSpace(location) || vnet.Location.Equals(location, StringComparison.OrdinalIgnoreCase)) .SelectMany(vnet => vnet.Subnets.Select(subnet => new AzureSubnet(vnet, subnet))) .OrderBy(subnet => subnet.Name) .ToList(); return(HttpContext.Session.Set(cacheKey, subnets)); }
public VirtualNetwork CreateVirtualNetwork(SqlManagementTestContext context, ResourceGroup resourceGroup, string location, int subnetCount = 1) { NetworkManagementClient networkClient = context.GetClient <NetworkManagementClient>(); // Create vnet andinitialize subnets string vnetName = SqlManagementTestUtilities.GenerateName(); List <ServiceEndpointPropertiesFormat> SqlPrivateAccess = new List <ServiceEndpointPropertiesFormat>() { new ServiceEndpointPropertiesFormat("Microsoft.Sql") }; List <Subnet> subnetList = new List <Subnet>(); for (int i = 0; i < subnetCount; i++) { string subnetName = SqlManagementTestUtilities.GenerateName(); String addressPrefix = "10.0." + (i + 1) + ".0/24"; Subnet subnet = new Subnet() { Name = subnetName, AddressPrefix = addressPrefix, ServiceEndpoints = SqlPrivateAccess, }; subnetList.Add(subnet); } 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 = subnetList }; // Put Vnet var putVnetResponse = networkClient.VirtualNetworks.CreateOrUpdate(resourceGroup.Name, vnetName, vnet); Assert.Equal("Succeeded", putVnetResponse.ProvisioningState); // Get Vnet var getVnetResponse = networkClient.VirtualNetworks.Get(resourceGroup.Name, vnetName); return(getVnetResponse); }
protected NetworkManagementClient GetNetworkClient(MockContext context) { NetworkManagementClient client = context.GetServiceClient <NetworkManagementClient>( TestEnvironmentFactory.GetTestEnvironment()); return(client); }
private void SetupManagementClients(MockContext context) { DataLakeStoreAccountManagementClient = GetDataLakeStoreAccountManagementClient(context); SetDataLakeStoreFileSystemManagementClient(context); NewResourceManagementClient = GetNewResourceManagementClient(context); NetworkClient = GetNetworkClient(context); _helper.SetupManagementClients(NewResourceManagementClient, NetworkClient, DataLakeStoreAccountManagementClient); }
public NetworkManagementService(TokenCredentials credentials) { client = new Lazy <NetworkManagementClient>(() => { var result = new NetworkManagementClient(credentials); return(result); }); }
private static string InitializeToken() { var token = GetToken(); var creds = new Microsoft.Rest.TokenCredentials(token); s_netclient = new NetworkManagementClient(creds) { SubscriptionId = Config.Current.subscription_id }; s_computeClient = new ComputeManagementClient(creds) { SubscriptionId = Config.Current.subscription_id }; return token; }
/// <summary> /// Create Virtual Network Interface Card, NIC /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="nicName">Internal name for NIC</param> /// <param name="nicIPConfigName">Internal name for NIC Configuration. Sample only provides one configuration, but could be extended to provide more</param> /// <param name="pip">Public IP Address to be assigned to NIC</param> /// <param name="subnet">Subnet to use for current configuration</param> /// <returns>Awaitable task</returns> private static Task<NetworkInterface> CreateNetworkInterfaceAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string nicName, string nicIPConfigName, PublicIPAddress pip, Subnet subnet) { Console.WriteLine("Creating Network Interface"); var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId }; var createNicTask = networkClient.NetworkInterfaces.CreateOrUpdateAsync(resourceGroup, nicName, new NetworkInterface() { Location = location, IpConfigurations = new[] { new NetworkInterfaceIPConfiguration { Name = nicIPConfigName, PrivateIPAllocationMethod = "Dynamic", PublicIPAddress = pip, Subnet = subnet } } }); return createNicTask; }
/// <summary> /// Create Virtual Network /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="vNetName">Internal name used to identify Virtual Network within your subscription</param> /// <param name="vNetAddressPrefix">IP Address range for Virtual Network</param> /// <param name="subnets">List of Subnets to be provisioned inside the Virtual Network</param> /// <returns>Awaitable task</returns> private static Task<VirtualNetwork> CreateVirtualNetworkAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string vNetName, string vNetAddressPrefix, Subnet[] subnets) { Console.WriteLine("Creating Virtual Network"); var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId }; var createVNetTask = networkClient.VirtualNetworks.CreateOrUpdateAsync(resourceGroup, vNetName, new VirtualNetwork { Location = location, AddressSpace = new AddressSpace(new[] { vNetAddressPrefix }), Subnets = subnets }); return createVNetTask; }
/// <summary> /// Create Public IP Address (with DNS name) /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="pipAddressName">Internal name used to identify Public IP Address within your subscription</param> /// <param name="pipDnsName">Globally unique name. Will be part of Fully Qualified Domain Name, FQDN, used to access resources in Azure</param> /// <returns>Awaitable task</returns> private static Task<PublicIPAddress> CreatePublicIPAddressAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string pipAddressName, string pipDnsName) { Console.WriteLine("Creating Public IP"); var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId }; var createPipTask = networkClient.PublicIPAddresses.CreateOrUpdateAsync(resourceGroup, pipAddressName, new PublicIPAddress { Location = location, DnsSettings = new PublicIPAddressDnsSettings { DomainNameLabel = pipDnsName }, PublicIPAllocationMethod = "Dynamic" // This sample doesn't support Static IP Addresses but could be extended to do so }); return createPipTask; }