public override void ExecuteCmdlet()
{
ExecuteClientAction(() =>
{
WriteWarning("Update-AzureRmDisk: A property of the output of this cmdlet will change in an upcoming breaking change release. " +
"The Name property for a Sku will return Standard_LRS and Premium_LRS");
if (ShouldProcess(this.DiskName, VerbsData.Update))
{
string resourceGroupName = this.ResourceGroupName;
string diskName = this.DiskName;
DiskUpdate diskupdate = new DiskUpdate();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSDiskUpdate, DiskUpdate>(this.DiskUpdate, diskupdate);
Disk disk = new Disk();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSDisk, Disk>(this.Disk, disk);
var result = (this.DiskUpdate == null)
? DisksClient.CreateOrUpdate(resourceGroupName, diskName, disk)
: DisksClient.Update(resourceGroupName, diskName, diskupdate);
var psObject = new PSDisk();
ComputeAutomationAutoMapperProfile.Mapper.Map <Disk, PSDisk>(result, psObject);
WriteObject(psObject);
}
});
}
public virtual DiskUpdateOperation Update(DiskUpdate disk, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var scope = _clientDiagnostics.CreateScope("Disk.Update");
scope.Start();
try
{
var response = _restClient.Update(Id.ResourceGroupName, Id.Name, disk, cancellationToken);
var operation = new DiskUpdateOperation(this, _clientDiagnostics, Pipeline, _restClient.CreateUpdateRequest(Id.ResourceGroupName, Id.Name, disk).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <DiskUpdateOperation> UpdateAsync(DiskUpdate disk, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var scope = _clientDiagnostics.CreateScope("Disk.Update");
scope.Start();
try
{
var response = await _disksRestClient.UpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, disk, cancellationToken).ConfigureAwait(false);
var operation = new DiskUpdateOperation(this, _clientDiagnostics, Pipeline, _disksRestClient.CreateUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, disk).Request, response);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
protected override void ProcessRecord()
{
ComputeAutomationAutoMapperProfile.Initialize();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.ResourceGroupName, VerbsData.Update))
{
string resourceGroupName = this.ResourceGroupName;
string diskName = this.DiskName;
Disk diskObj = new Disk();
Mapper.Map <PSDisk, Disk>(this.Disk, diskObj);
DiskUpdate diskUpdateObj = new DiskUpdate();
Mapper.Map <PSDiskUpdate, DiskUpdate>(this.DiskUpdate, diskUpdateObj);
var result = (this.DiskUpdate == null)
? DisksClient.CreateOrUpdate(resourceGroupName, diskName, diskObj)
: DisksClient.Update(resourceGroupName, diskName, diskUpdateObj);
var psObject = new PSDisk();
Mapper.Map <Disk, PSDisk>(result, psObject);
WriteObject(psObject);
}
});
}
public Response Update(string resourceGroupName, string diskName, DiskUpdate disk, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskName == null)
{
throw new ArgumentNullException(nameof(diskName));
}
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var message = CreateUpdateRequest(resourceGroupName, diskName, disk);
_pipeline.Send(message, cancellationToken);
switch (message.Response.Status)
{
case 200:
case 202:
return(message.Response);
default:
throw _clientDiagnostics.CreateRequestFailedException(message.Response);
}
}
public virtual ArmOperation <Disk> Update(bool waitForCompletion, DiskUpdate disk, CancellationToken cancellationToken = default)
{
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var scope = _diskClientDiagnostics.CreateScope("Disk.Update");
scope.Start();
try
{
var response = _diskRestClient.Update(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, disk, cancellationToken);
var operation = new ComputeArmOperation <Disk>(new DiskOperationSource(Client), _diskClientDiagnostics, Pipeline, _diskRestClient.CreateUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, disk).Request, response, OperationFinalStateVia.Location);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
protected PSArgument[] CreateDiskUpdateParameters()
{
string resourceGroupName = string.Empty;
string diskName = string.Empty;
DiskUpdate disk = new DiskUpdate();
return(ConvertFromObjectsToArguments(
new string[] { "ResourceGroupName", "DiskName", "Disk" },
new object[] { resourceGroupName, diskName, disk }));
}
protected void ExecuteDiskUpdateMethod(object[] invokeMethodInputParameters)
{
string resourceGroupName = (string)ParseParameter(invokeMethodInputParameters[0]);
string diskName = (string)ParseParameter(invokeMethodInputParameters[1]);
DiskUpdate disk = (DiskUpdate)ParseParameter(invokeMethodInputParameters[2]);
Disk diskOrg = (Disk)ParseParameter(invokeMethodInputParameters[3]);
var result = (disk == null)
? DisksClient.CreateOrUpdate(resourceGroupName, diskName, diskOrg)
: DisksClient.Update(resourceGroupName, diskName, disk);
WriteObject(result);
}
public async Task Update()
{
var diskName = Recording.GenerateAssetName("testDisk-");
var disk = await CreateDiskAsync(diskName);
var newDiskSize = 20;
var update = new DiskUpdate()
{
DiskSizeGB = newDiskSize
};
var lro = await disk.UpdateAsync(true, update);
Disk updatedDisk = lro.Value;
Assert.AreEqual(newDiskSize, updatedDisk.Data.DiskSizeGB);
}
public override void ExecuteCmdlet()
{
ExecuteClientAction(() =>
{
if (ShouldProcess(this.DiskName, VerbsData.Update))
{
string resourceGroupName = this.ResourceGroupName;
string diskName = this.DiskName;
DiskUpdate diskupdate = new DiskUpdate();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSDiskUpdate, DiskUpdate>(this.DiskUpdate, diskupdate);
Disk disk = new Disk();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSDisk, Disk>(this.Disk, disk);
var result = (this.DiskUpdate == null)
? DisksClient.CreateOrUpdate(resourceGroupName, diskName, disk)
: DisksClient.Update(resourceGroupName, diskName, diskupdate);
var psObject = new PSDisk();
ComputeAutomationAutoMapperProfile.Mapper.Map <Disk, PSDisk>(result, psObject);
WriteObject(psObject);
}
});
}
public void UltraSSD_CRUD_EmptyDisk()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
EnsureClientsInitialized(context);
// Data
var rgName = TestUtilities.GenerateName(TestPrefix);
var diskName = TestUtilities.GenerateName(DiskNamePrefix);
Disk disk = GenerateBaseDisk("Empty");
disk.Sku = new DiskSku(DiskStorageAccountTypes.UltraSSDLRS, "Ultra");
disk.DiskSizeGB = 256;
disk.Zones = new List <string> {
"2"
};
disk.DiskMBpsReadWrite = 8;
disk.DiskIOPSReadWrite = 500;
disk.Location = DiskRPLocation;
try
{
m_ResourcesClient.ResourceGroups.CreateOrUpdate(rgName, new ResourceGroup {
Location = DiskRPLocation
});
// Put
Disk diskOut = m_CrpClient.Disks.CreateOrUpdate(rgName, diskName, disk);
Validate(disk, diskOut, DiskRPLocation);
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
// Patch
const string tagKey = "tagKey";
var updatedisk = new DiskUpdate();
updatedisk.Tags = new Dictionary <string, string>()
{
{ tagKey, "tagValue" }
};
updatedisk.DiskMBpsReadWrite = 9;
updatedisk.DiskIOPSReadWrite = 600;
diskOut = m_CrpClient.Disks.Update(rgName, diskName, updatedisk);
Validate(disk, diskOut, DiskRPLocation, update: true);
Assert.Equal(updatedisk.DiskIOPSReadWrite, diskOut.DiskIOPSReadWrite);
Assert.Equal(updatedisk.DiskMBpsReadWrite, diskOut.DiskMBpsReadWrite);
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation, update: true);
Assert.Equal(updatedisk.DiskIOPSReadWrite, diskOut.DiskIOPSReadWrite);
Assert.Equal(updatedisk.DiskMBpsReadWrite, diskOut.DiskMBpsReadWrite);
// Delete
m_CrpClient.Disks.Delete(rgName, diskName);
try
{
// Ensure it was really deleted
m_CrpClient.Disks.Get(rgName, diskName);
Assert.False(true);
}
catch (CloudException ex)
{
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
finally
{
// Delete resource group
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
}
}
public virtual DisksUpdateOperation StartUpdate(string resourceGroupName, string diskName, DiskUpdate disk, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskName == null)
{
throw new ArgumentNullException(nameof(diskName));
}
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartUpdate");
scope.Start();
try
{
var originalResponse = RestClient.Update(resourceGroupName, diskName, disk, cancellationToken);
return(new DisksUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGroupName, diskName, disk).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Updates (patches) a disk.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='diskName'>
/// The name of the managed disk that is being created. The name can't be
/// changed after the disk is created. Supported characters for the name are
/// a-z, A-Z, 0-9 and _. The maximum name length is 80 characters.
/// </param>
/// <param name='disk'>
/// Disk object supplied in the body of the Patch disk operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DiskInner> UpdateAsync(this IDisksOperations operations, string resourceGroupName, string diskName, DiskUpdate disk, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, diskName, disk, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async ValueTask <Response> UpdateAsync(string resourceGroupName, string diskName, DiskUpdate disk, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskName == null)
{
throw new ArgumentNullException(nameof(diskName));
}
if (disk == null)
{
throw new ArgumentNullException(nameof(disk));
}
using var message = CreateUpdateRequest(resourceGroupName, diskName, disk);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 202:
case 200:
return(message.Response);
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
/// <summary>
/// Updates (patches) a disk.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='diskName'>
/// The name of the managed disk that is being created. The name can't be
/// changed after the disk is created. Supported characters for the name are
/// a-z, A-Z, 0-9 and _. The maximum name length is 80 characters.
/// </param>
/// <param name='disk'>
/// Disk object supplied in the body of the Patch disk operation.
/// </param>
public static Disk Update(this IDisksOperations operations, string resourceGroupName, string diskName, DiskUpdate disk)
{
return(operations.UpdateAsync(resourceGroupName, diskName, disk).GetAwaiter().GetResult());
}
private void Run()
{
// CreationData
Microsoft.Azure.Management.Compute.Models.CreationData vCreationData = null;
// EncryptionSettings
Microsoft.Azure.Management.Compute.Models.EncryptionSettings vEncryptionSettings = null;
#pragma warning disable CS0618 // Type or member is obsolete
if (this.CreateOption.HasValue)
#pragma warning restore CS0618 // Type or member is obsolete
{
if (vCreationData == null)
{
vCreationData = new Microsoft.Azure.Management.Compute.Models.CreationData();
}
#pragma warning disable CS0618 // Type or member is obsolete
vCreationData.CreateOption = this.CreateOption.Value;
#pragma warning restore CS0618 // Type or member is obsolete
}
#pragma warning disable CS0618 // Type or member is obsolete
if (this.StorageAccountId != null)
#pragma warning restore CS0618 // Type or member is obsolete
{
if (vCreationData == null)
{
vCreationData = new Microsoft.Azure.Management.Compute.Models.CreationData();
}
#pragma warning disable CS0618 // Type or member is obsolete
vCreationData.StorageAccountId = this.StorageAccountId;
#pragma warning restore CS0618 // Type or member is obsolete
}
#pragma warning disable CS0618 // Type or member is obsolete
if (this.ImageReference != null)
#pragma warning restore CS0618 // Type or member is obsolete
{
if (vCreationData == null)
{
vCreationData = new Microsoft.Azure.Management.Compute.Models.CreationData();
}
#pragma warning disable CS0618 // Type or member is obsolete
vCreationData.ImageReference = this.ImageReference;
#pragma warning restore CS0618 // Type or member is obsolete
}
#pragma warning disable CS0618 // Type or member is obsolete
if (this.SourceUri != null)
#pragma warning restore CS0618 // Type or member is obsolete
{
if (vCreationData == null)
{
vCreationData = new Microsoft.Azure.Management.Compute.Models.CreationData();
}
#pragma warning disable CS0618 // Type or member is obsolete
vCreationData.SourceUri = this.SourceUri;
#pragma warning restore CS0618 // Type or member is obsolete
}
#pragma warning disable CS0618 // Type or member is obsolete
if (this.SourceResourceId != null)
#pragma warning restore CS0618 // Type or member is obsolete
{
if (vCreationData == null)
{
vCreationData = new Microsoft.Azure.Management.Compute.Models.CreationData();
}
#pragma warning disable CS0618 // Type or member is obsolete
vCreationData.SourceResourceId = this.SourceResourceId;
#pragma warning restore CS0618 // Type or member is obsolete
}
if (this.EncryptionSettingsEnabled != null)
{
if (vEncryptionSettings == null)
{
vEncryptionSettings = new Microsoft.Azure.Management.Compute.Models.EncryptionSettings();
}
vEncryptionSettings.Enabled = this.EncryptionSettingsEnabled;
}
if (this.DiskEncryptionKey != null)
{
if (vEncryptionSettings == null)
{
vEncryptionSettings = new Microsoft.Azure.Management.Compute.Models.EncryptionSettings();
}
vEncryptionSettings.DiskEncryptionKey = this.DiskEncryptionKey;
}
if (this.KeyEncryptionKey != null)
{
if (vEncryptionSettings == null)
{
vEncryptionSettings = new Microsoft.Azure.Management.Compute.Models.EncryptionSettings();
}
vEncryptionSettings.KeyEncryptionKey = this.KeyEncryptionKey;
}
var vDiskUpdate = new DiskUpdate
{
AccountType = this.AccountType,
OsType = this.OsType,
DiskSizeGB = this.DiskSizeGB,
Tags = (this.Tag == null) ? null : this.Tag.Cast <DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value),
CreationData = vCreationData,
EncryptionSettings = vEncryptionSettings,
};
WriteObject(vDiskUpdate);
}
private async Task UltraSSD_CRUD_Helper(string location, string methodName, bool useZones = false, bool sharedDisks = false)
{
EnsureClientsInitialized(DefaultLocation);
// Data
var rgName = Recording.GenerateAssetName(TestPrefix);
var diskName = Recording.GenerateAssetName(DiskNamePrefix);
Disk disk = GenerateBaseDisk("Empty");
disk.Sku = new DiskSku(DiskStorageAccountTypes.UltraSSDLRS, "Ultra");
disk.DiskSizeGB = 32;
if (useZones)
{
disk.Zones = new List <string> {
"1"
};
}
disk.DiskMBpsReadWrite = 8;
disk.DiskIopsReadWrite = 512;
disk.Location = location;
if (sharedDisks)
{
disk.DiskIopsReadOnly = 512;
disk.DiskMBpsReadOnly = 8;
disk.MaxShares = 2;
}
await ResourceGroupsOperations.CreateOrUpdateAsync(rgName, new ResourceGroup(location));
// Put
Disk diskOut = await WaitForCompletionAsync(await DisksOperations.StartCreateOrUpdateAsync(rgName, diskName, disk));
Validate(disk, diskOut, location);
// Get
diskOut = (await DisksOperations.GetAsync(rgName, diskName)).Value;
Validate(disk, diskOut, location);
// Patch
const string tagKey = "tagKey";
var updatedisk = new DiskUpdate();
updatedisk.Tags = new Dictionary <string, string>()
{
{ tagKey, "tagValue" }
};
updatedisk.DiskMBpsReadWrite = 9;
updatedisk.DiskIopsReadWrite = 600;
if (sharedDisks)
{
updatedisk.DiskMBpsReadOnly = 9;
updatedisk.DiskIopsReadOnly = 600;
updatedisk.MaxShares = 3;
}
updatedisk.Sku = new DiskSku(DiskStorageAccountTypes.UltraSSDLRS, "Ultra");
diskOut = await WaitForCompletionAsync(await DisksOperations.StartUpdateAsync(rgName, diskName, updatedisk));
Validate(disk, diskOut, location, update: true);
Assert.AreEqual(updatedisk.DiskIopsReadWrite, diskOut.DiskIopsReadWrite);
Assert.AreEqual(updatedisk.DiskMBpsReadWrite, diskOut.DiskMBpsReadWrite);
if (sharedDisks)
{
Assert.AreEqual(updatedisk.DiskIopsReadOnly, diskOut.DiskIopsReadOnly);
Assert.AreEqual(updatedisk.DiskMBpsReadOnly, diskOut.DiskMBpsReadOnly);
Assert.AreEqual(updatedisk.MaxShares, diskOut.MaxShares);
}
// Get
diskOut = await DisksOperations.GetAsync(rgName, diskName);
Validate(disk, diskOut, location, update: true);
Assert.AreEqual(updatedisk.DiskIopsReadWrite, diskOut.DiskIopsReadWrite);
Assert.AreEqual(updatedisk.DiskMBpsReadWrite, diskOut.DiskMBpsReadWrite);
if (sharedDisks)
{
Assert.AreEqual(updatedisk.DiskIopsReadOnly, diskOut.DiskIopsReadOnly);
Assert.AreEqual(updatedisk.DiskMBpsReadOnly, diskOut.DiskMBpsReadOnly);
Assert.AreEqual(updatedisk.MaxShares, diskOut.MaxShares);
}
// Delete
await WaitForCompletionAsync(await DisksOperations.StartDeleteAsync(rgName, diskName));
try
{
// Ensure it was really deleted
await DisksOperations.GetAsync(rgName, diskName);
Assert.False(true);
}
catch (Exception ex)
{
Assert.NotNull(ex);
//Assert.AreEqual(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
protected void Disk_CRUD_Execute(string diskCreateOption, string methodName, int?diskSizeGB = null, string location = null, IList <string> zones = null)
{
using (MockContext context = MockContext.Start(this.GetType().FullName, methodName))
{
EnsureClientsInitialized(context);
DiskRPLocation = location ?? DiskRPLocation;
// Data
var rgName = TestUtilities.GenerateName(TestPrefix);
var diskName = TestUtilities.GenerateName(DiskNamePrefix);
Disk disk = GenerateDefaultDisk(diskCreateOption, rgName, diskSizeGB, zones);
try
{
// **********
// SETUP
// **********
// Create resource group, unless create option is import in which case resource group will be created with vm
if (diskCreateOption != DiskCreateOption.Import)
{
m_ResourcesClient.ResourceGroups.CreateOrUpdate(rgName, new ResourceGroup {
Location = DiskRPLocation
});
}
// **********
// TEST
// **********
// Put
Disk diskOut = m_CrpClient.Disks.CreateOrUpdate(rgName, diskName, disk);
Validate(disk, diskOut, DiskRPLocation);
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
// Get disk access
AccessUri accessUri = m_CrpClient.Disks.GrantAccess(rgName, diskName, AccessDataDefault);
Assert.NotNull(accessUri.AccessSAS);
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
// Patch
// TODO: Bug 9865640 - DiskRP doesn't follow patch semantics for zones: skip this for zones
if (zones == null)
{
const string tagKey = "tageKey";
var updatedisk = new DiskUpdate();
updatedisk.Tags = new Dictionary <string, string>()
{
{ tagKey, "tagvalue" }
};
diskOut = m_CrpClient.Disks.Update(rgName, diskName, updatedisk);
Validate(disk, diskOut, DiskRPLocation);
}
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
// End disk access
m_CrpClient.Disks.RevokeAccess(rgName, diskName);
// Delete
m_CrpClient.Disks.Delete(rgName, diskName);
try
{
// Ensure it was really deleted
m_CrpClient.Disks.Get(rgName, diskName);
Assert.False(true);
}
catch (CloudException ex)
{
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
finally
{
// Delete resource group
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
}
}
private void UltraSSD_CRUD_Helper(string location, string methodName, bool useZones = false, bool sharedDisks = false)
{
using (MockContext context = MockContext.Start(this.GetType(), methodName))
{
EnsureClientsInitialized(context);
// Data
var rgName = TestUtilities.GenerateName(TestPrefix);
var diskName = TestUtilities.GenerateName(DiskNamePrefix);
Disk disk = GenerateBaseDisk("Empty");
disk.Sku = new DiskSku(DiskStorageAccountTypes.UltraSSDLRS, "Ultra");
disk.DiskSizeGB = 32;
if (useZones)
{
disk.Zones = new List <string> {
"1"
};
}
disk.DiskMBpsReadWrite = 8;
disk.DiskIOPSReadWrite = 512;
disk.Location = location;
if (sharedDisks)
{
disk.DiskIOPSReadOnly = 512;
disk.DiskMBpsReadOnly = 8;
disk.MaxShares = 2;
}
try
{
m_ResourcesClient.ResourceGroups.CreateOrUpdate(rgName, new ResourceGroup {
Location = location
});
// Put
Disk diskOut = m_CrpClient.Disks.CreateOrUpdate(rgName, diskName, disk);
Validate(disk, diskOut, location);
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, location);
// Patch
const string tagKey = "tagKey";
var updatedisk = new DiskUpdate();
updatedisk.Tags = new Dictionary <string, string>()
{
{ tagKey, "tagValue" }
};
updatedisk.DiskMBpsReadWrite = 9;
updatedisk.DiskIOPSReadWrite = 600;
if (sharedDisks)
{
updatedisk.DiskMBpsReadOnly = 9;
updatedisk.DiskIOPSReadOnly = 600;
updatedisk.MaxShares = 3;
}
updatedisk.Sku = new DiskSku(DiskStorageAccountTypes.UltraSSDLRS, "Ultra");
diskOut = m_CrpClient.Disks.Update(rgName, diskName, updatedisk);
Validate(disk, diskOut, location, update: true);
Assert.Equal(updatedisk.DiskIOPSReadWrite, diskOut.DiskIOPSReadWrite);
Assert.Equal(updatedisk.DiskMBpsReadWrite, diskOut.DiskMBpsReadWrite);
if (sharedDisks)
{
Assert.Equal(updatedisk.DiskIOPSReadOnly, diskOut.DiskIOPSReadOnly);
Assert.Equal(updatedisk.DiskMBpsReadOnly, diskOut.DiskMBpsReadOnly);
Assert.Equal(updatedisk.MaxShares, diskOut.MaxShares);
}
// Get
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, location, update: true);
Assert.Equal(updatedisk.DiskIOPSReadWrite, diskOut.DiskIOPSReadWrite);
Assert.Equal(updatedisk.DiskMBpsReadWrite, diskOut.DiskMBpsReadWrite);
if (sharedDisks)
{
Assert.Equal(updatedisk.DiskIOPSReadOnly, diskOut.DiskIOPSReadOnly);
Assert.Equal(updatedisk.DiskMBpsReadOnly, diskOut.DiskMBpsReadOnly);
Assert.Equal(updatedisk.MaxShares, diskOut.MaxShares);
}
// Delete
m_CrpClient.Disks.Delete(rgName, diskName);
try
{
// Ensure it was really deleted
m_CrpClient.Disks.Get(rgName, diskName);
Assert.False(true);
}
catch (CloudException ex)
{
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
finally
{
// Delete resource group
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
}
}
protected async Task Disk_CRUD_Execute(string diskCreateOption, string methodName, int?diskSizeGB = null, string location = null, IList <string> zones = null)
{
EnsureClientsInitialized(DefaultLocation);
DiskRPLocation = location ?? DiskRPLocation;
// Data
var rgName = Recording.GenerateAssetName(TestPrefix);
var diskName = Recording.GenerateAssetName(DiskNamePrefix);
Disk disk = await GenerateDefaultDisk(diskCreateOption, rgName, diskSizeGB, zones, location);
// **********
// SETUP
// **********
// Create resource group, unless create option is import in which case resource group will be created with vm,
// or copy in which casethe resource group will be created with the original disk.
if (diskCreateOption != DiskCreateOption.Import && diskCreateOption != DiskCreateOption.Copy)
{
await ResourceGroupsOperations.CreateOrUpdateAsync(rgName, new ResourceGroup(DiskRPLocation));
}
// **********
// TEST
// **********
// Put
Disk diskOut = await WaitForCompletionAsync((await DisksOperations.StartCreateOrUpdateAsync(rgName, diskName, disk)));
Validate(disk, diskOut, DiskRPLocation);
// Get
diskOut = await DisksOperations.GetAsync(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
//string resourceGroupName, string diskName, AccessLevel access, int durationInSeconds, CancellationToken cancellationToken = default
// Get disk access
AccessUri accessUri = await WaitForCompletionAsync(await DisksOperations.StartGrantAccessAsync(rgName, diskName, new GrantAccessData(AccessDataDefault.Access, AccessDataDefault.DurationInSeconds)));
Assert.NotNull(accessUri.AccessSAS);
// Get
diskOut = await DisksOperations.GetAsync(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
// Patch
// TODO: Bug 9865640 - DiskRP doesn't follow patch semantics for zones: skip this for zones
if (zones == null)
{
const string tagKey = "tageKey";
var updatedisk = new DiskUpdate();
updatedisk.Tags = new Dictionary <string, string>()
{
{ tagKey, "tagvalue" }
};
diskOut = await WaitForCompletionAsync(await DisksOperations.StartUpdateAsync(rgName, diskName, updatedisk));
Validate(disk, diskOut, DiskRPLocation);
}
// Get
diskOut = await DisksOperations.GetAsync(rgName, diskName);
Validate(disk, diskOut, DiskRPLocation);
// End disk access
await WaitForCompletionAsync(await DisksOperations.StartRevokeAccessAsync(rgName, diskName));
// Delete
await WaitForCompletionAsync(await DisksOperations.StartDeleteAsync(rgName, diskName));
try
{
// Ensure it was really deleted
await DisksOperations.GetAsync(rgName, diskName);
Assert.False(true);
}
catch (Exception ex)
{
Assert.NotNull(ex);
//Assert.AreEqual(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
internal HttpMessage CreateUpdateRequest(string resourceGroupName, string diskName, DiskUpdate disk)
{
var message = _pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Patch;
var uri = new RawRequestUriBuilder();
uri.Reset(endpoint);
uri.AppendPath("/subscriptions/", false);
uri.AppendPath(subscriptionId, true);
uri.AppendPath("/resourceGroups/", false);
uri.AppendPath(resourceGroupName, true);
uri.AppendPath("/providers/Microsoft.Compute/disks/", false);
uri.AppendPath(diskName, true);
uri.AppendQuery("api-version", "2019-11-01", true);
request.Uri = uri;
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Content-Type", "application/json");
var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(disk);
request.Content = content;
return(message);
}
