/// <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;
}
