public virtual async Task <Response <CheckNameAvailabilityResponse> > CheckNameAvailabilityAsync(CheckNameAvailabilityRequest parameters, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("ServersOperations.CheckNameAvailability"); scope.Start(); try { return(await RestClient.CheckNameAvailabilityAsync(parameters, cancellationToken).ConfigureAwait(false)); } catch (Exception e) { scope.Failed(e); throw; } }
public static Response <CheckNameAvailabilityResponse> CheckNameAvailabilityServer(this Subscription subscription, CheckNameAvailabilityRequest parameters, CancellationToken cancellationToken = default) { Argument.AssertNotNull(parameters, nameof(parameters)); return(GetExtensionClient(subscription).CheckNameAvailabilityServer(parameters, cancellationToken)); }
public static Response <CheckNameAvailabilityResponse> CheckNameAvailability(this Subscription subscription, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { if (request == null) { throw new ArgumentNullException(nameof(request)); } return(subscription.UseClientContext((baseUri, credential, options, pipeline) => { var clientDiagnostics = new ClientDiagnostics(options); using var scope = clientDiagnostics.CreateScope("SubscriptionExtensions.CheckNameAvailability"); scope.Start(); try { var restOperations = GetDeviceUpdateRestOperations(clientDiagnostics, credential, options, pipeline, baseUri); var response = restOperations.CheckNameAvailability(subscription.Id.SubscriptionId, request, cancellationToken); return response; } catch (Exception e) { scope.Failed(e); throw; } } )); }
public static async Task <Response <CheckNameAvailabilityResponse> > CheckDeviceUpdateNameAvailabilityAsync(this SubscriptionResource subscriptionResource, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { Argument.AssertNotNull(request, nameof(request)); return(await GetExtensionClient(subscriptionResource).CheckDeviceUpdateNameAvailabilityAsync(request, cancellationToken).ConfigureAwait(false)); }
internal HttpMessage CreateCheckNameAvailabilityRequest(string subscriptionId, CheckNameAvailabilityRequest request) { var message = _pipeline.CreateMessage(); var request0 = message.Request; request0.Method = RequestMethod.Post; var uri = new RawRequestUriBuilder(); uri.Reset(endpoint); uri.AppendPath("/subscriptions/", false); uri.AppendPath(subscriptionId, true); uri.AppendPath("/providers/Microsoft.DeviceUpdate/checknameavailability", false); uri.AppendQuery("api-version", apiVersion, true); request0.Uri = uri; request0.Headers.Add("Accept", "application/json"); request0.Headers.Add("Content-Type", "application/json"); var content = new Utf8JsonRequestContent(); content.JsonWriter.WriteObjectValue(request); request0.Content = content; message.SetProperty("UserAgentOverride", _userAgent); return(message); }
/// <summary> /// Check name availability /// </summary> /// <remarks> /// Check whether a workspace name is available /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='request'> /// The check request /// </param> public static CheckNameAvailabilityResponse CheckNameAvailability(this IOperations operations, CheckNameAvailabilityRequest request) { return(operations.CheckNameAvailabilityAsync(request).GetAwaiter().GetResult()); }
/// <summary> /// Checks the resource name availability. /// </summary> /// <remarks> /// Checks if resource name is available. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. The name is case insensitive. /// </param> /// <param name='managedEnvironmentName'> /// Name of the Managed Environment. /// </param> /// <param name='checkNameAvailabilityRequest'> /// The check name availability request. /// </param> public static CheckNameAvailabilityResponse CheckNameAvailability(this INamespacesOperations operations, string resourceGroupName, string managedEnvironmentName, CheckNameAvailabilityRequest checkNameAvailabilityRequest) { return(operations.CheckNameAvailabilityAsync(resourceGroupName, managedEnvironmentName, checkNameAvailabilityRequest).GetAwaiter().GetResult()); }
/// <summary> /// Checks the account name availability. /// </summary> /// <remarks> /// Checks if account name is available. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkNameAvailabilityRequest'> /// The check name availability request. /// </param> public static CheckNameAvailabilityResult CheckNameAvailability(this IAccountsOperations operations, CheckNameAvailabilityRequest checkNameAvailabilityRequest) { return(operations.CheckNameAvailabilityAsync(checkNameAvailabilityRequest).GetAwaiter().GetResult()); }
public static async Task <Response <CheckNameAvailabilityResponse> > CheckDeviceUpdateNameAvailabilityAsync(this Subscription subscription, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { return(await GetExtensionClient(subscription).CheckDeviceUpdateNameAvailabilityAsync(request, cancellationToken).ConfigureAwait(false)); }
public static Response <CheckNameAvailabilityResponse> CheckDeviceUpdateNameAvailability(this Subscription subscription, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { return(GetExtensionClient(subscription).CheckDeviceUpdateNameAvailability(request, cancellationToken)); }
/// <summary> /// Checks if the specified management group name is valid and unique /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='checkNameAvailabilityRequest'> /// Management group name availability check parameters. /// </param> public static CheckNameAvailabilityResult CheckNameAvailability(this IManagementGroupsAPIClient operations, CheckNameAvailabilityRequest checkNameAvailabilityRequest) { return(operations.CheckNameAvailabilityAsync(checkNameAvailabilityRequest).GetAwaiter().GetResult()); }
/// <summary> /// API to check for resource name availability /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group where the backup vault is present. /// </param> /// <param name='location'> /// The location in which uniqueness will be verified. /// </param> /// <param name='parameters'> /// Check name availability request /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <CheckNameAvailabilityResult> CheckNameAvailabilityAsync(this IBackupVaultsOperations operations, string resourceGroupName, string location, CheckNameAvailabilityRequest parameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CheckNameAvailabilityWithHttpMessagesAsync(resourceGroupName, location, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// API to check for resource name availability /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group where the backup vault is present. /// </param> /// <param name='location'> /// The location in which uniqueness will be verified. /// </param> /// <param name='parameters'> /// Check name availability request /// </param> public static CheckNameAvailabilityResult CheckNameAvailability(this IBackupVaultsOperations operations, string resourceGroupName, string location, CheckNameAvailabilityRequest parameters) { return(operations.CheckNameAvailabilityAsync(resourceGroupName, location, parameters).GetAwaiter().GetResult()); }
/// <summary> /// Check Name Availability for global uniqueness /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='location'> /// The location in which uniqueness will be verified. /// </param> /// <param name='checkNameAvailability'> /// Check Name Availability Request. /// </param> public static CheckNameAvailabilityResponse CheckNameAvailabilityLocal(this IMixedRealityClient operations, string location, CheckNameAvailabilityRequest checkNameAvailability) { return(operations.CheckNameAvailabilityLocalAsync(location, checkNameAvailability).GetAwaiter().GetResult()); }
/// <summary> /// Checks the resource name availability. /// </summary> /// <remarks> /// Checks if resource name is available. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. The name is case insensitive. /// </param> /// <param name='managedEnvironmentName'> /// Name of the Managed Environment. /// </param> /// <param name='checkNameAvailabilityRequest'> /// The check name availability request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <CheckNameAvailabilityResponse> CheckNameAvailabilityAsync(this INamespacesOperations operations, string resourceGroupName, string managedEnvironmentName, CheckNameAvailabilityRequest checkNameAvailabilityRequest, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CheckNameAvailabilityWithHttpMessagesAsync(resourceGroupName, managedEnvironmentName, checkNameAvailabilityRequest, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Check Name Availability for global uniqueness /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='location'> /// The location in which uniqueness will be verified. /// </param> /// <param name='checkNameAvailability'> /// Check Name Availability Request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <CheckNameAvailabilityResponse> CheckNameAvailabilityLocalAsync(this IMixedRealityClient operations, string location, CheckNameAvailabilityRequest checkNameAvailability, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CheckNameAvailabilityLocalWithHttpMessagesAsync(location, checkNameAvailability, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public virtual async Task <Response <CheckNameAvailabilityResponse> > CheckDeviceUpdateNameAvailabilityAsync(CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { using var scope = DefaultClientDiagnostics.CreateScope("SubscriptionResourceExtensionClient.CheckDeviceUpdateNameAvailability"); scope.Start(); try { var response = await DefaultRestClient.CheckNameAvailabilityAsync(Id.SubscriptionId, request, cancellationToken).ConfigureAwait(false); return(response); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Check name availability /// </summary> /// <remarks> /// Check whether a workspace name is available /// </remarks> /// <param name='request'> /// The check request /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorContractException"> /// 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 <HttpOperationResponse <CheckNameAvailabilityResponse> > CheckNameAvailabilityWithHttpMessagesAsync(CheckNameAvailabilityRequest request, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (Client.ApiVersion == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion"); } if (Client.ApiVersion != null) { if (Client.ApiVersion.Length < 1) { throw new ValidationException(ValidationRules.MinLength, "Client.ApiVersion", 1); } } if (Client.SubscriptionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId"); } if (Client.SubscriptionId != null) { if (Client.SubscriptionId.Length < 1) { throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1); } } if (request == null) { throw new ValidationException(ValidationRules.CannotBeNull, "request"); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("request", request); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "CheckNameAvailability", tracingParameters); } // Construct URL var _baseUrl = Client.BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/providers/Microsoft.Synapse/checkNameAvailability").ToString(); _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId)); 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 += "?" + string.Join("&", _queryParameters); } // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers 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 (request != null) { _requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(request, 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"); } // 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 != 200) { var ex = new ErrorContractException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorContract _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorContract>(_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 HttpOperationResponse <CheckNameAvailabilityResponse>(); _result.Request = _httpRequest; _result.Response = _httpResponse; // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <CheckNameAvailabilityResponse>(_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> /// Check Name Availability for global uniqueness /// </summary> /// <param name='location'> /// The location in which uniqueness will be verified. /// </param> /// <param name='checkNameAvailability'> /// Check Name Availability Request. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorResponseException"> /// 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 <CheckNameAvailabilityResponse> > CheckNameAvailabilityLocalWithHttpMessagesAsync(string location, CheckNameAvailabilityRequest checkNameAvailability, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (SubscriptionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.SubscriptionId"); } if (location == null) { throw new ValidationException(ValidationRules.CannotBeNull, "location"); } if (location != null) { if (location.Length > 90) { throw new ValidationException(ValidationRules.MaxLength, "location", 90); } if (location.Length < 1) { throw new ValidationException(ValidationRules.MinLength, "location", 1); } if (!System.Text.RegularExpressions.Regex.IsMatch(location, "^[-\\w\\._\\(\\)]+$")) { throw new ValidationException(ValidationRules.Pattern, "location", "^[-\\w\\._\\(\\)]+$"); } } if (checkNameAvailability == null) { throw new ValidationException(ValidationRules.CannotBeNull, "checkNameAvailability"); } if (checkNameAvailability != null) { checkNameAvailability.Validate(); } if (ApiVersion == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.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("location", location); tracingParameters.Add("checkNameAvailability", checkNameAvailability); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "CheckNameAvailabilityLocal", tracingParameters); } // Construct URL var _baseUrl = BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/providers/Microsoft.MixedReality/locations/{location}/checkNameAvailability").ToString(); _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(SubscriptionId)); _url = _url.Replace("{location}", System.Uri.EscapeDataString(location)); List <string> _queryParameters = new List <string>(); if (ApiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(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("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (GenerateClientRequestId != null && GenerateClientRequestId.Value) { _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString()); } if (AcceptLanguage != null) { if (_httpRequest.Headers.Contains("accept-language")) { _httpRequest.Headers.Remove("accept-language"); } _httpRequest.Headers.TryAddWithoutValidation("accept-language", 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 (checkNameAvailability != null) { _requestContent = SafeJsonConvert.SerializeObject(checkNameAvailability, 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 (Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorResponse _errorBody = SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, 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 <CheckNameAvailabilityResponse>(); _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 == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <CheckNameAvailabilityResponse>(_responseContent, 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); }
public async Task <Response <CheckNameAvailabilityResponse> > CheckNameAvailabilityAsync(string subscriptionId, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { if (subscriptionId == null) { throw new ArgumentNullException(nameof(subscriptionId)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } using var message = CreateCheckNameAvailabilityRequest(subscriptionId, request); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 200: { CheckNameAvailabilityResponse value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); value = CheckNameAvailabilityResponse.DeserializeCheckNameAvailabilityResponse(document.RootElement); return(Response.FromValue(value, message.Response)); }
/// <summary> /// Determines whether a resource can be created with the specified name. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='parameters'> /// The parameters to request for name availability. /// </param> public static CheckNameAvailabilityResponse CheckNameAvailability(this IServersOperations operations, CheckNameAvailabilityRequest parameters) { return(operations.CheckNameAvailabilityAsync(parameters).GetAwaiter().GetResult()); }
/// <summary> /// Check name availability /// </summary> /// <remarks> /// Check whether a workspace name is available /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='request'> /// The check request /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <CheckNameAvailabilityResponse> CheckNameAvailabilityAsync(this IOperations operations, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CheckNameAvailabilityWithHttpMessagesAsync(request, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public virtual Response <CheckNameAvailabilityResponse> CheckDeviceUpdateNameAvailability(CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { using var scope = DefaultClientDiagnostics.CreateScope("SubscriptionExtensionClient.CheckDeviceUpdateNameAvailability"); scope.Start(); try { var response = DefaultRestClient.CheckNameAvailability(Id.SubscriptionId, request, 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="checkNameAvailabilityRequest"> Management group name availability check parameters. </param> /// <param name="cancellationToken"> The cancellation token to use. </param> public async virtual Task <Response <CheckNameAvailabilityResult> > CheckNameAvailabilityAsync(CheckNameAvailabilityRequest checkNameAvailabilityRequest, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("ManagementGroupContainer.CheckNameAvailability"); scope.Start(); try { return(await _restClient.CheckNameAvailabilityAsync(checkNameAvailabilityRequest, cancellationToken).ConfigureAwait(false)); } catch (Exception e) { scope.Failed(e); throw; } }
public async static Task <Response <CheckNameAvailabilityResponse> > CheckNameAvailabilityServerAsync(this Subscription subscription, CheckNameAvailabilityRequest parameters, CancellationToken cancellationToken = default) { Argument.AssertNotNull(parameters, nameof(parameters)); return(await GetExtensionClient(subscription).CheckNameAvailabilityServerAsync(parameters, cancellationToken).ConfigureAwait(false)); }
public static Response <CheckNameAvailabilityResponse> CheckDeviceUpdateNameAvailability(this SubscriptionResource subscriptionResource, CheckNameAvailabilityRequest request, CancellationToken cancellationToken = default) { Argument.AssertNotNull(request, nameof(request)); return(GetExtensionClient(subscriptionResource).CheckDeviceUpdateNameAvailability(request, cancellationToken)); }
public virtual Response <CheckNameAvailabilityResponse> CheckNameAvailability(CheckNameAvailabilityRequest parameters, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("ServersOperations.CheckNameAvailability"); scope.Start(); try { return(RestClient.CheckNameAvailability(parameters, cancellationToken)); } catch (Exception e) { scope.Failed(e); throw; } }