public virtual ArmOperation Delete(WaitUntil waitUntil, CancellationToken cancellationToken = default)
{
using var scope = _msixPackageMSIXPackagesClientDiagnostics.CreateScope("MsixPackageResource.Delete");
scope.Start();
try
{
var response = _msixPackageMSIXPackagesRestClient.Delete(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, cancellationToken);
var operation = new DesktopVirtualizationArmOperation(response);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletionResponse(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation Delete(bool waitForCompletion, CancellationToken cancellationToken = default)
{
using var scope = _virtualWorkspaceWorkspacesClientDiagnostics.CreateScope("VirtualWorkspace.Delete");
scope.Start();
try
{
var response = _virtualWorkspaceWorkspacesRestClient.Delete(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, cancellationToken);
var operation = new DesktopVirtualizationArmOperation(response);
if (waitForCompletion)
{
operation.WaitForCompletionResponse(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation> DeleteAsync(WaitUntil waitUntil, CancellationToken cancellationToken = default)
{
using var scope = _virtualApplicationApplicationsClientDiagnostics.CreateScope("VirtualApplicationResource.Delete");
scope.Start();
try
{
var response = await _virtualApplicationApplicationsRestClient.DeleteAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, cancellationToken).ConfigureAwait(false);
var operation = new DesktopVirtualizationArmOperation(response);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionResponseAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation> DeleteAsync(bool waitForCompletion, bool?force = null, CancellationToken cancellationToken = default)
{
using var scope = _userSessionClientDiagnostics.CreateScope("UserSession.Delete");
scope.Start();
try
{
var response = await _userSessionRestClient.DeleteAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, force, cancellationToken).ConfigureAwait(false);
var operation = new DesktopVirtualizationArmOperation(response);
if (waitForCompletion)
{
await operation.WaitForCompletionResponseAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <VirtualApplicationGroup> CreateOrUpdate(WaitUntil waitUntil, string applicationGroupName, VirtualApplicationGroupData applicationGroup, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(applicationGroupName, nameof(applicationGroupName));
Argument.AssertNotNull(applicationGroup, nameof(applicationGroup));
using var scope = _virtualApplicationGroupApplicationGroupsClientDiagnostics.CreateScope("VirtualApplicationGroupCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _virtualApplicationGroupApplicationGroupsRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, applicationGroupName, applicationGroup, cancellationToken);
var operation = new DesktopVirtualizationArmOperation <VirtualApplicationGroup>(Response.FromValue(new VirtualApplicationGroup(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <MsixPackageResource> CreateOrUpdate(WaitUntil waitUntil, string msixPackageFullName, MsixPackageData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(msixPackageFullName, nameof(msixPackageFullName));
Argument.AssertNotNull(data, nameof(data));
using var scope = _msixPackageMSIXPackagesClientDiagnostics.CreateScope("MsixPackageCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _msixPackageMSIXPackagesRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, msixPackageFullName, data, cancellationToken);
var operation = new DesktopVirtualizationArmOperation <MsixPackageResource>(Response.FromValue(new MsixPackageResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <VirtualWorkspace> CreateOrUpdate(bool waitForCompletion, string workspaceName, VirtualWorkspaceData workspace, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(workspaceName, nameof(workspaceName));
Argument.AssertNotNull(workspace, nameof(workspace));
using var scope = _virtualWorkspaceWorkspacesClientDiagnostics.CreateScope("VirtualWorkspaceCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _virtualWorkspaceWorkspacesRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, workspaceName, workspace, cancellationToken);
var operation = new DesktopVirtualizationArmOperation <VirtualWorkspace>(Response.FromValue(new VirtualWorkspace(Client, response), response.GetRawResponse()));
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <HostPool> CreateOrUpdate(bool waitForCompletion, string hostPoolName, HostPoolData hostPool, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(hostPoolName, nameof(hostPoolName));
Argument.AssertNotNull(hostPool, nameof(hostPool));
using var scope = _hostPoolClientDiagnostics.CreateScope("HostPoolCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _hostPoolRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, hostPoolName, hostPool, cancellationToken);
var operation = new DesktopVirtualizationArmOperation <HostPool>(Response.FromValue(new HostPool(Client, response), response.GetRawResponse()));
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual ArmOperation <ScalingPlan> CreateOrUpdate(bool waitForCompletion, string scalingPlanName, ScalingPlanData scalingPlan, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(scalingPlanName, nameof(scalingPlanName));
Argument.AssertNotNull(scalingPlan, nameof(scalingPlan));
using var scope = _scalingPlanClientDiagnostics.CreateScope("ScalingPlanCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _scalingPlanRestClient.Create(Id.SubscriptionId, Id.ResourceGroupName, scalingPlanName, scalingPlan, cancellationToken);
var operation = new DesktopVirtualizationArmOperation <ScalingPlan>(Response.FromValue(new ScalingPlan(Client, response), response.GetRawResponse()));
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <ArmOperation <HostPoolResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string hostPoolName, HostPoolData data, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(hostPoolName, nameof(hostPoolName));
Argument.AssertNotNull(data, nameof(data));
using var scope = _hostPoolClientDiagnostics.CreateScope("HostPoolCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _hostPoolRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, hostPoolName, data, cancellationToken).ConfigureAwait(false);
var operation = new DesktopVirtualizationArmOperation <HostPoolResource>(Response.FromValue(new HostPoolResource(Client, response), response.GetRawResponse()));
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <MsixPackage> > CreateOrUpdateAsync(bool waitForCompletion, string msixPackageFullName, MsixPackageData msixPackage, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(msixPackageFullName, nameof(msixPackageFullName));
Argument.AssertNotNull(msixPackage, nameof(msixPackage));
using var scope = _msixPackageMSIXPackagesClientDiagnostics.CreateScope("MsixPackageCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _msixPackageMSIXPackagesRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, msixPackageFullName, msixPackage, cancellationToken).ConfigureAwait(false);
var operation = new DesktopVirtualizationArmOperation <MsixPackage>(Response.FromValue(new MsixPackage(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 <VirtualApplication> > CreateOrUpdateAsync(bool waitForCompletion, string applicationName, VirtualApplicationData application, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(applicationName, nameof(applicationName));
Argument.AssertNotNull(application, nameof(application));
using var scope = _virtualApplicationApplicationsClientDiagnostics.CreateScope("VirtualApplicationCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _virtualApplicationApplicationsRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, applicationName, application, cancellationToken).ConfigureAwait(false);
var operation = new DesktopVirtualizationArmOperation <VirtualApplication>(Response.FromValue(new VirtualApplication(Client, response), response.GetRawResponse()));
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
