protected async Task DiskEncryptionSet_CRUD_Execute(string methodName, string location = null)
{
EnsureClientsInitialized(DefaultLocation);
DiskRPLocation = location ?? DiskRPLocation;
// Data
var rgName = Recording.GenerateAssetName(TestPrefix);
var desName = Recording.GenerateAssetName(DiskNamePrefix);
DiskEncryptionSet des = GenerateDefaultDiskEncryptionSet(DiskRPLocation);
await ResourceGroupsOperations.CreateOrUpdateAsync(rgName, new ResourceGroup(DiskRPLocation));
// Put DiskEncryptionSet
DiskEncryptionSet desOut = await WaitForCompletionAsync(await DiskEncryptionSetsOperations.StartCreateOrUpdateAsync(rgName, desName, des));
Validate(des, desOut, desName);
// Get DiskEncryptionSet
desOut = await DiskEncryptionSetsOperations.GetAsync(rgName, desName);
Validate(des, desOut, desName);
// Patch DiskEncryptionSet
const string tagKey = "tageKey";
var updateDes = new DiskEncryptionSetUpdate()
{
Tags = { { tagKey, "tagvalue" } }
};
desOut = await WaitForCompletionAsync(await DiskEncryptionSetsOperations.StartUpdateAsync(rgName, desName, updateDes));
Validate(des, desOut, desName);
Assert.AreEqual(1, desOut.Tags.Count);
// Delete DiskEncryptionSet
await WaitForCompletionAsync(await DiskEncryptionSetsOperations.StartDeleteAsync(rgName, desName));
try
{
// Ensure it was really deleted
await DiskEncryptionSetsOperations.GetAsync(rgName, desName);
Assert.False(true);
}
catch (Exception ex)
{
Assert.NotNull(ex);
//Assert.AreEqual(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.Name, VerbsData.Update))
{
string resourceGroupName;
string diskEncryptionSetName;
switch (this.ParameterSetName)
{
case "ResourceIdParameter":
resourceGroupName = GetResourceGroupName(this.ResourceId);
diskEncryptionSetName = GetResourceName(this.ResourceId, "Microsoft.Compute/diskEncryptionSets");
break;
case "ObjectParameter":
resourceGroupName = GetResourceGroupName(this.InputObject.Id);
diskEncryptionSetName = GetResourceName(this.InputObject.Id, "Microsoft.Compute/diskEncryptionSets");
break;
default:
resourceGroupName = this.ResourceGroupName;
diskEncryptionSetName = this.Name;
break;
}
if (this.InputObject == null)
{
BuildPatchObject();
}
else
{
BuildPutObject();
}
DiskEncryptionSetUpdate diskEncryptionSetupdate = this.DiskEncryptionSetUpdate;
DiskEncryptionSet parameter = new DiskEncryptionSet();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSDiskEncryptionSet, DiskEncryptionSet>(this.InputObject, parameter);
var result = (this.DiskEncryptionSetUpdate == null)
? DiskEncryptionSetsClient.CreateOrUpdate(resourceGroupName, diskEncryptionSetName, parameter)
: DiskEncryptionSetsClient.Update(resourceGroupName, diskEncryptionSetName, diskEncryptionSetupdate);
var psObject = new PSDiskEncryptionSet();
ComputeAutomationAutoMapperProfile.Mapper.Map <DiskEncryptionSet, PSDiskEncryptionSet>(result, psObject);
WriteObject(psObject);
}
});
}
protected void DiskEncryptionSet_UpdateDisk_Execute(string methodName, string location = null)
{
using (MockContext context = MockContext.Start(this.GetType()))
{
EnsureClientsInitialized(context);
var rgName = TestUtilities.GenerateName(TestPrefix);
var diskName = TestUtilities.GenerateName(DiskNamePrefix);
var desName = "longlivedSwaggerDES";
Disk disk = GenerateDefaultDisk(DiskCreateOption.Empty, rgName, 10);
disk.Location = location;
try
{
m_ResourcesClient.ResourceGroups.CreateOrUpdate(rgName, new ResourceGroup {
Location = location
});
// Put Disk with PlatformManagedKey
m_CrpClient.Disks.CreateOrUpdate(rgName, diskName, disk);
Disk diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Validate(disk, diskOut, disk.Location);
Assert.Null(diskOut.Encryption.DiskEncryptionSetId);
Assert.Equal(EncryptionType.EncryptionAtRestWithPlatformKey, diskOut.Encryption.Type);
// Update Disk with CustomerManagedKey
DiskEncryptionSet desOut = m_CrpClient.DiskEncryptionSets.Get("longrunningrg-centraluseuap", desName);
Assert.NotNull(desOut);
disk.Encryption = new Encryption
{
Type = EncryptionType.EncryptionAtRestWithCustomerKey.ToString(),
DiskEncryptionSetId = desOut.Id
};
m_CrpClient.Disks.CreateOrUpdate(rgName, diskName, disk);
diskOut = m_CrpClient.Disks.Get(rgName, diskName);
Assert.Equal(desOut.Id.ToLower(), diskOut.Encryption.DiskEncryptionSetId.ToLower());
Assert.Equal(EncryptionType.EncryptionAtRestWithCustomerKey, diskOut.Encryption.Type);
m_CrpClient.Disks.Delete(rgName, diskName);
}
finally
{
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.Name, VerbsCommon.New))
{
string resourceGroupName = this.ResourceGroupName;
string diskEncryptionSetName = this.Name;
DiskEncryptionSet diskEncryptionSet = new DiskEncryptionSet();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSDiskEncryptionSet, DiskEncryptionSet>(this.InputObject, diskEncryptionSet);
var result = DiskEncryptionSetsClient.CreateOrUpdate(resourceGroupName, diskEncryptionSetName, diskEncryptionSet);
var psObject = new PSDiskEncryptionSet();
ComputeAutomationAutoMapperProfile.Mapper.Map <DiskEncryptionSet, PSDiskEncryptionSet>(result, psObject);
WriteObject(psObject);
}
});
}
protected async Task DiskEncryptionSet_UpdateDisk_Execute(string methodName, string location = null)
{
EnsureClientsInitialized(DefaultLocation);
var rgName = Recording.GenerateAssetName(TestPrefix);
var diskName = Recording.GenerateAssetName(DiskNamePrefix);
var desName = "longlivedSwaggerDES";
Disk disk = await GenerateDefaultDisk(DiskCreateOption.Empty.ToString(), rgName, 10);
disk.Location = location;
await ResourceGroupsOperations.CreateOrUpdateAsync(rgName, new ResourceGroup(location));
// Put Disk with PlatformManagedKey
await WaitForCompletionAsync(await DisksOperations.StartCreateOrUpdateAsync(rgName, diskName, disk));
Disk diskOut = await DisksOperations.GetAsync(rgName, diskName);
Validate(disk, diskOut, disk.Location);
Assert.Null(diskOut.Encryption.DiskEncryptionSetId);
Assert.AreEqual(EncryptionType.EncryptionAtRestWithPlatformKey, diskOut.Encryption.Type);
// Update Disk with CustomerManagedKey
DiskEncryptionSet desOut = await DiskEncryptionSetsOperations.GetAsync("longrunningrg-southeastasia", desName);
Assert.NotNull(desOut);
disk.Encryption = new Encryption
{
Type = EncryptionType.EncryptionAtRestWithCustomerKey.ToString(),
DiskEncryptionSetId = desOut.Id
};
await WaitForCompletionAsync(await DisksOperations.StartCreateOrUpdateAsync(rgName, diskName, disk));
diskOut = await DisksOperations.GetAsync(rgName, diskName);
Assert.AreEqual(desOut.Id.ToLower(), diskOut.Encryption.DiskEncryptionSetId.ToLower());
Assert.AreEqual(EncryptionType.EncryptionAtRestWithCustomerKey, diskOut.Encryption.Type);
await WaitForCompletionAsync(await DisksOperations.StartDeleteAsync(rgName, diskName));
}
public async Task <Response <DiskEncryptionSet> > GetAsync(string resourceGroupName, string diskEncryptionSetName, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskEncryptionSetName == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSetName));
}
using var message = CreateGetRequest(resourceGroupName, diskEncryptionSetName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
DiskEncryptionSet value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = DiskEncryptionSet.DeserializeDiskEncryptionSet(document.RootElement);
return(Response.FromValue(value, message.Response));
}
protected DiskEncryptionSet GenerateDefaultDiskEncryptionSet(string location)
{
string testVaultId = @"/subscriptions/0296790d-427c-48ca-b204-8b729bbd8670/resourcegroups/swagger/providers/Microsoft.KeyVault/vaults/swaggervault";
string encryptionKeyUri = @"https://swaggervault.vault.azure.net/keys/diskRPSSEKey/4780bcaf12384596b75cf63731f2046c";
var des = new DiskEncryptionSet
{
Identity = new EncryptionSetIdentity
{
Type = ResourceIdentityType.SystemAssigned.ToString()
},
Location = location,
ActiveKey = new KeyVaultAndKeyReference
{
SourceVault = new SourceVault
{
Id = testVaultId
},
KeyUrl = encryptionKeyUri
}
};
return(des);
}
public async Task <Response> CreateOrUpdateAsync(string resourceGroupName, string diskEncryptionSetName, DiskEncryptionSet diskEncryptionSet, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskEncryptionSetName == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSetName));
}
if (diskEncryptionSet == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSet));
}
using var message = CreateCreateOrUpdateRequest(resourceGroupName, diskEncryptionSetName, diskEncryptionSet);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
case 201:
return(message.Response);
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string diskEncryptionSetName, DiskEncryptionSet diskEncryptionSet)
{
var message = _pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Put;
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/diskEncryptionSets/", false);
uri.AppendPath(diskEncryptionSetName, true);
uri.AppendQuery("api-version", "2019-11-01", true);
request.Uri = uri;
request.Headers.Add("Content-Type", "application/json");
var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(diskEncryptionSet);
request.Content = content;
return(message);
}
public virtual DiskEncryptionSetsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string diskEncryptionSetName, DiskEncryptionSet diskEncryptionSet, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskEncryptionSetName == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSetName));
}
if (diskEncryptionSet == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSet));
}
using var scope = _clientDiagnostics.CreateScope("DiskEncryptionSetsOperations.StartCreateOrUpdate");
scope.Start();
try
{
var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, diskEncryptionSetName, diskEncryptionSet, cancellationToken);
return(new DiskEncryptionSetsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, diskEncryptionSetName, diskEncryptionSet).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Creates or updates a disk encryption set
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='diskEncryptionSetName'>
/// The name of the disk encryption set that is being created. The name can't
/// be changed after the disk encryption set 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='diskEncryptionSet'>
/// disk encryption set object supplied in the body of the Put disk encryption
/// set operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DiskEncryptionSet> CreateOrUpdateAsync(this IDiskEncryptionSetsOperations operations, string resourceGroupName, string diskEncryptionSetName, DiskEncryptionSet diskEncryptionSet, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, diskEncryptionSetName, diskEncryptionSet, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates or updates a disk encryption set
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='diskEncryptionSetName'>
/// The name of the disk encryption set that is being created. The name can't
/// be changed after the disk encryption set 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='diskEncryptionSet'>
/// disk encryption set object supplied in the body of the Put disk encryption
/// set operation.
/// </param>
public static DiskEncryptionSet CreateOrUpdate(this IDiskEncryptionSetsOperations operations, string resourceGroupName, string diskEncryptionSetName, DiskEncryptionSet diskEncryptionSet)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, diskEncryptionSetName, diskEncryptionSet).GetAwaiter().GetResult());
}
protected void DiskEncryptionSet_List_Execute(string methodName, string location = null)
{
using (MockContext context = MockContext.Start(this.GetType(), methodName))
{
EnsureClientsInitialized(context);
DiskRPLocation = location ?? DiskRPLocation;
// Data
var rgName1 = TestUtilities.GenerateName(TestPrefix);
var rgName2 = TestUtilities.GenerateName(TestPrefix);
var desName1 = TestUtilities.GenerateName(DiskNamePrefix);
var desName2 = TestUtilities.GenerateName(DiskNamePrefix);
DiskEncryptionSet des1 = GenerateDefaultDiskEncryptionSet(DiskRPLocation);
DiskEncryptionSet des2 = GenerateDefaultDiskEncryptionSet(DiskRPLocation);
try
{
// **********
// SETUP
// **********
// Create resource groups
m_ResourcesClient.ResourceGroups.CreateOrUpdate(rgName1, new ResourceGroup {
Location = DiskRPLocation
});
m_ResourcesClient.ResourceGroups.CreateOrUpdate(rgName2, new ResourceGroup {
Location = DiskRPLocation
});
// Put 4 diskEncryptionSets, 2 in each resource group
m_CrpClient.DiskEncryptionSets.CreateOrUpdate(rgName1, desName1, des1);
m_CrpClient.DiskEncryptionSets.CreateOrUpdate(rgName1, desName2, des2);
m_CrpClient.DiskEncryptionSets.CreateOrUpdate(rgName2, desName1, des1);
m_CrpClient.DiskEncryptionSets.CreateOrUpdate(rgName2, desName2, des2);
// **********
// TEST
// **********
// List diskEncryptionSets under resource group
IPage <DiskEncryptionSet> dessOut = m_CrpClient.DiskEncryptionSets.ListByResourceGroup(rgName1);
Assert.Equal(2, dessOut.Count());
Assert.Null(dessOut.NextPageLink);
dessOut = m_CrpClient.DiskEncryptionSets.ListByResourceGroup(rgName2);
Assert.Equal(2, dessOut.Count());
Assert.Null(dessOut.NextPageLink);
// List diskEncryptionSets under subscription
dessOut = m_CrpClient.DiskEncryptionSets.List();
Assert.True(dessOut.Count() >= 4);
if (dessOut.NextPageLink != null)
{
dessOut = m_CrpClient.DiskEncryptionSets.ListNext(dessOut.NextPageLink);
Assert.True(dessOut.Any());
}
// Delete diskEncryptionSets
m_CrpClient.DiskEncryptionSets.Delete(rgName1, desName1);
m_CrpClient.DiskEncryptionSets.Delete(rgName1, desName2);
m_CrpClient.DiskEncryptionSets.Delete(rgName2, desName1);
m_CrpClient.DiskEncryptionSets.Delete(rgName2, desName2);
}
finally
{
// Delete resource group
m_ResourcesClient.ResourceGroups.Delete(rgName1);
m_ResourcesClient.ResourceGroups.Delete(rgName2);
}
}
}
public Response CreateOrUpdate(string resourceGroupName, string diskEncryptionSetName, DiskEncryptionSet diskEncryptionSet, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (diskEncryptionSetName == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSetName));
}
if (diskEncryptionSet == null)
{
throw new ArgumentNullException(nameof(diskEncryptionSet));
}
using var message = CreateCreateOrUpdateRequest(resourceGroupName, diskEncryptionSetName, diskEncryptionSet);
_pipeline.Send(message, cancellationToken);
switch (message.Response.Status)
{
case 201:
case 200:
return(message.Response);
default:
throw _clientDiagnostics.CreateRequestFailedException(message.Response);
}
}
