public virtual Response <CheckNameAvailabilityResult> CheckNameAvailability(VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("VaultsOperations.CheckNameAvailability");
scope.Start();
try
{
return(RestClient.CheckNameAvailability(vaultName, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <Microsoft.Azure.Management.KeyVault.Models.CheckNameAvailabilityResult> ValidateKeyVaultName(
Guid subscriptionId, string resourceGroupName, string keyVaultName)
{
var accessToken = await GetAccessToken();
var token = new TokenCredentials(accessToken);
var kvClient = new KeyVaultManagementClient(token)
{
SubscriptionId = subscriptionId.ToString()
};
var param = new VaultCheckNameAvailabilityParameters {
Name = keyVaultName
};
var result = await kvClient.Vaults.CheckNameAvailabilityAsync(param);
if (!result.NameAvailable.GetValueOrDefault(true))
{
// The name isn't available, let's see if it's our KV
bool available = false;
try
{
await kvClient.Vaults.GetAsync(resourceGroupName, keyVaultName);
available = true;
}
catch (CloudException ce)
{
if (!ce.ResourceNotFound())
{
_logger.LogError(ce,
$"Exception validating Key Vault {keyVaultName} " +
$"in resource group {resourceGroupName} " +
$"in subscription {subscriptionId} " +
$"with request {ce.RequestId}");
throw;
}
}
return(new Microsoft.Azure.Management.KeyVault.Models.CheckNameAvailabilityResult(available, result.Reason, result.Message));
}
return(result);
}
public async Task <Microsoft.Azure.Management.KeyVault.Models.CheckNameAvailabilityResult> ValidateKeyVaultName(Guid subscriptionId, string resourceGroupName, string keyVaultName)
{
var accessToken = await GetAccessToken();
var token = new TokenCredentials(accessToken);
var kvClient = new KeyVaultManagementClient(token)
{
SubscriptionId = subscriptionId.ToString()
};
var param = new VaultCheckNameAvailabilityParameters {
Name = keyVaultName
};
var result = await kvClient.Vaults.CheckNameAvailabilityAsync(param);
if (!result.NameAvailable.GetValueOrDefault(true))
{
// The name isn't available, let's see if it's our KV
bool available = false;
try
{
await kvClient.Vaults.GetAsync(resourceGroupName, keyVaultName);
available = true;
}
catch (CloudException ce)
{
if (ce.Body.Code != "NotFound")
{
throw;
}
}
return(new Microsoft.Azure.Management.KeyVault.Models.CheckNameAvailabilityResult(available));
}
return(result);
}
public virtual Response <CheckNameAvailabilityResult> CheckKeyVaultNameAvailability(VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
using var scope = VaultsClientDiagnostics.CreateScope("SubscriptionResourceExtensionClient.CheckKeyVaultNameAvailability");
scope.Start();
try
{
var response = VaultsRestClient.CheckNameAvailability(Id.SubscriptionId, vaultName, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityAsync(VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("VaultsOperations.CheckNameAvailability");
scope.Start();
try
{
return(await RestClient.CheckNameAvailabilityAsync(vaultName, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async static Task <Response <CheckNameAvailabilityResult> > CheckKeyVaultNameAvailabilityAsync(this Subscription subscription, VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(vaultName, nameof(vaultName));
return(await GetExtensionClient(subscription).CheckKeyVaultNameAvailabilityAsync(vaultName, cancellationToken).ConfigureAwait(false));
}
public static Response <CheckNameAvailabilityResult> CheckKeyVaultNameAvailability(this Subscription subscription, VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(vaultName, nameof(vaultName));
return(GetExtensionClient(subscription).CheckKeyVaultNameAvailability(vaultName, cancellationToken));
}
/// <summary>
/// Checks that the vault name is valid and is not already in use.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='vaultName'>
/// The name of the vault.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <CheckNameAvailabilityResult> CheckNameAvailabilityAsync(this IVaultsOperations operations, VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CheckNameAvailabilityWithHttpMessagesAsync(vaultName, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Checks that the vault name is valid and is not already in use.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='vaultName'>
/// The name of the vault.
/// </param>
public static CheckNameAvailabilityResult CheckNameAvailability(this IVaultsOperations operations, VaultCheckNameAvailabilityParameters vaultName)
{
return(operations.CheckNameAvailabilityAsync(vaultName).GetAwaiter().GetResult());
}
public Task <AzureOperationResponse <CheckNameAvailabilityResult> > CheckNameAvailabilityWithHttpMessagesAsync(VaultCheckNameAvailabilityParameters vaultName, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default)
{
throw new NotImplementedException();
}
public static Response <CheckNameAvailabilityResult> CheckNameAvailabilityVault(this Subscription subscription, VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
if (vaultName == null)
{
throw new ArgumentNullException(nameof(vaultName));
}
return(subscription.UseClientContext((baseUri, credential, options, pipeline) =>
{
var clientDiagnostics = new ClientDiagnostics(options);
using var scope = clientDiagnostics.CreateScope("SubscriptionExtensions.CheckNameAvailabilityVault");
scope.Start();
try
{
var restOperations = GetVaultsRestOperations(clientDiagnostics, credential, options, pipeline, baseUri);
var response = restOperations.CheckNameAvailability(subscription.Id.SubscriptionId, vaultName, cancellationToken);
return response;
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
));
}
public async virtual Task <Response <CheckNameAvailabilityResult> > CheckKeyVaultNameAvailabilityAsync(VaultCheckNameAvailabilityParameters vaultName, CancellationToken cancellationToken = default)
{
if (vaultName == null)
{
throw new ArgumentNullException(nameof(vaultName));
}
using var scope = VaultsClientDiagnostics.CreateScope("SubscriptionExtensionClient.CheckKeyVaultNameAvailability");
scope.Start();
try
{
var response = await VaultsRestClient.CheckNameAvailabilityAsync(Id.SubscriptionId, vaultName, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
