public async Task CheckNameAvailability()
{
var rq = new CheckNameAvailabilityOptions();
rq.Name = "this-should-not-exist";
var rs = await Client.GetManagementGroups().CheckNameAvailabilityAsync(rq);
Assert.IsTrue(rs.Value.NameAvailable);
}
/// <summary> Checks if the specified management group name is valid and unique. </summary>
/// <param name="checkNameAvailabilityOptions"> Management group name availability check parameters. </param>
/// <param name="cancellationToken"> The cancellation token to use. </param>
public virtual Response <CheckNameAvailabilityResult> CheckNameAvailability(CheckNameAvailabilityOptions checkNameAvailabilityOptions, CancellationToken cancellationToken = default)
{
using var scope = Diagnostics.CreateScope("ManagementGroupContainer.CheckNameAvailability");
scope.Start();
try
{
return(RestClient.CheckNameAvailability(checkNameAvailabilityOptions, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual Response <CheckNameAvailabilityResult> CheckNameAvailability(CheckNameAvailabilityOptions checkNameAvailabilityRequest, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(checkNameAvailabilityRequest, nameof(checkNameAvailabilityRequest));
using var scope = _managementGroupClientDiagnostics.CreateScope("ManagementGroupCollection.CheckNameAvailability");
scope.Start();
try
{
var response = _managementGroupRestClient.CheckNameAvailability(checkNameAvailabilityRequest, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual Response <CheckNameAvailabilityResult> CheckDisasterRecoveryNameAvailability(CheckNameAvailabilityOptions options, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(options, nameof(options));
using var scope = _disasterRecoveryConfigsClientDiagnostics.CreateScope("EventHubNamespaceResource.CheckDisasterRecoveryNameAvailability");
scope.Start();
try
{
var response = _disasterRecoveryConfigsRestClient.CheckNameAvailability(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, options, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityDisasterRecoveryConfigAsync(CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _disasterRecoveryConfigsClientDiagnostics.CreateScope("EventHubNamespace.CheckNameAvailabilityDisasterRecoveryConfig");
scope.Start();
try
{
var response = await _disasterRecoveryConfigsRestClient.CheckNameAvailabilityAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, parameters, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityAsync(CheckNameAvailabilityOptions checkNameAvailabilityRequest, CancellationToken cancellationToken = default)
{
if (checkNameAvailabilityRequest == null)
{
throw new ArgumentNullException(nameof(checkNameAvailabilityRequest));
}
using var scope = _managementGroupClientDiagnostics.CreateScope("ManagementGroupCollection.CheckNameAvailability");
scope.Start();
try
{
var response = await _managementGroupRestClient.CheckNameAvailabilityAsync(checkNameAvailabilityRequest, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual Response <CheckNameAvailabilityResult> CheckNameAvailabilityNamespace(CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = NamespacesClientDiagnostics.CreateScope("SubscriptionExtensionClient.CheckNameAvailabilityNamespace");
scope.Start();
try
{
var response = NamespacesRestClient.CheckNameAvailability(Id.SubscriptionId, parameters, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public static Response <CheckNameAvailabilityResult> CheckNameAvailabilityNamespace(this Subscription subscription, CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(parameters, nameof(parameters));
return(GetExtensionClient(subscription).CheckNameAvailabilityNamespace(parameters, cancellationToken));
}
public async static Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityNamespaceAsync(this Subscription subscription, CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(parameters, nameof(parameters));
return(await GetExtensionClient(subscription).CheckNameAvailabilityNamespaceAsync(parameters, cancellationToken).ConfigureAwait(false));
}
public static Response <CheckNameAvailabilityResult> CheckEventHubNameAvailability(this SubscriptionResource subscriptionResource, CheckNameAvailabilityOptions options, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(options, nameof(options));
return(GetExtensionClient(subscriptionResource).CheckEventHubNameAvailability(options, cancellationToken));
}
public static async Task <Response <CheckNameAvailabilityResult> > CheckEventHubNameAvailabilityAsync(this SubscriptionResource subscriptionResource, CheckNameAvailabilityOptions options, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(options, nameof(options));
return(await GetExtensionClient(subscriptionResource).CheckEventHubNameAvailabilityAsync(options, cancellationToken).ConfigureAwait(false));
}
public virtual Response<CheckNameAvailabilityResult> CheckEventHubNameAvailability(CheckNameAvailabilityOptions options, CancellationToken cancellationToken = default)
{
using var scope = NamespacesClientDiagnostics.CreateScope("SubscriptionResourceExtensionClient.CheckEventHubNameAvailability");
scope.Start();
try
{
var response = NamespacesRestClient.CheckNameAvailability(Id.SubscriptionId, options, cancellationToken);
return response;
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityNamespaceAsync(CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
using var scope = NamespacesClientDiagnostics.CreateScope("SubscriptionExtensionClient.CheckNameAvailabilityNamespace");
scope.Start();
try
{
var response = await NamespacesRestClient.CheckNameAvailabilityAsync(Id.SubscriptionId, parameters, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual Response <CheckNameAvailabilityResult> CheckNameAvailabilityDisasterRecoveryConfig(CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _disasterRecoveryConfigsClientDiagnostics.CreateScope("EventHubNamespace.CheckNameAvailabilityDisasterRecoveryConfig");
scope.Start();
try
{
var response = _disasterRecoveryConfigsRestClient.CheckNameAvailability(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, parameters, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public static Response <CheckNameAvailabilityResult> CheckNameAvailabilityNamespace(this Subscription subscription, CheckNameAvailabilityOptions parameters, CancellationToken cancellationToken = default)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
return(subscription.UseClientContext((baseUri, credential, options, pipeline) =>
{
var clientDiagnostics = new ClientDiagnostics(options);
using var scope = clientDiagnostics.CreateScope("SubscriptionExtensions.CheckNameAvailabilityNamespace");
scope.Start();
try
{
var restOperations = GetNamespacesRestOperations(clientDiagnostics, credential, options, pipeline, baseUri);
var response = restOperations.CheckNameAvailability(subscription.Id.SubscriptionId, parameters, cancellationToken);
return response;
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
));
}
/// <summary> Checks if the specified management group name is valid and unique. </summary>
/// <param name="checkNameAvailabilityOptions"> Management group name availability check parameters. </param>
/// <param name="cancellationToken"> The cancellation token to use. </param>
public async virtual Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityAsync(CheckNameAvailabilityOptions checkNameAvailabilityOptions, CancellationToken cancellationToken = default)
{
using var scope = Diagnostics.CreateScope("ManagementGroupContainer.CheckNameAvailability");
scope.Start();
try
{
return(await RestClient.CheckNameAvailabilityAsync(checkNameAvailabilityOptions, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
