private async ValueTask <Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
{
if (!_hasCompleted)
{
using DiagnosticScope? scope = _diagnostics?.CreateScope($"{nameof(SparkSessionOperation)}.{nameof(UpdateStatus)}");
scope?.Start();
try
{
// Get the latest status
Response <SparkBatchJob> update = async
? await _client.GetSparkBatchJobAsync(_batchId, true, cancellationToken).ConfigureAwait(false)
: _client.GetSparkBatchJob(_batchId, true, cancellationToken);
// Check if the operation is no longer running
_hasCompleted = IsJobComplete(update.Value.Result ?? SparkBatchJobResultType.Uncertain, update.Value.State.Value, _completionType);
if (_hasCompleted)
{
_hasValue = true;
_value = update.Value;
}
// Update raw response
_rawResponse = update.GetRawResponse();
}
catch (Exception e)
{
scope?.Failed(e);
throw;
}
}
return(GetRawResponse());
}
public async virtual Task <ArmOperation <JobCredential> > CreateOrUpdateAsync(bool waitForCompletion, string credentialName, JobCredentialData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(credentialName, nameof(credentialName));
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _jobCredentialClientDiagnostics.CreateScope("JobCredentialCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _jobCredentialRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, credentialName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new SqlArmOperation <JobCredential>(Response.FromValue(new JobCredential(Client, response), response.GetRawResponse()));
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <AfdEndpoint> > CreateOrUpdateAsync(bool waitForCompletion, string endpointName, AfdEndpointData endpointInput, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(endpointName, nameof(endpointName));
if (endpointInput == null)
{
throw new ArgumentNullException(nameof(endpointInput));
}
using var scope = _afdEndpointClientDiagnostics.CreateScope("AfdEndpointCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _afdEndpointRestClient.CreateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, endpointName, endpointInput, cancellationToken).ConfigureAwait(false);
var operation = new CdnArmOperation <AfdEndpoint>(new AfdEndpointOperationSource(Client), _afdEndpointClientDiagnostics, Pipeline, _afdEndpointRestClient.CreateCreateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, endpointName, endpointInput).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <ManagedInstancePrivateEndpointConnection> > CreateOrUpdateAsync(bool waitForCompletion, string privateEndpointConnectionName, ManagedInstancePrivateEndpointConnectionData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(privateEndpointConnectionName, nameof(privateEndpointConnectionName));
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _managedInstancePrivateEndpointConnectionClientDiagnostics.CreateScope("ManagedInstancePrivateEndpointConnectionCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _managedInstancePrivateEndpointConnectionRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, privateEndpointConnectionName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new SqlArmOperation <ManagedInstancePrivateEndpointConnection>(new ManagedInstancePrivateEndpointConnectionOperationSource(Client), _managedInstancePrivateEndpointConnectionClientDiagnostics, Pipeline, _managedInstancePrivateEndpointConnectionRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, privateEndpointConnectionName, parameters).Request, response, OperationFinalStateVia.Location);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual AzureFirewallCreateOrUpdateOperation CreateOrUpdate(string azureFirewallName, AzureFirewallData parameters, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (azureFirewallName == null)
{
throw new ArgumentNullException(nameof(azureFirewallName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("AzureFirewallCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _azureFirewallsRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, azureFirewallName, parameters, cancellationToken);
var operation = new AzureFirewallCreateOrUpdateOperation(Parent, _clientDiagnostics, Pipeline, _azureFirewallsRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, azureFirewallName, parameters).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <LinkedServiceResource> > GetLinkedServiceAsync(string linkedServiceName, string ifNoneMatch = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("LinkedServiceClient.GetLinkedService");
scope.Start();
try
{
return(await RestClient.GetLinkedServiceAsync(linkedServiceName, ifNoneMatch, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <object> > GetOperationResultAsync(string operationId, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("LibraryClient.GetOperationResult");
scope.Start();
try
{
return(await RestClient.GetOperationResultAsync(operationId, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <VirtualMachineRunCommand> > GetAsync(string expand = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("VirtualMachineRunCommand.Get");
scope.Start();
try
{
var response = await _virtualMachineRunCommandsRestClient.GetByVirtualMachineAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, expand, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new VirtualMachineRunCommand(this, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <AuthorizationRule> > GetAuthorizationRuleAsync(string resourceGroupName, string namespaceName, string @alias, string authorizationRuleName, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("DisasterRecoveryConfigsClient.GetAuthorizationRule");
scope.Start();
try
{
return(await RestClient.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, @alias, authorizationRuleName, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <ApplicationGateway> > CreateOrUpdateAsync(WaitUntil waitUntil, string applicationGatewayName, ApplicationGatewayData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(applicationGatewayName, nameof(applicationGatewayName));
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _applicationGatewayClientDiagnostics.CreateScope("ApplicationGatewayCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _applicationGatewayRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, applicationGatewayName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <ApplicationGateway>(new ApplicationGatewayOperationSource(Client), _applicationGatewayClientDiagnostics, Pipeline, _applicationGatewayRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, applicationGatewayName, parameters).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <DateTimeOffset> > GetNullAsync(CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("Datetimerfc1123Client.GetNull");
scope.Start();
try
{
return(await RestClient.GetNullAsync(cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual QueueCreateOperation CreateOrUpdate(string queueName, StorageQueueData queue, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (queueName == null)
{
throw new ArgumentNullException(nameof(queueName));
}
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
using var scope = _clientDiagnostics.CreateScope("StorageQueueContainer.CreateOrUpdate");
scope.Start();
try
{
var response = _restClient.Create(Id.ResourceGroupName, Id.Parent.Name, Id.Name, queueName, queue, cancellationToken);
var operation = new QueueCreateOperation(Parent, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response> DeleteValueAsync(string tagName, string tagValue, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("TagsOperations.DeleteValue");
scope.Start();
try
{
return(await RestClient.DeleteValueAsync(tagName, tagValue, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <HostingEnvironmentMultiRolePool> > GetAsync(CancellationToken cancellationToken = default)
{
using var scope = _hostingEnvironmentMultiRolePoolAppServiceEnvironmentsClientDiagnostics.CreateScope("HostingEnvironmentMultiRolePool.Get");
scope.Start();
try
{
var response = await _hostingEnvironmentMultiRolePoolAppServiceEnvironmentsRestClient.GetMultiRolePoolAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _hostingEnvironmentMultiRolePoolAppServiceEnvironmentsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new HostingEnvironmentMultiRolePool(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ServiceEndpointPolicyDefinitionCreateOrUpdateOperation CreateOrUpdate(string serviceEndpointPolicyDefinitionName, ServiceEndpointPolicyDefinitionData serviceEndpointPolicyDefinitions, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (serviceEndpointPolicyDefinitionName == null)
{
throw new ArgumentNullException(nameof(serviceEndpointPolicyDefinitionName));
}
if (serviceEndpointPolicyDefinitions == null)
{
throw new ArgumentNullException(nameof(serviceEndpointPolicyDefinitions));
}
using var scope = _clientDiagnostics.CreateScope("ServiceEndpointPolicyDefinitionCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _restClient.CreateOrUpdate(Id.ResourceGroupName, Id.Name, serviceEndpointPolicyDefinitionName, serviceEndpointPolicyDefinitions, cancellationToken);
var operation = new ServiceEndpointPolicyDefinitionCreateOrUpdateOperation(Parent, _clientDiagnostics, Pipeline, _restClient.CreateCreateOrUpdateRequest(Id.ResourceGroupName, Id.Name, serviceEndpointPolicyDefinitionName, serviceEndpointPolicyDefinitions).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <AvailableClustersList> > ListAvailableClustersAsync(CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ClustersOperations.ListAvailableClusters");
scope.Start();
try
{
return(await RestClient.ListAvailableClustersAsync(cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <Struct> > OperationAsync(string request, string message, string scope, string uri, string pipeline, string clientDiagnostics, Class @class, CancellationToken cancellationToken = default)
{
using var scope0 = _clientDiagnostics.CreateScope("ServiceClient.Operation");
scope0.Start();
try
{
return(await RestClient.OperationAsync(request, message, scope, uri, pipeline, clientDiagnostics, @class, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope0.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <PrivateEndpointConnection> > CreateOrUpdateAsync(bool waitForCompletion, string peConnectionName, PrivateEndpointConnectionData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(peConnectionName, nameof(peConnectionName));
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _privateEndpointConnectionPrivateLinkServicesClientDiagnostics.CreateScope("PrivateEndpointConnectionCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _privateEndpointConnectionPrivateLinkServicesRestClient.UpdatePrivateEndpointConnectionAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, peConnectionName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new NetworkArmOperation <PrivateEndpointConnection>(Response.FromValue(new PrivateEndpointConnection(Client, response), response.GetRawResponse()));
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <DatabaseAccountGremlinDatabaseThroughputSettingResource> > GetAsync(CancellationToken cancellationToken = default)
{
using var scope = _databaseAccountGremlinDatabaseThroughputSettingGremlinResourcesClientDiagnostics.CreateScope("DatabaseAccountGremlinDatabaseThroughputSettingResource.Get");
scope.Start();
try
{
var response = await _databaseAccountGremlinDatabaseThroughputSettingGremlinResourcesRestClient.GetGremlinDatabaseThroughputAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw new RequestFailedException(response.GetRawResponse());
}
return(Response.FromValue(new DatabaseAccountGremlinDatabaseThroughputSettingResource(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <NetworkVirtualAppliance> > GetAsync(string resourceGroupName, string networkVirtualApplianceName, string expand = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("NetworkVirtualAppliancesClient.Get");
scope.Start();
try
{
return(await RestClient.GetAsync(resourceGroupName, networkVirtualApplianceName, expand, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <ManagedHsmResource> > GetAsync(CancellationToken cancellationToken = default)
{
using var scope = _managedHsmClientDiagnostics.CreateScope("ManagedHsmResource.Get");
scope.Start();
try
{
var response = await _managedHsmRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw new RequestFailedException(response.GetRawResponse());
}
return(Response.FromValue(new ManagedHsmResource(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual AfdSecretCreateOrUpdateOperation CreateOrUpdate(bool waitForCompletion, string secretName, AfdSecretData secret, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(secretName, nameof(secretName));
if (secret == null)
{
throw new ArgumentNullException(nameof(secret));
}
using var scope = _afdSecretClientDiagnostics.CreateScope("AfdSecretCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _afdSecretRestClient.Create(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, secretName, secret, cancellationToken);
var operation = new AfdSecretCreateOrUpdateOperation(ArmClient, _afdSecretClientDiagnostics, Pipeline, _afdSecretRestClient.CreateCreateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, secretName, secret).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <GalleryApplication> > GetAsync(CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("GalleryApplication.Get");
scope.Start();
try
{
var response = await _galleryApplicationsRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new GalleryApplication(this, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Get all role definitions that are applicable at scope and above.
/// </summary>
/// <param name="roleScope"> The scope of the role assignments. </param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"><paramref name="roleScope"/> is null.</exception>
public virtual Pageable <KeyVaultRoleDefinition> GetRoleDefinitions(KeyVaultRoleScope roleScope, CancellationToken cancellationToken = default)
{
return(PageableHelpers.CreateEnumerable(_ =>
{
using DiagnosticScope scope = _diagnostics.CreateScope($"{nameof(KeyVaultAccessControlClient)}.{nameof(GetRoleDefinitions)}");
scope.Start();
try
{
var response = _definitionsRestClient.List(vaultBaseUrl: VaultUri.AbsoluteUri, scope: roleScope.ToString(), cancellationToken: cancellationToken);
return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}, (nextLink, _) =>
{
using DiagnosticScope scope = _diagnostics.CreateScope($"{nameof(KeyVaultAccessControlClient)}.{nameof(GetRoleDefinitions)}");
scope.Start();
try
{
var response = _definitionsRestClient.ListNextPage(nextLink: nextLink, vaultBaseUrl: VaultUri.AbsoluteUri, scope: roleScope.ToString(), cancellationToken: cancellationToken);
return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}));
}
public virtual DiskCreateOrUpdateOperation CreateOrUpdate(string diskName, DiskData disk, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (diskName == null)
{
throw new ArgumentNullException(nameof(diskName));
}
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var scope = _clientDiagnostics.CreateScope("DiskCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _restClient.CreateOrUpdate(Id.ResourceGroupName, diskName, disk, cancellationToken);
var operation = new DiskCreateOrUpdateOperation(Parent, _clientDiagnostics, Pipeline, _restClient.CreateCreateOrUpdateRequest(Id.ResourceGroupName, diskName, disk).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary> Get the properties of the manifest that uniquely identifies this artifact. </summary>
/// <param name="cancellationToken"> The cancellation token to use. </param>
/// <exception cref="RequestFailedException">Thrown when a failure is returned by the Container Registry service.</exception>
public virtual async Task <Response <ArtifactManifestProperties> > GetManifestPropertiesAsync(CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(RegistryArtifact)}.{nameof(GetManifestProperties)}");
scope.Start();
try
{
string digest = await GetDigestAsync(cancellationToken).ConfigureAwait(false);
return(await _restClient.GetManifestPropertiesAsync(_repositoryName, digest, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual NatGatewayCreateOrUpdateOperation CreateOrUpdate(bool waitForCompletion, string natGatewayName, NatGatewayData parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(natGatewayName, nameof(natGatewayName));
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _natGatewayClientDiagnostics.CreateScope("NatGatewayCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _natGatewayRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, natGatewayName, parameters, cancellationToken);
var operation = new NatGatewayCreateOrUpdateOperation(ArmClient, _natGatewayClientDiagnostics, Pipeline, _natGatewayRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, natGatewayName, parameters).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <Application> > GetAsync(string resourceGroupName, string applicationName, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ApplicationsClient.Get");
scope.Start();
try
{
return(await RestClient.GetAsync(resourceGroupName, applicationName, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Starts a translation operation which translates the document(s) in your source container
/// to your <see cref="TranslationTarget"/>(s) in the given language.
/// <para>For document length limits, maximum batch size, and supported document formats, see
/// <a href="https://docs.microsoft.com/azure/cognitive-services/translator/document-translation/overview"/>.</para>
/// </summary>
/// <param name="inputs">Sets the inputs for the translation operation
/// including source and target containers for documents to be translated. </param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <exception cref="RequestFailedException">Service returned a non-success status code. </exception>
public virtual DocumentTranslationOperation StartTranslation(IEnumerable <DocumentTranslationInput> inputs, CancellationToken cancellationToken = default)
{
var request = new StartTranslationDetails(inputs);
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(StartTranslation)}");
scope.Start();
try
{
ResponseWithHeaders <DocumentTranslationStartTranslationHeaders> job = _serviceRestClient.StartTranslation(request, cancellationToken);
return(new DocumentTranslationOperation(_serviceRestClient, _clientDiagnostics, job.Headers.OperationLocation));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <VMwareHost> > CreateOrUpdateAsync(bool waitForCompletion, string hostName, VMwareHostData body = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(hostName, nameof(hostName));
using var scope = _vMwareHostHostsClientDiagnostics.CreateScope("VMwareHostCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _vMwareHostHostsRestClient.CreateAsync(Id.SubscriptionId, Id.ResourceGroupName, hostName, body, cancellationToken).ConfigureAwait(false);
var operation = new ConnectedVMwarevSphereArmOperation <VMwareHost>(new VMwareHostOperationSource(Client), _vMwareHostHostsClientDiagnostics, Pipeline, _vMwareHostHostsRestClient.CreateCreateRequest(Id.SubscriptionId, Id.ResourceGroupName, hostName, body).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
