public TestClientProvider(ManagementClient mgmtClient, ComputeManagementClient computeClient,
StorageManagementClient storageClient, NetworkManagementClient networkClient)
{
this.managementClient = mgmtClient;
this.computeManagementClient = computeClient;
this.storageManagementClient = storageClient;
this.networkManagementClient = networkClient;
}
public NetworkTestClient()
{
undoContext = UndoContext.Current;
undoContext.Start(4);
networkClient = TestBase.GetServiceClient<NetworkManagementClient>();
testOperations = new List<TestOperation>();
}
public ManagementController(ManagementControllerParameters parameters)
{
_parameters = parameters;
// To authenticate against the Microsoft Azure service management API we require management certificate
// load this from a publish settings file and later use it with the Service Management Libraries
var credentials = GetSubscriptionCloudCredentials(parameters.PublishSettingsFilePath);
// Create a management client and a virtual network management client
_managementClient = CloudContext.Clients.CreateManagementClient(credentials);
_virtualNetworkManagementClient = CloudContext.Clients.CreateVirtualNetworkManagementClient(credentials);
}
protected override void Clone(ServiceClient <NetworkManagementClient> client)
{
base.Clone(client);
NetworkManagementClient management = client as NetworkManagementClient;
if (management != null)
{
management._credentials = Credentials;
management._baseUri = BaseUri;
management.Credentials.InitializeServiceClient(management);
}
}
/// <summary>
/// Reserves all IPs for services in the <see cref="IEnumerable{T}"/> of <see cref="AzureCloudService"/> that need IP reservation.
/// </summary>
/// <param name="services">The list of <see cref="AzureCloudService"/> to reserve IPs for.</param>
/// <param name="client">The <see cref="ComputeManagementClient"/> that is performing the operation.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task ReserveAllIpsAsync(this IEnumerable<AzureCloudService> services, NetworkManagementClient client)
{
Contract.Requires(services != null);
Contract.Requires(client != null);
var tasks = services.Where(s => s.ReserveIp)
.Select(
async s =>
{
await client.ReserveIpIfNotReservedAsync(s);
});
await Task.WhenAll(tasks);
}
private NetworkListResponse.VirtualNetworkSite GetAzureVNet(string name)
{
NetworkManagementClient networkClient = new NetworkManagementClient(this.Client.Credentials, this.Client.BaseUri);
Task<NetworkListResponse> listNetworkTask = networkClient.Networks.ListAsync();
listNetworkTask.Wait();
if (listNetworkTask.Status == TaskStatus.RanToCompletion)
{
NetworkListResponse networkList = listNetworkTask.Result;
foreach (NetworkListResponse.VirtualNetworkSite network in networkList.VirtualNetworkSites)
{
if (network.Name == name)
{
return network;
}
}
}
return null;
}
/// <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.Error.ToString() == Constants.ResourceNotFound)
{
return null;
}
else
{
Logger.Error(methodName, cex);
throw cex;
}
}
}
}
/// <summary>
/// Rollback all virtual networks
/// </summary>
/// <param name="networkConfiguration">Network configuration</param>
private void RollBackVirtualNetworks(NetworkConfiguration networkConfiguration)
{
Stopwatch swVirtualNetwork = new Stopwatch();
swVirtualNetwork.Start();
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.NetworkConfiguration.ToString());
// Get destination subscription network configuration
NetworkGetConfigurationResponse destinationNetworkResponse = GetNetworkConfigurationFromMSAzure(
importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl);
NetworkConfiguration destinationNetConfiguration = null;
XmlSerializer serializer = new XmlSerializer(typeof(NetworkConfiguration));
if (destinationNetworkResponse != null && !(string.IsNullOrEmpty(destinationNetworkResponse.Configuration)))
{
var destinationReader = new StringReader(destinationNetworkResponse.Configuration);
destinationNetConfiguration = (NetworkConfiguration)serializer.Deserialize(destinationReader);
}
try
{
if (networkConfiguration != null)
{
if (networkConfiguration.VirtualNetworkConfiguration != null)
{
if (networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null &&
destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites)
{
foreach (var dns in networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers)
{
string dnsDestination = resourceImporter.GetDestinationResourceName(ResourceType.DnsServer, dns.name,
ResourceType.VirtualNetworkSite,
resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite,
virtualNetworkSite.name));
if (!string.IsNullOrEmpty(dnsDestination))
{
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers =
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Where(s => s.name != dnsDestination).ToArray();
}
}
}
}
if (networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null &&
destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites)
{
foreach (var localNetwork in networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites)
{
string localNetworkDestination = resourceImporter.GetDestinationResourceName(ResourceType.LocalNetworkSite,
localNetwork.name,
ResourceType.VirtualNetworkSite,
resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite,
virtualNetworkSite.name));
if (!string.IsNullOrEmpty(localNetworkDestination))
{
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Where(s => s.name != localNetworkDestination).ToArray();
}
}
}
}
if (networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null &&
destinationNetConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.
Where(x => !networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.
Any(x1 => resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite, x1.name) == x.name)).ToArray();
}
}
}
MemoryStream memoryStream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Encoding = Encoding.UTF8 });
serializer.Serialize(writer, destinationNetConfiguration);
using (var vnetClient = new NetworkManagementClient(importParameters.DestinationSubscriptionSettings.Credentials,
importParameters.DestinationSubscriptionSettings.ServiceUrl))
{
OperationStatusResponse response = Retry.RetryOperation(() => vnetClient.Networks.SetConfiguration(
new NetworkSetConfigurationParameters
{
Configuration = Encoding.UTF8.GetString(memoryStream.ToArray())
}), (BaseParameters)importParameters, ResourceType.NetworkConfiguration);
}
writer.Close();
memoryStream.Close();
resourceImporter.UpdateMedatadaFile(ResourceType.NetworkConfiguration, null, false);
Logger.Info(methodName, ProgressResources.RollbackVirtualNetworksWaiting, ResourceType.NetworkConfiguration.ToString());
dcMigrationManager.ReportProgress(ProgressResources.RollbackVirtualNetworksWaiting);
Task.Delay(Constants.DelayTimeInMilliseconds_Rollback).Wait();
Logger.Info(methodName, ProgressResources.RollbackVirtualNetwork, ResourceType.NetworkConfiguration.ToString());
swVirtualNetwork.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime,swVirtualNetwork.Elapsed.Days, swVirtualNetwork.Elapsed.Hours,
swVirtualNetwork.Elapsed.Minutes, swVirtualNetwork.Elapsed.Seconds), ResourceType.NetworkConfiguration.ToString());
}
catch (CloudException ex)
{
if (string.Compare(ex.Error.ToString(), Constants.ResourceNotFound, StringComparison.CurrentCultureIgnoreCase) != 0)
{
Logger.Error(methodName, ex, ResourceType.VirtualNetwork.ToString());
}
else
{
throw;
}
}
}
public DeploymentGetResponse CreateMultivipDeploymentAndAssertSuccess(NetworkManagementClient networkClient, ComputeManagementClient computeClient, List<string> vipNames, string serviceName, string deploymentName, string storageAccountName, string location)
{
Utilities.CreateAzureVirtualMachine(computeClient, serviceName, deploymentName,
storageAccountName, "blob.core.windows.net");
DeploymentGetResponse depRetrieved =
computeClient.Deployments.GetByName(serviceName: serviceName, deploymentName: deploymentName);
List<ConfigurationSet> endpointCfgSets = new List<ConfigurationSet>
{
new ConfigurationSet
{
ConfigurationSetType = "NetworkConfiguration",
InputEndpoints =
new List<InputEndpoint>
{
new InputEndpoint()
{
LocalPort = 3387,
Name = "RDP2",
Port = 52777,
Protocol = InputEndpointTransportProtocol.Tcp,
EnableDirectServerReturn = false
},
}
}
};
// Update with single endpoint
var updateParams = Utilities.GetVMUpdateParameters(depRetrieved.Roles.First(),
storageAccountName, endpointCfgSets, preserveOriginalConfigSets: false);
computeClient.VirtualMachines.Update(
serviceName,
deploymentName,
depRetrieved.Roles.First().RoleName,
updateParams);
int i = 1;
foreach (var vip in vipNames)
{
i++;
OperationStatusResponse virtualIPCreate =
networkClient.VirtualIPs.Add(serviceName: serviceName,
deploymentName: deploymentName, virtualIPName: vip);
Assert.True(virtualIPCreate.StatusCode == HttpStatusCode.OK);
depRetrieved = Utilities.AssertLogicalVipWithoutIPPresentOrAbsent(computeClient, serviceName: serviceName,
deploymentName: deploymentName, virtualIPName: vip, expectedVipCount: i, present: true);
endpointCfgSets.First().InputEndpoints.Add(
new InputEndpoint()
{
LocalPort = 3387 + i,
Name = "RDPS" + i,
Port = 52777 + i,
Protocol = InputEndpointTransportProtocol.Tcp,
EnableDirectServerReturn = false,
VirtualIPName = vip
});
}
updateParams = Utilities.GetVMUpdateParameters(depRetrieved.Roles.First(),
storageAccountName, endpointCfgSets, preserveOriginalConfigSets: false);
computeClient.VirtualMachines.Update(
serviceName,
deploymentName,
depRetrieved.Roles.First().RoleName,
updateParams);
depRetrieved =
computeClient.Deployments.GetByName(serviceName: serviceName, deploymentName: deploymentName);
Assert.NotNull(depRetrieved);
Assert.NotNull(depRetrieved.VirtualIPAddresses);
Assert.True(depRetrieved.VirtualIPAddresses.Count == vipNames.Count + 1);
foreach (var virtualIpAddress in depRetrieved.VirtualIPAddresses)
{
Assert.NotNull(virtualIpAddress.Address);
}
return depRetrieved;
}
/// <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);
}
}
/// <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 SetNetworkConfiguration(NetworkManagementClient networkClient, NetworkSetConfigurationParameters parameters)
{
this.networkClient = networkClient;
this.parameters = parameters;
oldNetworkConfiguration = GetConfigurationSafe();
}
/// <summary>
/// Checks that the provided reserved ip name is present in destination and also it is not allocated to any service.
/// </summary>
/// <param name="credentials">Subscription credentials</param>
/// <param name="serviceUrl">Subscription service url</param>
/// <param name="reservedIPName">Reserved ip name</param>
/// <param name="serviceName">Service name</param>
/// <returns>Returns true if ReservedIPName is present in destination and it is not allocated to any deployment /
/// returns <see cref="ValidationException"/> if the ReservedIPName is not available in destination subscription or it is available but already assigned to any service.
/// </returns>
private bool CheckReservedIPNameAvailability(SubscriptionCloudCredentials credentials, Uri serviceUrl, string reservedIPName, string serviceName)
{
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted, ResourceType.VirtualNetwork.ToString());
using (var vnetClient = new NetworkManagementClient(credentials, serviceUrl))
{
var reservedIPLists = vnetClient.ReservedIPs.List();
NetworkReservedIPListResponse.ReservedIP reservedIpPresent = (from ri in reservedIPLists
where (ri.Name == reservedIPName)
select ri).FirstOrDefault();
if (reservedIpPresent == null)
{
throw new ValidationException(string.Format(ProgressResources.MissingReservedIPName, reservedIPName));
}
else if (reservedIpPresent.ServiceName != null && !(serviceName.Equals(reservedIpPresent.ServiceName, StringComparison.InvariantCultureIgnoreCase)))
{
throw new ValidationException(string.Format(ProgressResources.OccupiedReservedIpName, reservedIPName, reservedIpPresent.ServiceName));
}
}
return true;
}
/// <summary>
/// Creates virtual networks.
/// </summary>
/// <param name="networkConfiguration">Network configuration</param>
private void CreateVirtualNetworks(NetworkConfiguration networkConfiguration)
{
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Stopwatch swVirtualNet = new Stopwatch();
swVirtualNet.Start();
if (networkConfiguration != null && !networkConfiguration.IsImported)
{
Logger.Info(methodName, ProgressResources.ImportVirtualNetworkStarted, ResourceType.VirtualNetwork.ToString());
try
{
// Get destination subscription network configuration
NetworkGetConfigurationResponse destinationNetworkResponse = GetNetworkConfigurationFromMSAzure(
importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl);
NetworkConfiguration destinationNetConfiguration = null;
XmlSerializer serializer = new XmlSerializer(typeof(NetworkConfiguration));
if (destinationNetworkResponse != null && !(string.IsNullOrEmpty(destinationNetworkResponse.Configuration)))
{
var destinationReader = new StringReader(destinationNetworkResponse.Configuration);
destinationNetConfiguration = (NetworkConfiguration)serializer.Deserialize(destinationReader);
}
// Merge network configuration if destination subscription is already having networks.
if (destinationNetConfiguration != null)
{
if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers =
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Union(
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers
).ToArray();
}
else if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
(destinationNetConfiguration.VirtualNetworkConfiguration.Dns == null ||
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers == null)
&&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns != null &&
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers =
networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers;
}
if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Union(
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites).ToArray();
}
else if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites == null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites = networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites;
}
if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites =
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites.Union(
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites).ToArray();
}
else if (destinationNetConfiguration.VirtualNetworkConfiguration != null &&
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites == null &&
networkConfiguration.VirtualNetworkConfiguration != null &&
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null)
{
destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites =
networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites;
}
}
// else destination network configuration will have new network configuration only.
else
{
destinationNetConfiguration = networkConfiguration;
}
MemoryStream memoryStream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Encoding = Encoding.UTF8 });
serializer.Serialize(writer, destinationNetConfiguration);
using (var vnetClient = new NetworkManagementClient(importParameters.DestinationSubscriptionSettings.Credentials,
importParameters.DestinationSubscriptionSettings.ServiceUrl))
{
OperationStatusResponse response = Retry.RetryOperation(() =>
vnetClient.Networks.SetConfiguration(new NetworkSetConfigurationParameters
{
Configuration = Encoding.UTF8.GetString(memoryStream.ToArray())
}
), (BaseParameters)importParameters, ResourceType.NetworkConfiguration);
}
UpdateMedatadaFile(ResourceType.NetworkConfiguration);
writer.Close();
memoryStream.Close();
swVirtualNet.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ImportVirtualNetworkCompleted, swVirtualNet.Elapsed.Days,
swVirtualNet.Elapsed.Hours, swVirtualNet.Elapsed.Minutes, swVirtualNet.Elapsed.Seconds),
ResourceType.VirtualNetwork.ToString());
}
catch (Exception ex)
{
Logger.Error(methodName, ex, ResourceType.VirtualNetwork.ToString());
throw;
}
}
}
