/// <summary>
/// Creates or Updates Azure NetApp Files Account
/// </summary>
/// <param name="anfClient">ANF client object</param>
/// <param name="resourceGroupName">Resource group name</param>
/// <param name="location">Azure location</param>
/// <param name="accountName">Azure NetApp Files Account name</param>
/// <param name="domainUserName">Active Directory Username</param>
/// <param name="domainPassword">Active Directory Password</param>
/// <param name="dnsList">DNS IP list</param>
/// <param name="domainName">Domain Name</param>
/// <param name="smbServerName">SMB Server Name</param>
/// <param name="encodedCertContent">Encoded Certification content</param>
/// <returns>NetApp Account object</returns>
public static async Task <NetAppAccount> CreateOrUpdateANFAccountAsync(AzureNetAppFilesManagementClient anfClient,
string resourceGroupName,
string location,
string accountName,
string domainUserName,
string domainPassword,
string dnsList,
string domainName,
string smbServerName,
string encodedCertContent)
{
ActiveDirectory activeDirectory = new ActiveDirectory()
{
Username = domainUserName,
Password = domainPassword,
Dns = dnsList,
Domain = domainName,
SmbServerName = smbServerName,
ServerRootCACertificate = encodedCertContent
};
NetAppAccount anfAccountBody = new NetAppAccount(location, null, accountName, null, null, null, new List <ActiveDirectory>()
{
activeDirectory
});
return(await anfClient.Accounts.CreateOrUpdateAsync(anfAccountBody, resourceGroupName, accountName));
}
public override void ExecuteCmdlet()
{
IDictionary <string, string> tagPairs = null;
if (Tag != null)
{
tagPairs = new Dictionary <string, string>();
foreach (string key in Tag.Keys)
{
tagPairs.Add(key, Tag[key].ToString());
}
}
var netAppAccountBody = new NetAppAccount()
{
Location = Location,
ActiveDirectories = (ActiveDirectory != null) ? ActiveDirectory.ConvertFromPs() : null,
Tags = tagPairs
};
if (ShouldProcess(Name, string.Format(PowerShell.Cmdlets.NetAppFiles.Properties.Resources.CreateResourceMessage, ResourceGroupName)))
{
var anfAccount = AzureNetAppFilesManagementClient.Accounts.CreateOrUpdate(netAppAccountBody, ResourceGroupName, Name);
WriteObject(anfAccount.ToPsNetAppFilesAccount());
}
}
public void CreateDeleteAccount()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var accountsInitial = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
int initialCount = accountsInitial.Count();
// create the account with only the one required property
var netAppAccount = new NetAppAccount()
{
Location = ResourceUtils.location
};
var resource = netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Equal(resource.Name, ResourceUtils.accountName1);
Assert.Null(resource.Tags);
Assert.Null(resource.ActiveDirectories);
// get all accounts and check
var accountsBefore = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
Assert.Equal(initialCount + 1, accountsBefore.Count());
// remove the account and check
netAppMgmtClient.Accounts.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
// get all accounts and check
var accountsAfter = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
Assert.Equal(initialCount, accountsAfter.Count());
}
}
public void UpdateAccountNotPermitted()
{
// a put update is not a valid operation
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the account
ResourceUtils.CreateAccount(netAppMgmtClient);
// Now try and modify it
var netAppAccount = new NetAppAccount()
{
Location = ResourceUtils.location,
};
try
{
netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.True(false);
}
catch (Exception ex)
{
Assert.Contains("MethodNotAllowed", ex.Message);
}
// cleanup - remove the account
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public static NetAppAccount CreateAccount(AzureNetAppFilesManagementClient netAppMgmtClient, string accountName = accountName1, string resourceGroup = resourceGroup, string location = location, object tags = null, ActiveDirectory activeDirectory = null)
{
// request reference example
// az netappfiles account update -g --account-name cli-lf-acc2 --active-directories '[{"username": "******", "password": "******", "smbservername": "SMBSERVER", "dns": "1.2.3.4", "domain": "westcentralus"}]' -l westus2
var activeDirectories = new List <ActiveDirectory> {
activeDirectory
};
var netAppAccount = new NetAppAccount()
{
Location = location,
Tags = tags,
// current limitations of active directories make this problematic
// omitting tests on active directory properties for now
//ActiveDirectories = activeDirectories
ActiveDirectories = null
};
var resource = netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, resourceGroup, accountName);
Assert.Equal(resource.Name, accountName);
Thread.Sleep(delay); // some robustness against ARM caching
return(resource);
}
public static NetAppAccount CreateAccount(AzureNetAppFilesManagementClient netAppMgmtClient, string accountName = accountName1, string resourceGroup = resourceGroup, string location = location, IDictionary <string, string> tags = default(IDictionary <string, string>), ActiveDirectory activeDirectory = null)
{
// request reference example
// az netappfiles account update -g --account-name cli-lf-acc2 --active-directories '[{"username": "******", "password": "******", "smbservername": "SMBSERVER", "dns": "1.2.3.4", "domain": "westcentralus"}]' -l westus2
var activeDirectories = activeDirectory != null ? new List <ActiveDirectory> {
activeDirectory
} : new List <ActiveDirectory>();
var netAppAccount = new NetAppAccount()
{
Location = location,
Tags = tags,
ActiveDirectories = activeDirectories
};
var resource = netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, resourceGroup, accountName);
Assert.Equal(resource.Name, accountName);
if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
{
Thread.Sleep(delay); // some robustness against ARM caching
}
return(resource);
}
/// <summary>
/// Creates or updates a Azure NetApp Files Account
/// </summary>
/// <param name="client">Azure NetApp Files Management Client</param>
/// <param name="account">Account object generated from information contained at the appsettings.json file at Accounts section</param>
/// <returns>NetAppAccount</returns>
public static async Task <NetAppAccount> CreateOrUpdateAnfAccountAsync(ProjectConfiguration config, AzureNetAppFilesManagementClient client, ModelNetAppAccount account)
{
// Setting up NetApp Files account object
NetAppAccount anfAccountBody = new NetAppAccount(account.Location, null, account.Name);
// Requesting account to be created
return(await client.Accounts.CreateOrUpdateAsync(anfAccountBody, config.ResourceGroup, account.Name));
}
/// <summary>
/// Creates or updates a Azure NetApp Files Account with Active Directory information for SMB
/// </summary>
/// <param name="client">Azure NetApp Files Management Client</param>
/// <param name="account">Account object generated from information contained at the appsettings.json file at Accounts section</param>
/// <param name="activeDirectoryInfoList">Active Directory object list</param>
/// <returns>NetAppAccount object</returns>
public static async Task <NetAppAccount> CreateOrUpdateAnfAccountAsync(ProjectConfiguration config, AzureNetAppFilesManagementClient client, ModelNetAppAccount account, ActiveDirectory[] activeDirectories)
{
// Setting up NetApp Files account object and Active Directory Information
NetAppAccount anfAccount = new NetAppAccount(account.Location.ToLower(), null, account.Name, null, null, null, activeDirectories);
// Requesting account to be created
return(await client.Accounts.CreateOrUpdateAsync(anfAccount, config.ResourceGroup, account.Name));
}
/// <summary>
/// Creates or Updates Azure NetApp Files Account
/// </summary>
/// <param name="anfClient">ANF client object</param>
/// <param name="resourceGroupName">Resource group name</param>
/// <param name="location">Azure location</param>
/// <param name="accountName">Azure NetApp Files Account name</param>
/// <returns>NetApp Account object</returns>
public static async Task <NetAppAccount> CreateOrUpdateANFAccountAsync(AzureNetAppFilesManagementClient anfClient,
string resourceGroupName,
string location,
string accountName)
{
NetAppAccount anfAccountBody = new NetAppAccount(location, null, accountName);
return(await anfClient.Accounts.CreateOrUpdateAsync(anfAccountBody, resourceGroupName, accountName));
}
public static PSNetAppFilesAccount ToPsNetAppFilesAccount(this NetAppAccount netAppAccount)
{
return(new PSNetAppFilesAccount
{
ResourceGroupName = new ResourceIdentifier(netAppAccount.Id).ResourceGroupName,
Location = netAppAccount.Location,
Id = netAppAccount.Id,
Name = netAppAccount.Name,
Type = netAppAccount.Type,
Tags = netAppAccount.Tags,
ProvisioningState = netAppAccount.ProvisioningState
});
}
public static void CreateAccount(AzureNetAppFilesManagementClient netAppMgmtClient, string accountName = accountName1, string resourceGroup = resourceGroup, string location = location)
{
var netAppAccount = new NetAppAccount()
{
Location = location,
};
var resource = netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, resourceGroup, accountName);
Assert.Equal(resource.Name, accountName);
Thread.Sleep(delay); // some robustness against ARM caching
}
public override void ExecuteCmdlet()
{
var netAppAccountBody = new NetAppAccount()
{
Location = Location,
Tags = Tag
};
if (ShouldProcess(Name, "Create the new account"))
{
var anfAccount = AzureNetAppFilesManagementClient.Accounts.CreateOrUpdate(netAppAccountBody, ResourceGroupName, Name);
WriteObject(anfAccount.ToPsNetAppFilesAccount());
}
}
public static PSNetAppFilesAccount ToPsNetAppFilesAccount(this NetAppAccount netAppAccount)
{
return(new PSNetAppFilesAccount
{
ResourceGroupName = new ResourceIdentifier(netAppAccount.Id).ResourceGroupName,
Location = netAppAccount.Location,
Id = netAppAccount.Id,
Name = netAppAccount.Name,
Type = netAppAccount.Type,
Tags = netAppAccount.Tags,
ActiveDirectories = (netAppAccount.ActiveDirectories != null) ? ConvertActiveDirectoriesToPs(netAppAccount.ActiveDirectories) : null,
ProvisioningState = netAppAccount.ProvisioningState
});
}
public override void ExecuteCmdlet()
{
var netAppAccountBody = new NetAppAccount()
{
Location = Location,
ActiveDirectories = (ActiveDirectory != null) ? ModelExtensions.ConvertActiveDirectoriesFromPs(ActiveDirectory) : null,
Tags = Tag
};
if (ShouldProcess(Name, string.Format(PowerShell.Cmdlets.NetAppFiles.Properties.Resources.CreateResourceMessage, ResourceGroupName)))
{
var anfAccount = AzureNetAppFilesManagementClient.Accounts.CreateOrUpdate(netAppAccountBody, ResourceGroupName, Name);
WriteObject(anfAccount.ToPsNetAppFilesAccount());
}
}
public static PSNetAppFilesAccount ToPsNetAppFilesAccount(this NetAppAccount netAppAccount)
{
string resourceGroupName = new ResourceIdentifier(netAppAccount.Id).ResourceGroupName;
return(new PSNetAppFilesAccount
{
ResourceGroupName = resourceGroupName,
Location = netAppAccount.Location,
Id = netAppAccount.Id,
Name = netAppAccount.Name,
Type = netAppAccount.Type,
Tags = netAppAccount.Tags,
Etag = netAppAccount.Etag,
ActiveDirectories = (netAppAccount.ActiveDirectories != null) ? netAppAccount.ActiveDirectories.ConvertToPs(resourceGroupName, netAppAccount.Name) : null,
ProvisioningState = netAppAccount.ProvisioningState,
SystemData = netAppAccount.SystemData?.ToPsSystemData()
});
}
/// <summary>
/// Creates or retrieves an Azure NetApp Files Account
/// </summary>
/// <param name="config">Project Configuration file which contains the resource group needed</param>
/// <param name="client">Azure NetApp Files Management Client</param>
/// <param name="account">ModelNetAppAccount object that contains the data configured in the appsettings.json file for the ANF account</param>
/// <returns>NetAppCount object</returns>
private static async Task <NetAppAccount> CreateOrRetrieveAccountAsync(ProjectConfiguration config, AzureNetAppFilesManagementClient client, ModelNetAppAccount account)
{
// Creating ANF Account
NetAppAccount anfAccount = await GetResourceAsync <NetAppAccount>(client, config.ResourceGroup, account.Name);
if (anfAccount == null)
{
anfAccount = await CreateOrUpdateAnfAccountAsync(config, client, account);
Utils.WriteConsoleMessage($"\tAccount successfully created, resource id: {anfAccount.Id}");
}
else
{
Utils.WriteConsoleMessage($"\tAccount already exists, resource id: {anfAccount.Id}");
}
return(anfAccount);
}
public override void ExecuteCmdlet()
{
IDictionary <string, string> tagPairs = null;
if (Tag != null)
{
tagPairs = new Dictionary <string, string>();
foreach (string key in Tag.Keys)
{
tagPairs.Add(key, Tag[key].ToString());
}
}
NetAppAccount existingAccount = null;
try
{
existingAccount = AzureNetAppFilesManagementClient.Accounts.Get(ResourceGroupName, Name);
}
catch
{
existingAccount = null;
}
if (existingAccount != null)
{
throw new AzPSResourceNotFoundCloudException($"A NetAppAccount with name '{this.Name}' in resource group '{this.ResourceGroupName}' already exists. Only one active directory allowed. Please use Set/Update-AzNetAppFilesAccount to update an existing NetAppAccount.");
}
var netAppAccountBody = new NetAppAccount()
{
Location = Location,
ActiveDirectories = (ActiveDirectory != null) ? ActiveDirectory.ConvertFromPs() : null,
Tags = tagPairs
};
if (ShouldProcess(Name, string.Format(PowerShell.Cmdlets.NetAppFiles.Properties.Resources.CreateResourceMessage, ResourceGroupName)))
{
var anfAccount = AzureNetAppFilesManagementClient.Accounts.CreateOrUpdate(netAppAccountBody, ResourceGroupName, Name);
WriteObject(anfAccount.ToPsNetAppFilesAccount());
}
}
public static NetAppAccount CreateAccount(AzureNetAppFilesManagementClient netAppMgmtClient, string accountName = accountName1, string resourceGroup = resourceGroup, string location = location, object tags = null, ActiveDirectory activeDirectory = null)
{
var activeDirectories = new List <ActiveDirectory> {
activeDirectory
};
var netAppAccount = new NetAppAccount()
{
Location = location,
Tags = tags,
// current limitations of active directories make this problematic
// omitting tests on active directory properties for now
//ActiveDirectories = activeDirectories
ActiveDirectories = null
};
var resource = netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, resourceGroup, accountName);
Assert.Equal(resource.Name, accountName);
Thread.Sleep(delay); // some robustness against ARM caching
return(resource);
}
/// <summary>
/// Create or update a NetApp account
/// </summary>
/// <remarks>
/// Create or update the specified NetApp account within the resource group
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// NetApp Account object supplied in the body of the operation.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='accountName'>
/// The name of the NetApp account
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <NetAppAccount> BeginCreateOrUpdateAsync(this IAccountsOperations operations, NetAppAccount body, string resourceGroupName, string accountName, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(body, resourceGroupName, accountName, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Create or update a NetApp account
/// </summary>
/// <remarks>
/// Create or update the specified NetApp account within the resource group
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// NetApp Account object supplied in the body of the operation.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='accountName'>
/// The name of the NetApp account
/// </param>
public static NetAppAccount BeginCreateOrUpdate(this IAccountsOperations operations, NetAppAccount body, string resourceGroupName, string accountName)
{
return(operations.BeginCreateOrUpdateAsync(body, resourceGroupName, accountName).GetAwaiter().GetResult());
}
/// <summary>
/// Create or update a NetApp account
/// </summary>
/// <param name='body'>
/// NetApp Account object supplied in the body of the operation.
/// </param>
/// <param name='resourceGroup'>
/// The name of the resource group.
/// </param>
/// <param name='accountName'>
/// The name of the NetApp account
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <NetAppAccount> > BeginCreateOrUpdateWithHttpMessagesAsync(NetAppAccount body, string resourceGroup, string accountName, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (body == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "body");
}
if (body != null)
{
body.Validate();
}
if (Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
if (resourceGroup == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroup");
}
if (accountName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
}
if (Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("body", body);
tracingParameters.Add("resourceGroup", resourceGroup);
tracingParameters.Add("accountName", accountName);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "BeginCreateOrUpdate", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.NetApp/netAppAccounts/{accountName}").ToString();
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
_url = _url.Replace("{resourceGroup}", System.Uri.EscapeDataString(resourceGroup));
_url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
List <string> _queryParameters = new List <string>();
if (Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("PUT");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (body != null)
{
_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 201 && (int)_statusCode != 202)
{
var ex = new ErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
Error _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <Error>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <NetAppAccount>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 201)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <NetAppAccount>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Create or update a NetApp account
/// </summary>
/// <param name='body'>
/// NetApp Account object supplied in the body of the operation.
/// </param>
/// <param name='resourceGroup'>
/// The name of the resource group.
/// </param>
/// <param name='accountName'>
/// The name of the NetApp account
/// </param>
/// <param name='customHeaders'>
/// The headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public async Task <AzureOperationResponse <NetAppAccount> > CreateOrUpdateWithHttpMessagesAsync(NetAppAccount body, string resourceGroup, string accountName, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Send Request
AzureOperationResponse <NetAppAccount> _response = await BeginCreateOrUpdateWithHttpMessagesAsync(body, resourceGroup, accountName, customHeaders, cancellationToken).ConfigureAwait(false);
return(await Client.GetPutOrPatchOperationResultAsync(_response, customHeaders, cancellationToken).ConfigureAwait(false));
}
static private async Task RunAsync()
{
//---------------------------------------------------------------------------------------------------------------------
// Setting variables necessary for resources creation - change these to appropriated values related to your environment
//---------------------------------------------------------------------------------------------------------------------
string subscriptionId = "<subscriptionId>";
string location = "eastus2";
string resourceGroupName = "anf01-rg";
string vnetName = "vnet-02";
string subnetName = "anf-sn";
string vnetResourceGroupName = "anf01-rg";
string anfAccountName = "anfaccount03";
string capacityPoolName = "Pool01";
string capacityPoolServiceLevel = "Standard";
long capacitypoolSize = 4398046511104; // 4TiB which is minimum size
long volumeSize = 107374182400; // 100GiB - volume minimum size
//----------------------------------------------------------------------------------------
// Authenticating using service principal, refer to README.md file for requirement details
//----------------------------------------------------------------------------------------
WriteConsoleMessage("Authenticating...");
var credentials = await ServicePrincipalAuth.GetServicePrincipalCredential("AZURE_AUTH_LOCATION");
//------------------------------------------
// Instantiating a new ANF management client
//------------------------------------------
WriteConsoleMessage("Instantiating a new Azure NetApp Files management client...");
AzureNetAppFilesManagementClient anfClient = new AzureNetAppFilesManagementClient(credentials)
{
SubscriptionId = subscriptionId
};
WriteConsoleMessage($"\tApi Version: {anfClient.ApiVersion}");
//----------------------
// Creating ANF Account
//----------------------
// Setting up NetApp Files account body object
NetAppAccount anfAccountBody = new NetAppAccount(location, null, anfAccountName);
// Requesting account to be created
WriteConsoleMessage("Requesting account to be created...");
var anfAccount = await anfClient.Accounts.CreateOrUpdateAsync(anfAccountBody, resourceGroupName, anfAccountName);
WriteConsoleMessage($"\tAccount Resource Id: {anfAccount.Id}");
//-----------------------
// Creating Capacity Pool
//-----------------------
// Setting up capacity pool body object
CapacityPool capacityPoolBody = new CapacityPool()
{
Location = location.ToLower(), // Important: location needs to be lower case
ServiceLevel = capacityPoolServiceLevel,
Size = capacitypoolSize
};
// Creating capacity pool
WriteConsoleMessage("Requesting capacity pool to be created...");
var capacityPool = await anfClient.Pools.CreateOrUpdateAsync(capacityPoolBody, resourceGroupName, anfAccount.Name, capacityPoolName);
WriteConsoleMessage($"\tCapacity Pool Resource Id: {capacityPool.Id}");
//------------------------
// Creating NFS 4.1 Volume
//------------------------
// Creating export policy object
VolumePropertiesExportPolicy exportPolicies = new VolumePropertiesExportPolicy()
{
Rules = new List <ExportPolicyRule>
{
new ExportPolicyRule()
{
AllowedClients = "0.0.0.0",
Cifs = false,
Nfsv3 = false,
Nfsv41 = true,
RuleIndex = 1,
UnixReadOnly = false,
UnixReadWrite = true
}
}
};
// Creating volume body object
string subnetId = $"/subscriptions/{subscriptionId}/resourceGroups/{vnetResourceGroupName}/providers/Microsoft.Network/virtualNetworks/{vnetName}/subnets/{subnetName}";
string volumeName = $"Vol-{anfAccountName}-{capacityPoolName}";
Volume volumeBody = new Volume()
{
ExportPolicy = exportPolicies,
Location = location.ToLower(),
ServiceLevel = capacityPoolServiceLevel,
CreationToken = volumeName,
SubnetId = subnetId,
UsageThreshold = volumeSize,
ProtocolTypes = new List <string>()
{
"NFSv4.1"
}
};
// Creating NFS 4.1 volume
WriteConsoleMessage("Requesting volume to be created...");
var volume = await anfClient.Volumes.CreateOrUpdateAsync(volumeBody, resourceGroupName, anfAccount.Name, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id), volumeName);
WriteConsoleMessage($"\tVolume Resource Id: {volume.Id}");
//------------------------
// Cleaning up
//------------------------
//WriteConsoleMessage("Cleaning up created resources...");
//WriteConsoleMessage("\tDeleting volume...");
//await anfClient.Volumes.DeleteAsync(resourceGroupName, anfAccount.Name, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id), ResourceUriUtils.GetAnfVolume(volume.Id));
//// Adding a final verification if the resource completed deletion since it may have a few secs between ARM the Resource Provider be fully in sync
//await WaitForNoAnfResource<Volume>(anfClient, volume.Id);
//Utils.WriteConsoleMessage($"\t\tDeleted volume: {volume.Id}");
//WriteConsoleMessage("\tDeleting capacity pool...");
//await anfClient.Pools.DeleteAsync(resourceGroupName, anfAccount.Name, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id));
//await WaitForNoAnfResource<CapacityPool>(anfClient, capacityPool.Id);
//Utils.WriteConsoleMessage($"\t\tDeleted capacity pool: {capacityPool.Id}");
//WriteConsoleMessage("\tDeleting account...");
//await anfClient.Accounts.DeleteAsync(resourceGroupName, anfAccount.Name);
//await WaitForNoAnfResource<NetAppAccount>(anfClient, anfAccount.Id);
//Utils.WriteConsoleMessage($"\t\tDeleted account: {anfAccount.Id}");
}
static private async Task CreateANFCRRAsync()
{
//----------------------------------------------------------------------------------------
// Authenticating using service principal, refer to README.md file for requirement details
//----------------------------------------------------------------------------------------
WriteConsoleMessage("Authenticating...");
Credentials = await ServicePrincipalAuth.GetServicePrincipalCredential("AZURE_AUTH_LOCATION");
//------------------------------------------
// Instantiating a new ANF management client
//------------------------------------------
WriteConsoleMessage("Instantiating a new Azure NetApp Files management client...");
AzureNetAppFilesManagementClient anfClient = new AzureNetAppFilesManagementClient(Credentials)
{
SubscriptionId = subscriptionId
};
WriteConsoleMessage($"\tApi Version: {anfClient.ApiVersion}");
//----------------------
// Creating ANF Primary Account
//----------------------
// Setting up Primary NetApp Files account body object
NetAppAccount anfPrimaryAccountBody = new NetAppAccount(primaryLocation, null, primaryAnfAccountName);
WriteConsoleMessage($"Requesting Primary account to be created in {primaryLocation}");
var anfPrimaryAccount = await anfClient.Accounts.CreateOrUpdateAsync(anfPrimaryAccountBody, primaryResourceGroupName, primaryAnfAccountName);
WriteConsoleMessage($"\tAccount Resource Id: {anfPrimaryAccount.Id}");
// Setting up capacity pool body object for Primary Account
CapacityPool primaryCapacityPoolBody = new CapacityPool()
{
Location = primaryLocation.ToLower(), // Important: location needs to be lower case
ServiceLevel = ServiceLevel.Premium, //Service level can be one of three levels -> { Standard, Premium, Ultra }
Size = capacitypoolSize
};
WriteConsoleMessage("Requesting capacity pool to be created for Primary Account");
var primaryCapacityPool = await anfClient.Pools.CreateOrUpdateAsync(primaryCapacityPoolBody, primaryResourceGroupName, anfPrimaryAccount.Name, primarycapacityPoolName);
WriteConsoleMessage($"\tCapacity Pool Resource Id: {primaryCapacityPool.Id}");
// Creating export policy object
VolumePropertiesExportPolicy exportPolicies = new VolumePropertiesExportPolicy()
{
Rules = new List <ExportPolicyRule>
{
new ExportPolicyRule()
{
AllowedClients = "0.0.0.0",
Cifs = false,
Nfsv3 = false,
Nfsv41 = true,
RuleIndex = 1,
UnixReadOnly = false,
UnixReadWrite = true
}
}
};
// Creating primary volume body object
string primarySubnetId = $"/subscriptions/{subscriptionId}/resourceGroups/{primaryResourceGroupName}/providers/Microsoft.Network/virtualNetworks/{primaryVNETName}/subnets/{primarySubnetName}";
Volume primaryVolumeBody = new Volume()
{
ExportPolicy = exportPolicies,
Location = primaryLocation.ToLower(),
ServiceLevel = ServiceLevel.Premium, //Service level can be one of three levels -> { Standard, Premium, Ultra }
CreationToken = primaryVolumeName,
SubnetId = primarySubnetId,
UsageThreshold = volumeSize,
ProtocolTypes = new List <string>()
{
"NFSv4.1"
}
};
// Creating NFS 4.1 volume
WriteConsoleMessage($"Requesting volume to be created in {primarycapacityPoolName}");
var primaryVolume = await anfClient.Volumes.CreateOrUpdateAsync(primaryVolumeBody, primaryResourceGroupName, primaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(primaryCapacityPool.Id), primaryVolumeName);
WriteConsoleMessage($"\tVolume Resource Id: {primaryVolume.Id}");
WriteConsoleMessage($"Waiting for {primaryVolume.Id} to be available...");
await ResourceUriUtils.WaitForAnfResource <Volume>(anfClient, primaryVolume.Id);
//----------------------
// Creating ANF Secondary Account
//----------------------
// Setting up Secondary NetApp Files account body object
NetAppAccount anfSecondaryAccountBody = new NetAppAccount(secondaryLocation, null, secondaryAnfAccountName);
WriteConsoleMessage($"Requesting Secondary account to be created in {secondaryLocation}");
var anfSecondaryAccount = await anfClient.Accounts.CreateOrUpdateAsync(anfSecondaryAccountBody, secondaryResourceGroupName, secondaryAnfAccountName);
WriteConsoleMessage($"\tAccount Resource Id: {anfSecondaryAccount.Id}");
// Setting up capacity pool body object for Secondary Account
CapacityPool secondaryCapacityPoolBody = new CapacityPool()
{
Location = secondaryLocation.ToLower(), // Important: location needs to be lower case
ServiceLevel = ServiceLevel.Standard, //Service level can be one of three levels -> { Standard, Premium, Ultra }
Size = capacitypoolSize
};
WriteConsoleMessage("Requesting capacity pool to be created for Secondary Account");
var secondaryCapacityPool = await anfClient.Pools.CreateOrUpdateAsync(secondaryCapacityPoolBody, secondaryResourceGroupName, anfSecondaryAccount.Name, secondarycapacityPoolName);
WriteConsoleMessage($"\tCapacity Pool Resource Id: {secondaryCapacityPool.Id}");
// Creating secondary volume body object
string secondarySubnetId = $"/subscriptions/{subscriptionId}/resourceGroups/{secondaryResourceGroupName}/providers/Microsoft.Network/virtualNetworks/{secondaryVNETName}/subnets/{secondarySubnetName}";
Volume secondaryVolumeBody = new Volume()
{
ExportPolicy = exportPolicies,
Location = secondaryLocation.ToLower(),
ServiceLevel = ServiceLevel.Standard, //Service level can be one of three levels -> { Standard, Premium, Ultra },
CreationToken = secondaryVolumeName,
SubnetId = secondarySubnetId,
UsageThreshold = volumeSize,
ProtocolTypes = new List <string>()
{
"NFSv4.1"
},
VolumeType = "DataProtection",
DataProtection = new VolumePropertiesDataProtection()
{
Replication = new ReplicationObject()
{
EndpointType = "dst",
RemoteVolumeRegion = primaryLocation,
RemoteVolumeResourceId = primaryVolume.Id,
ReplicationSchedule = "_10minutely"
}
}
};
//-------------------------------------------------------------
// Creating Data Replication Volume on the Destination Account
//-------------------------------------------------------------
// Creating NFS 4.1 Data Replication Volume
WriteConsoleMessage("Adding Data Replication in Destination region...");
var dataReplicationVolume = await anfClient.Volumes.CreateOrUpdateAsync(secondaryVolumeBody, secondaryResourceGroupName, anfSecondaryAccount.Name, ResourceUriUtils.GetAnfCapacityPool(secondaryCapacityPool.Id), secondaryVolumeName);
//Wait for Data Replication Volume to get be ready
WriteConsoleMessage($"Waiting for {dataReplicationVolume.Id} to be available...");
await ResourceUriUtils.WaitForAnfResource <Volume>(anfClient, dataReplicationVolume.Id);
//--------------------------
// Authorizing Source volume
//--------------------------
AuthorizeRequest authRequest = new AuthorizeRequest()
{
RemoteVolumeResourceId = dataReplicationVolume.Id
};
WriteConsoleMessage("Authorizing replication in Source region...");
await anfClient.Volumes.AuthorizeReplicationAsync(primaryResourceGroupName, primaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(primaryCapacityPool.Id), primaryVolumeName, authRequest);
WriteConsoleMessage("ANF Cross-Region Replication has completed successfully");
//-----------------------------------------
// Clean up Resources
//-----------------------------------------
if (shouldCleanUp)
{
//Wait for replication status to be "Mirrored"
WriteConsoleMessage("Checking replication status to become Mirrored before start deleting...");
await ResourceUriUtils.WaitForCompleteReplicationStatus(anfClient, dataReplicationVolume.Id);
// Break the replication
WriteConsoleMessage("Breaking the replication connection");
await anfClient.Volumes.BreakReplicationAsync(secondaryResourceGroupName, secondaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(secondaryCapacityPool.Id), secondaryVolumeName);
// Check if replication status is "Broken"
WriteConsoleMessage("Checking replication status to become Broken... ");
await ResourceUriUtils.WaitForBrokenReplicationStatus(anfClient, dataReplicationVolume.Id);
// Delete replication and send confirmation to Source volume
WriteConsoleMessage("Deleting the replication connection on the destination volume");
await anfClient.Volumes.DeleteReplicationAsync(secondaryResourceGroupName, secondaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(secondaryCapacityPool.Id), secondaryVolumeName);
// Delete secondary ANF resources
WriteConsoleMessage("Deleting Secondary ANF resources...");
WriteConsoleMessage("Deleting Secondary Volume");
await anfClient.Volumes.DeleteAsync(secondaryResourceGroupName, secondaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(secondaryCapacityPool.Id), secondaryVolumeName);
// Wait for Data replication volume to be fully deleted
await ResourceUriUtils.WaitForNoAnfResource <Volume>(anfClient, dataReplicationVolume.Id);
// Delete secondary Capacity Pool
WriteConsoleMessage("Deleting Secondary Capacity Pool");
await anfClient.Pools.DeleteAsync(secondaryResourceGroupName, secondaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(secondaryCapacityPool.Id));
// wait for secondary Capacity Pool to be fully deleted
await ResourceUriUtils.WaitForNoAnfResource <CapacityPool>(anfClient, secondaryCapacityPool.Id);
// Delete Secondary ANF account
WriteConsoleMessage("Deleting Secondary Account");
await anfClient.Accounts.DeleteAsync(secondaryResourceGroupName, secondaryAnfAccountName);
// Delete primary ANF resources
WriteConsoleMessage("Deleting Primary ANF resources...");
WriteConsoleMessage("Deleting Primary Volume");
await anfClient.Volumes.DeleteAsync(primaryResourceGroupName, primaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(primaryCapacityPool.Id), primaryVolumeName);
// Wait for primary Volume to be fully deleted
await ResourceUriUtils.WaitForNoAnfResource <Volume>(anfClient, primaryVolume.Id);
// Delete primary capacity pool
WriteConsoleMessage("Deleting Primary Capacity Pool");
await anfClient.Pools.DeleteAsync(primaryResourceGroupName, primaryAnfAccountName, ResourceUriUtils.GetAnfCapacityPool(primaryCapacityPool.Id));
// Wait for primary capacity pool to be fully deleted
await ResourceUriUtils.WaitForNoAnfResource <CapacityPool>(anfClient, primaryCapacityPool.Id);
// Delete Primary ANF account
WriteConsoleMessage("Deleting Primary Account");
await anfClient.Accounts.DeleteAsync(primaryResourceGroupName, primaryAnfAccountName);
}
}
static private async Task RunAsync()
{
//---------------------------------------------------------------------------------------------------------------------
// Setting variables necessary for resources creation - change these to appropriated values related to your environment
//---------------------------------------------------------------------------------------------------------------------
bool cleanup = false;
string subscriptionId = "[Subscription Id]";
string location = "[Location]";
string resourceGroupName = "[Resource group name where ANF resources will be created]";
string vnetName = "[Existing Vnet Name]";
string subnetName = "[Existing Subnet where ANF volumes will be created]";
string vnetResourceGroupName = "[Vnet Resource Group Name]";
string anfAccountName = "[ANF Account Name]";
string capacityPoolName = "[ANF Capacity Pool Name]";
string capacityPoolServiceLevel = "Standard"; // Valid service levels are: Standard, Premium and Ultra
long capacitypoolSize = 4398046511104; // 4TiB which is minimum size
long volumeSize = 107374182400; // 100GiB - volume minimum size
// SMB/CIFS related variables
string domainJoinUsername = "******";
string dnsList = "[DNS Ip Address]"; // Please notice that this is a comma-separated string
string adFQDN = "[Active Directory FQDN]";
string smbServerNamePrefix = "[SMB Server Name Prefix]"; // this needs to be maximum 10 characters in length and during the domain join process a random string gets appended.
//------------------------------------------------------------------------------------------------------
// Getting Active Directory Identity's password (from identity that has rights to domain join computers)
//------------------------------------------------------------------------------------------------------
Console.WriteLine("Please type Active Directory's user password that will domain join ANF's SMB server and press [ENTER]:");
string DomainJoinUserPassword = Utils.GetConsolePassword();
// Basic validation
if (string.IsNullOrWhiteSpace(DomainJoinUserPassword))
{
throw new Exception("Invalid password, password cannot be null or empty string");
}
//----------------------------------------------------------------------------------------
// Authenticating using service principal, refer to README.md file for requirement details
//----------------------------------------------------------------------------------------
WriteConsoleMessage("Authenticating...");
var credentials = await ServicePrincipalAuth.GetServicePrincipalCredential("AZURE_AUTH_LOCATION");
//------------------------------------------
// Instantiating a new ANF management client
//------------------------------------------
WriteConsoleMessage("Instantiating a new Azure NetApp Files management client...");
AzureNetAppFilesManagementClient anfClient = new AzureNetAppFilesManagementClient(credentials)
{
SubscriptionId = subscriptionId
};
WriteConsoleMessage($"\tApi Version: {anfClient.ApiVersion}");
//----------------------
// Creating ANF Account
//----------------------
NetAppAccount anfAccount = await GetResourceAsync <NetAppAccount>(anfClient, resourceGroupName, anfAccountName);
if (anfAccount == null)
{
// Setting up Active Directories Object
// Despite of this being a list, currently ANF accepts only one Active Directory object and only one Active Directory should exist per subscription.
List <ActiveDirectory> activeDirectories = new List <ActiveDirectory>()
{
new ActiveDirectory()
{
Dns = dnsList,
Domain = adFQDN,
Username = domainJoinUsername,
Password = DomainJoinUserPassword,
SmbServerName = smbServerNamePrefix
}
};
// Setting up NetApp Files account body object
NetAppAccount anfAccountBody = new NetAppAccount()
{
Location = location.ToLower(), // Important: location needs to be lower case,
ActiveDirectories = activeDirectories
};
// Requesting account to be created
WriteConsoleMessage("Creating account...");
anfAccount = await anfClient.Accounts.CreateOrUpdateAsync(anfAccountBody, resourceGroupName, anfAccountName);
}
else
{
WriteConsoleMessage("Account already exists...");
}
WriteConsoleMessage($"\tAccount Resource Id: {anfAccount.Id}");
//-----------------------
// Creating Capacity Pool
//-----------------------
CapacityPool capacityPool = await GetResourceAsync <CapacityPool>(anfClient, resourceGroupName, anfAccountName, capacityPoolName);
if (capacityPool == null)
{
// Setting up capacity pool body object
CapacityPool capacityPoolBody = new CapacityPool()
{
Location = location.ToLower(),
ServiceLevel = capacityPoolServiceLevel,
Size = capacitypoolSize
};
// Creating capacity pool
WriteConsoleMessage("Creating capacity pool...");
capacityPool = await anfClient.Pools.CreateOrUpdateAsync(capacityPoolBody, resourceGroupName, anfAccount.Name, capacityPoolName);
}
else
{
WriteConsoleMessage("Capacity pool already exists...");
}
WriteConsoleMessage($"\tCapacity Pool Resource Id: {capacityPool.Id}");
//------------------------
// Creating SMB Volume
//------------------------
string volumeName = $"Vol-{anfAccountName}-{capacityPoolName}";
Volume volume = await GetResourceAsync <Volume>(anfClient, resourceGroupName, anfAccountName, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id), volumeName);
if (volume == null)
{
string subnetId = $"/subscriptions/{subscriptionId}/resourceGroups/{vnetResourceGroupName}/providers/Microsoft.Network/virtualNetworks/{vnetName}/subnets/{subnetName}";
// Creating volume body object
Volume volumeBody = new Volume()
{
Location = location.ToLower(),
ServiceLevel = capacityPoolServiceLevel,
CreationToken = volumeName,
SubnetId = subnetId,
UsageThreshold = volumeSize,
ProtocolTypes = new List <string>()
{
"CIFS"
} // Despite of this being a list, only one protocol is supported at this time
};
// Creating SMB volume
// Please notice that the SMB Server gets created at this point by using information stored in ANF Account resource about Active Directory
WriteConsoleMessage("Creating volume...");
volume = await anfClient.Volumes.CreateOrUpdateAsync(volumeBody, resourceGroupName, anfAccount.Name, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id), volumeName);
}
else
{
WriteConsoleMessage("Volume already exists...");
}
WriteConsoleMessage($"\tVolume Resource Id: {volume.Id}");
//// Outputs SMB Server Name
WriteConsoleMessage($"\t====> SMB Server FQDN: {volume.MountTargets[0].SmbServerFqdn}");
//------------------------
// Cleaning up
//------------------------
if (cleanup)
{
WriteConsoleMessage("Cleaning up created resources...");
WriteConsoleMessage("\tDeleting volume...");
await anfClient.Volumes.DeleteAsync(resourceGroupName, anfAccount.Name, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id), ResourceUriUtils.GetAnfVolume(volume.Id));
// Adding a final verification if the resource completed deletion since it may have a few secs between ARM the Resource Provider be fully in sync
await WaitForNoAnfResource <Volume>(anfClient, volume.Id);
Utils.WriteConsoleMessage($"\t\tDeleted volume: {volume.Id}");
WriteConsoleMessage("\tDeleting capacity pool...");
await anfClient.Pools.DeleteAsync(resourceGroupName, anfAccount.Name, ResourceUriUtils.GetAnfCapacityPool(capacityPool.Id));
await WaitForNoAnfResource <CapacityPool>(anfClient, capacityPool.Id);
Utils.WriteConsoleMessage($"\t\tDeleted capacity pool: {capacityPool.Id}");
WriteConsoleMessage("\tDeleting account...");
await anfClient.Accounts.DeleteAsync(resourceGroupName, anfAccount.Name);
await WaitForNoAnfResource <NetAppAccount>(anfClient, anfAccount.Id);
Utils.WriteConsoleMessage($"\t\tDeleted account: {anfAccount.Id}");
}
}
/// <summary>
/// Removes all created resources
/// </summary>
/// <returns></returns>
public static async Task RunCleanupTasksSampleAsync(ProjectConfiguration config, AzureNetAppFilesManagementClient anfClient)
{
//
// Cleaning up snapshots
//
Utils.WriteConsoleMessage("Cleaning up snapshots...");
List <Task> snapshotCleanupTasks = new List <Task>();
foreach (ModelNetAppAccount anfAcct in config.Accounts)
{
if (anfAcct.CapacityPools != null)
{
foreach (ModelCapacityPool pool in anfAcct.CapacityPools)
{
if (pool.Volumes != null)
{
foreach (ModelVolume volume in pool.Volumes)
{
IEnumerable <Snapshot> anfSnapshotList = await CommonSdk.ListResourceAsync <Snapshot>(anfClient, config.ResourceGroup, anfAcct.Name, pool.Name, volume.Name);
if (anfSnapshotList != null && anfSnapshotList.Count() > 0)
{
// Snapshot Name property (and other ANF's related nested resources) returns a relative path up to the name
// and to use this property with DeleteAsync for example, the argument needs to be sanitized and just the
// actual name needs to be used.
// Snapshot Name poperty example: "pmarques-anf01/pool01/pmarques-anf01-pool01-vol01/test-a"
// "test-a" is the actual name that needs to be used instead. Below you will see a sample function that
// parses the name from snapshot resource id
snapshotCleanupTasks.AddRange(anfSnapshotList.ToList().Select(
async snapshot =>
{
await anfClient.Snapshots.DeleteAsync(config.ResourceGroup, anfAcct.Name, pool.Name, volume.Name, ResourceUriUtils.GetAnfSnapshot(snapshot.Id));
Utils.WriteConsoleMessage($"\tDeleted snapshot: {snapshot.Id}");
}).ToList());
}
}
}
}
}
}
await WaitForTasksCompletion(snapshotCleanupTasks).ConfigureAwait(false);
//
// Cleaning up all volumes
//
// Note: Volume deletion operations at the RP level are executed serially
Utils.WriteConsoleMessage("Cleaning up Volumes...");
foreach (ModelNetAppAccount anfAcct in config.Accounts)
{
if (anfAcct.CapacityPools != null)
{
foreach (ModelCapacityPool pool in anfAcct.CapacityPools)
{
if (pool.Volumes != null)
{
IEnumerable <Volume> anfVolumeList = await CommonSdk.ListResourceAsync <Volume>(anfClient, config.ResourceGroup, anfAcct.Name, pool.Name);
if (anfVolumeList != null && anfVolumeList.Count() > 0)
{
foreach (Volume volume in anfVolumeList)
{
try
{
await anfClient.Volumes.DeleteAsync(config.ResourceGroup, anfAcct.Name, pool.Name, ResourceUriUtils.GetAnfVolume(volume.Id));
Utils.WriteConsoleMessage($"\tDeleted volume: {volume.Id}");
}
catch (Exception ex)
{
Utils.WriteErrorMessage($"An error ocurred while deleting volume {volume.Id}.\nError message: {ex.Message}");
throw;
}
}
}
}
else
{
Utils.WriteConsoleMessage($"\tNo volumes defined for Account: {anfAcct.Name}, Capacity Pool: {pool.Name}");
}
}
}
}
//
// Cleaning up capacity pools
//
Utils.WriteConsoleMessage("Cleaning up capacity pools...");
List <Task> poolCleanupTasks = new List <Task>();
foreach (ModelNetAppAccount anfAcct in config.Accounts)
{
if (anfAcct.CapacityPools != null)
{
poolCleanupTasks.AddRange(anfAcct.CapacityPools.Select(
async pool =>
{
CapacityPool anfPool = await GetResourceAsync <CapacityPool>(anfClient, config.ResourceGroup, anfAcct.Name, pool.Name);
if (anfPool != null)
{
await anfClient.Pools.DeleteAsync(config.ResourceGroup, anfAcct.Name, ResourceUriUtils.GetAnfCapacityPool(anfPool.Id));
Utils.WriteConsoleMessage($"\tDeleted volume: {anfPool.Id}");
}
}).ToList());
}
}
await WaitForTasksCompletion(poolCleanupTasks).ConfigureAwait(false);
//
// Cleaning up accounts
//
Utils.WriteConsoleMessage("Cleaning up accounts...");
List <Task> accountCleanupTasks = new List <Task>();
if (config.Accounts != null)
{
accountCleanupTasks.AddRange(config.Accounts.Select(
async account =>
{
NetAppAccount anfAccount = await GetResourceAsync <NetAppAccount>(anfClient, config.ResourceGroup, account.Name);
if (anfAccount != null)
{
await anfClient.Accounts.DeleteAsync(config.ResourceGroup, anfAccount.Name);
Utils.WriteConsoleMessage($"\tDeleted account: {anfAccount.Id}");
}
}).ToList());
}
await WaitForTasksCompletion(accountCleanupTasks).ConfigureAwait(false);
}
