public async virtual Task <Response <GalleryImageVersion> > GetAsync(string galleryImageVersionName, ReplicationStatusTypes?expand = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(galleryImageVersionName, nameof(galleryImageVersionName));
using var scope = _galleryImageVersionClientDiagnostics.CreateScope("GalleryImageVersionCollection.Get");
scope.Start();
try
{
var response = await _galleryImageVersionRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, galleryImageVersionName, expand, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _galleryImageVersionClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new GalleryImageVersion(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <TopLevelDomain> > GetAsync(string name, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(name, nameof(name));
using var scope = _topLevelDomainClientDiagnostics.CreateScope("TopLevelDomainCollection.Get");
scope.Start();
try
{
var response = await _topLevelDomainRestClient.GetAsync(Id.SubscriptionId, name, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _topLevelDomainClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new TopLevelDomain(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <DiskAccess> > GetAsync(string diskAccessName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(diskAccessName, nameof(diskAccessName));
using var scope = _diskAccessClientDiagnostics.CreateScope("DiskAccessCollection.Get");
scope.Start();
try
{
var response = await _diskAccessRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, diskAccessName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _diskAccessClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new DiskAccess(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ManagementGroupPolicySetDefinition> > GetAsync(string policySetDefinitionName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(policySetDefinitionName, nameof(policySetDefinitionName));
using var scope = _managementGroupPolicySetDefinitionPolicySetDefinitionsClientDiagnostics.CreateScope("ManagementGroupPolicySetDefinitionCollection.Get");
scope.Start();
try
{
var response = await _managementGroupPolicySetDefinitionPolicySetDefinitionsRestClient.GetAtManagementGroupAsync(Id.Name, policySetDefinitionName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _managementGroupPolicySetDefinitionPolicySetDefinitionsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ManagementGroupPolicySetDefinition(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ManagedInstanceDatabaseSchema> > GetAsync(string schemaName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(schemaName, nameof(schemaName));
using var scope = _managedInstanceDatabaseSchemaManagedDatabaseSchemasClientDiagnostics.CreateScope("ManagedInstanceDatabaseSchemaCollection.Get");
scope.Start();
try
{
var response = await _managedInstanceDatabaseSchemaManagedDatabaseSchemasRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, schemaName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _managedInstanceDatabaseSchemaManagedDatabaseSchemasClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ManagedInstanceDatabaseSchema(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <Gallery> > GetAsync(string galleryName, SelectPermissions?select = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(galleryName, nameof(galleryName));
using var scope = _galleryClientDiagnostics.CreateScope("GalleryCollection.Get");
scope.Start();
try
{
var response = await _galleryRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, galleryName, select, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _galleryClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new Gallery(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <Response> GetAsync(string operationId, CancellationToken cancellationToken = default)
{
if (operationId == null)
{
throw new ArgumentNullException(nameof(operationId));
}
using var message = CreateGetRequest(operationId);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
case 201:
case 202:
case 204:
return(message.Response);
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
public async virtual Task <Response <NetworkVirtualApplianceSku> > GetAsync(string skuName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(skuName, nameof(skuName));
using var scope = _networkVirtualApplianceSkuVirtualApplianceSkusClientDiagnostics.CreateScope("NetworkVirtualApplianceSkuCollection.Get");
scope.Start();
try
{
var response = await _networkVirtualApplianceSkuVirtualApplianceSkusRestClient.GetAsync(Id.SubscriptionId, skuName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _networkVirtualApplianceSkuVirtualApplianceSkusClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new NetworkVirtualApplianceSku(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <SiteInstanceProcessModule> > GetAsync(string baseAddress, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(baseAddress, nameof(baseAddress));
using var scope = _siteInstanceProcessModuleWebAppsClientDiagnostics.CreateScope("SiteInstanceProcessModuleCollection.Get");
scope.Start();
try
{
var response = await _siteInstanceProcessModuleWebAppsRestClient.GetInstanceProcessModuleAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, baseAddress, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _siteInstanceProcessModuleWebAppsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new SiteInstanceProcessModule(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ExpressRouteCircuitAuthorization> > GetAsync(string authorizationName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(authorizationName, nameof(authorizationName));
using var scope = _expressRouteCircuitAuthorizationClientDiagnostics.CreateScope("ExpressRouteCircuitAuthorizationCollection.Get");
scope.Start();
try
{
var response = await _expressRouteCircuitAuthorizationRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, authorizationName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _expressRouteCircuitAuthorizationClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ExpressRouteCircuitAuthorization(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <OSFamily> > GetAsync(string osFamilyName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(osFamilyName, nameof(osFamilyName));
using var scope = _osFamilyCloudServiceOperatingSystemsClientDiagnostics.CreateScope("OSFamilyCollection.Get");
scope.Start();
try
{
var response = await _osFamilyCloudServiceOperatingSystemsRestClient.GetOSFamilyAsync(Id.SubscriptionId, _location, osFamilyName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _osFamilyCloudServiceOperatingSystemsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new OSFamily(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ResourceGroupLongTermRetentionBackup> > GetAsync(string backupName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(backupName, nameof(backupName));
using var scope = _resourceGroupLongTermRetentionBackupLongTermRetentionBackupsClientDiagnostics.CreateScope("ResourceGroupLongTermRetentionBackupCollection.Get");
scope.Start();
try
{
var response = await _resourceGroupLongTermRetentionBackupLongTermRetentionBackupsRestClient.GetByResourceGroupAsync(Id.SubscriptionId, Id.ResourceGroupName, _locationName, _longTermRetentionServerName, _longTermRetentionDatabaseName, backupName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _resourceGroupLongTermRetentionBackupLongTermRetentionBackupsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ResourceGroupLongTermRetentionBackup(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <SiteSlotDiagnosticAnalysis> > GetAsync(string analysisName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(analysisName, nameof(analysisName));
using var scope = _siteSlotDiagnosticAnalysisDiagnosticsClientDiagnostics.CreateScope("SiteSlotDiagnosticAnalysisCollection.Get");
scope.Start();
try
{
var response = await _siteSlotDiagnosticAnalysisDiagnosticsRestClient.GetSiteAnalysisSlotAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, analysisName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _siteSlotDiagnosticAnalysisDiagnosticsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new SiteSlotDiagnosticAnalysis(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <DataPolicyManifest> > GetAsync(string policyMode, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(policyMode, nameof(policyMode));
using var scope = _dataPolicyManifestClientDiagnostics.CreateScope("DataPolicyManifestCollection.Get");
scope.Start();
try
{
var response = await _dataPolicyManifestRestClient.GetByPolicyModeAsync(policyMode, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _dataPolicyManifestClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new DataPolicyManifest(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <CapacityReservation> > GetAsync(string capacityReservationName, CapacityReservationInstanceViewTypes?expand = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(capacityReservationName, nameof(capacityReservationName));
using var scope = _capacityReservationClientDiagnostics.CreateScope("CapacityReservationCollection.Get");
scope.Start();
try
{
var response = await _capacityReservationRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, capacityReservationName, expand, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _capacityReservationClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new CapacityReservation(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <VaultKeyVersion> > GetAsync(string keyVersion, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(keyVersion, nameof(keyVersion));
using var scope = _vaultKeyVersionKeysClientDiagnostics.CreateScope("VaultKeyVersionCollection.Get");
scope.Start();
try
{
var response = await _vaultKeyVersionKeysRestClient.GetVersionAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, keyVersion, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _vaultKeyVersionKeysClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new VaultKeyVersion(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Get tags with the resource.
/// </summary>
/// <param name="cancellationToken"> A token to allow the caller to cancel the call to the service. The default value is <see cref="CancellationToken.None" />. </param>
/// <returns> The tags associate with resource. </returns>
public virtual async Task <Response <TagResource> > GetAsync(CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("TagResource.GetAtScope");
scope.Start();
try
{
var response = await _restClient.GetAtScopeAsync(Id, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new TagResource(this, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <SiteSlotDetector> > GetAsync(string detectorName, DateTimeOffset?startTime = null, DateTimeOffset?endTime = null, string timeGrain = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(detectorName, nameof(detectorName));
using var scope = _siteSlotDetectorDiagnosticsClientDiagnostics.CreateScope("SiteSlotDetectorCollection.Get");
scope.Start();
try
{
var response = await _siteSlotDetectorDiagnosticsRestClient.GetSiteDetectorResponseSlotAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, detectorName, startTime, endTime, timeGrain, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _siteSlotDetectorDiagnosticsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new SiteSlotDetector(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <VirtualMachineScaleSetVmExtension> > GetAsync(string vmExtensionName, string expand = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(vmExtensionName, nameof(vmExtensionName));
using var scope = _virtualMachineScaleSetVmExtensionVirtualMachineScaleSetVMExtensionsClientDiagnostics.CreateScope("VirtualMachineScaleSetVmExtensionCollection.Get");
scope.Start();
try
{
var response = await _virtualMachineScaleSetVmExtensionVirtualMachineScaleSetVMExtensionsRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, vmExtensionName, expand, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _virtualMachineScaleSetVmExtensionVirtualMachineScaleSetVMExtensionsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new VirtualMachineScaleSetVmExtension(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ServerDatabaseVulnerabilityAssessmentScan> > GetAsync(string scanId, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(scanId, nameof(scanId));
using var scope = _serverDatabaseVulnerabilityAssessmentScanDatabaseVulnerabilityAssessmentScansClientDiagnostics.CreateScope("ServerDatabaseVulnerabilityAssessmentScanCollection.Get");
scope.Start();
try
{
var response = await _serverDatabaseVulnerabilityAssessmentScanDatabaseVulnerabilityAssessmentScansRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, scanId, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _serverDatabaseVulnerabilityAssessmentScanDatabaseVulnerabilityAssessmentScansClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ServerDatabaseVulnerabilityAssessmentScan(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ServiceEndpointPolicyDefinition> > GetAsync(string serviceEndpointPolicyDefinitionName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(serviceEndpointPolicyDefinitionName, nameof(serviceEndpointPolicyDefinitionName));
using var scope = _serviceEndpointPolicyDefinitionClientDiagnostics.CreateScope("ServiceEndpointPolicyDefinitionCollection.Get");
scope.Start();
try
{
var response = await _serviceEndpointPolicyDefinitionRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, serviceEndpointPolicyDefinitionName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _serviceEndpointPolicyDefinitionClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ServiceEndpointPolicyDefinition(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ServerJobAgentJobVersionStep> > GetAsync(string stepName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(stepName, nameof(stepName));
using var scope = _serverJobAgentJobVersionStepJobStepsClientDiagnostics.CreateScope("ServerJobAgentJobVersionStepCollection.Get");
scope.Start();
try
{
var response = await _serverJobAgentJobVersionStepJobStepsRestClient.GetByVersionAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Parent.Name, Id.Parent.Parent.Name, Id.Parent.Name, int.Parse(Id.Name), stepName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _serverJobAgentJobVersionStepJobStepsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ServerJobAgentJobVersionStep(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <SiteRecommendation> > GetAsync(string name, bool?updateSeen = null, string recommendationId = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(name, nameof(name));
using var scope = _siteRecommendationRecommendationsClientDiagnostics.CreateScope("SiteRecommendationCollection.Get");
scope.Start();
try
{
var response = await _siteRecommendationRecommendationsRestClient.GetRuleDetailsByWebAppAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, name, updateSeen, recommendationId, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _siteRecommendationRecommendationsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new SiteRecommendation(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <TemplateSpec> > GetAsync(string templateSpecName, TemplateSpecExpandKind?expand = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(templateSpecName, nameof(templateSpecName));
using var scope = _templateSpecClientDiagnostics.CreateScope("TemplateSpecCollection.Get");
scope.Start();
try
{
var response = await _templateSpecRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, templateSpecName, expand, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _templateSpecClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new TemplateSpec(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <SiteDeployment> > GetAsync(string id, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(id, nameof(id));
using var scope = _siteDeploymentWebAppsClientDiagnostics.CreateScope("SiteDeploymentCollection.Get");
scope.Start();
try
{
var response = await _siteDeploymentWebAppsRestClient.GetDeploymentAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, id, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _siteDeploymentWebAppsClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new SiteDeployment(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <StaticSiteBuildARMResource> > GetAsync(string environmentName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(environmentName, nameof(environmentName));
using var scope = _staticSiteBuildARMResourceStaticSitesClientDiagnostics.CreateScope("StaticSiteBuildARMResourceCollection.Get");
scope.Start();
try
{
var response = await _staticSiteBuildARMResourceStaticSitesRestClient.GetStaticSiteBuildAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, environmentName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _staticSiteBuildARMResourceStaticSitesClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new StaticSiteBuildARMResource(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <VirtualNetworkGatewayNatRule> > GetAsync(string natRuleName, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(natRuleName, nameof(natRuleName));
using var scope = _virtualNetworkGatewayNatRuleClientDiagnostics.CreateScope("VirtualNetworkGatewayNatRuleCollection.Get");
scope.Start();
try
{
var response = await _virtualNetworkGatewayNatRuleRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, natRuleName, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _virtualNetworkGatewayNatRuleClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new VirtualNetworkGatewayNatRule(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <PrivateEndpoint> > GetAsync(string privateEndpointName, string expand = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(privateEndpointName, nameof(privateEndpointName));
using var scope = _privateEndpointClientDiagnostics.CreateScope("PrivateEndpointCollection.Get");
scope.Start();
try
{
var response = await _privateEndpointRestClient.GetAsync(Id.SubscriptionId, Id.ResourceGroupName, privateEndpointName, expand, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _privateEndpointClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new PrivateEndpoint(ArmClient, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <Response <ManagementGroup> > GetAsync(string groupId, ManagementGroupExpandType?expand = null, bool?recurse = null, string filter = null, string cacheControl = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(groupId, nameof(groupId));
using var scope = _managementGroupClientDiagnostics.CreateScope("ManagementGroupCollection.Get");
scope.Start();
try
{
var response = await _managementGroupRestClient.GetAsync(groupId, expand, recurse, filter, cacheControl, cancellationToken).ConfigureAwait(false);
if (response.Value == null)
{
throw await _managementGroupClientDiagnostics.CreateRequestFailedExceptionAsync(response.GetRawResponse()).ConfigureAwait(false);
}
return(Response.FromValue(new ManagementGroup(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <ResponseWithHeaders <DataFlowDebugSessionCreateDataFlowDebugSessionHeaders> > CreateDataFlowDebugSessionAsync(CreateDataFlowDebugSessionRequest request, CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
using var message = CreateCreateDataFlowDebugSessionRequest(request);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
var headers = new DataFlowDebugSessionCreateDataFlowDebugSessionHeaders(message.Response);
switch (message.Response.Status)
{
case 200:
case 202:
return(ResponseWithHeaders.FromValue(headers, message.Response));
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
