public virtual IscsiTargetCreateOrUpdateOperation CreateOrUpdate(bool waitForCompletion, string iscsiTargetName, IscsiTargetCreate iscsiTargetCreatePayload, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(iscsiTargetName, nameof(iscsiTargetName));
if (iscsiTargetCreatePayload == null)
{
throw new ArgumentNullException(nameof(iscsiTargetCreatePayload));
}
using var scope = _iscsiTargetClientDiagnostics.CreateScope("IscsiTargetCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _iscsiTargetRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, iscsiTargetName, iscsiTargetCreatePayload, cancellationToken);
var operation = new IscsiTargetCreateOrUpdateOperation(ArmClient, _iscsiTargetClientDiagnostics, Pipeline, _iscsiTargetRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, iscsiTargetName, iscsiTargetCreatePayload).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <IscsiTarget> > CreateOrUpdateAsync(bool waitForCompletion, string iscsiTargetName, IscsiTargetCreate iscsiTargetCreatePayload, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(iscsiTargetName, nameof(iscsiTargetName));
Argument.AssertNotNull(iscsiTargetCreatePayload, nameof(iscsiTargetCreatePayload));
using var scope = _iscsiTargetClientDiagnostics.CreateScope("IscsiTargetCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _iscsiTargetRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, iscsiTargetName, iscsiTargetCreatePayload, cancellationToken).ConfigureAwait(false);
var operation = new StoragePoolArmOperation <IscsiTarget>(new IscsiTargetOperationSource(Client), _iscsiTargetClientDiagnostics, Pipeline, _iscsiTargetRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, iscsiTargetName, iscsiTargetCreatePayload).Request, response, OperationFinalStateVia.AzureAsyncOperation);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Create or Update an iSCSI Target.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group. The name is case insensitive.
/// </param>
/// <param name='diskPoolName'>
/// The name of the Disk Pool.
/// </param>
/// <param name='iscsiTargetName'>
/// The name of the iSCSI Target.
/// </param>
/// <param name='iscsiTargetCreatePayload'>
/// Request payload for iSCSI Target create operation.
/// </param>
public static IscsiTarget CreateOrUpdate(this IIscsiTargetsOperations operations, string resourceGroupName, string diskPoolName, string iscsiTargetName, IscsiTargetCreate iscsiTargetCreatePayload)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, diskPoolName, iscsiTargetName, iscsiTargetCreatePayload).GetAwaiter().GetResult());
}
/// <summary>
/// Create or Update an iSCSI Target.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group. The name is case insensitive.
/// </param>
/// <param name='diskPoolName'>
/// The name of the Disk Pool.
/// </param>
/// <param name='iscsiTargetName'>
/// The name of the iSCSI Target.
/// </param>
/// <param name='iscsiTargetCreatePayload'>
/// Request payload for iSCSI Target create operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <IscsiTarget> BeginCreateOrUpdateAsync(this IIscsiTargetsOperations operations, string resourceGroupName, string diskPoolName, string iscsiTargetName, IscsiTargetCreate iscsiTargetCreatePayload, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, diskPoolName, iscsiTargetName, iscsiTargetCreatePayload, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task IscsiTargetCrudOperations()
{
var diskPoolName = Recording.GenerateAssetName("diskpool-");
var diskPoolCollection = _resourceGroup.GetDiskPools();
var sku = new DiskPoolSku("Standard_S1");
var diskPoolCreate = new DiskPoolCreate(sku, DefaultLocation, SubnetResourceId)
{
};
diskPoolCreate.AvailabilityZones.Add("1");
// create disk pool
var response = await diskPoolCollection.CreateOrUpdateAsync(true, diskPoolName, diskPoolCreate);
var diskPool = response.Value;
Assert.AreEqual(diskPoolName, diskPool.Data.Name);
Assert.AreEqual(ProvisioningStates.Succeeded, diskPool.Data.ProvisioningState);
// create iSCSI target
var targetCollection = diskPool.GetIscsiTargets();
var iscsiTargetName = Recording.GenerateAssetName("target-");
var iscsiTargetCreate = new IscsiTargetCreate(IscsiTargetAclMode.Dynamic);
var targetCreateResponse = await targetCollection.CreateOrUpdateAsync(true, iscsiTargetName, iscsiTargetCreate);
var iscsiTarget = targetCreateResponse.Value;
Assert.AreEqual(iscsiTargetName, iscsiTarget.Data.Name);
Assert.AreEqual(ProvisioningStates.Succeeded, iscsiTarget.Data.ProvisioningState);
// update iSCSI target -- by updating the managed by property
var dataStoreId = "/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1";
iscsiTargetCreate.ManagedBy = dataStoreId;
iscsiTargetCreate.ManagedByExtended.Add(dataStoreId);
var targetUpdateResponse = await targetCollection.CreateOrUpdateAsync(true, iscsiTargetName, iscsiTargetCreate);
iscsiTarget = targetUpdateResponse.Value;
Assert.AreEqual(dataStoreId, iscsiTarget.Data.ManagedBy);
Assert.AreEqual(ProvisioningStates.Succeeded, iscsiTarget.Data.ProvisioningState);
// remove managed by reference
iscsiTargetCreate.ManagedBy = "";
iscsiTargetCreate.ManagedByExtended.Remove(dataStoreId);
targetUpdateResponse = await targetCollection.CreateOrUpdateAsync(true, iscsiTargetName, iscsiTargetCreate);
iscsiTarget = targetUpdateResponse.Value;
Assert.AreEqual(null, iscsiTarget.Data.ManagedBy);
Assert.AreEqual(ProvisioningStates.Succeeded, iscsiTarget.Data.ProvisioningState);
// delete iSCSI target
var targetDeleteResponse = await iscsiTarget.DeleteAsync(true);
try
{
var getResponse = await targetCollection.GetAsync(iscsiTargetName);
}
catch (RequestFailedException e)
{
Assert.AreEqual(StatusCodes.Status404NotFound, e.Status);
}
}
public void IscsiTargetCrud()
{
using var context = MockContext.Start(this.GetType());
string resourceGroupName = TestUtilities.GenerateName("sdk-itcrud-rg");
string diskPoolName = TestUtilities.GenerateName("sdk-diskpool");
string iscsiTargetName = TestUtilities.GenerateName("target01");
string diskName = TestUtilities.GenerateName("sdk-test-disk");
string location = "eastus2euap";
Console.WriteLine(diskPoolName);
Console.WriteLine(iscsiTargetName);
Console.WriteLine(resourceGroupName);
Console.WriteLine(location);
CreateResourceGroup(context, location, resourceGroupName);
try
{
using var testBase = new StoragePoolTestBase(context);
var client = testBase.StoragePoolClient;
var vnetName = "sdk-vnet";
var subnetName = "sdk-subnet";
var diskName1 = "sdk-disk";
var diskName2 = "sdk-disk-2";
var availabilityZone = "2";
// create vnet and subnet
var networkClient = context.GetServiceClient <NetworkManagementClient>();
var vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new[] { "10.0.0.0/16" }
},
Subnets = new[]
{
new Subnet()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24",
Delegations = new Delegation[1]
{
new Delegation()
{
Name = "diskpool-delegation",
ServiceName = "Microsoft.StoragePool/diskPools",
},
},
},
},
};
networkClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet);
var subnet = networkClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
var computeClient = context.GetServiceClient <ComputeManagementClient>();
// create disk 1
var sku = new DiskSku();
sku.Name = DiskStorageAccountTypes.PremiumLRS;
var disk1 = new ManagedDisk()
{
Location = location,
Sku = sku,
Zones = new[] { availabilityZone },
DiskSizeGB = 256,
CreationData = new CreationData(DiskCreateOption.Empty),
MaxShares = 2,
};
computeClient.Disks.CreateOrUpdate(resourceGroupName, diskName1, disk1);
disk1 = computeClient.Disks.Get(resourceGroupName, diskName1);
var disk2 = new ManagedDisk()
{
Location = location,
Sku = sku,
Zones = new[] { availabilityZone },
DiskSizeGB = 256,
CreationData = new CreationData(DiskCreateOption.Empty),
MaxShares = 2,
};
computeClient.Disks.CreateOrUpdate(resourceGroupName, diskName2, disk2);
disk2 = computeClient.Disks.Get(resourceGroupName, diskName2);
// create disk pool
var disks = new Disk[] { new Disk(disk1.Id), new Disk(disk2.Id) };
var diskPoolSku = new DiskPoolSku("Standard", "Standard");
var diskPool = new DiskPoolCreate(diskPoolSku, subnet.Id, location, new[] { availabilityZone }, disks);
client.DiskPools.CreateOrUpdate(resourceGroupName, diskPoolName, diskPool);
// assert that create succeeded
var createdDiskPool = client.DiskPools.Get(resourceGroupName, diskPoolName);
Assert.NotNull(createdDiskPool);
Assert.Equal("Succeeded", createdDiskPool.ProvisioningState);
// create iscsi target
var luns = new IscsiLun[] { new IscsiLun("lun1", disk1.Id) };
var iscsiTarget = new IscsiTargetCreate(IscsiTargetAclMode.Dynamic, iscsiTargetName);
iscsiTarget.Luns = luns;
client.IscsiTargets.CreateOrUpdate(resourceGroupName, diskPoolName, iscsiTargetName, iscsiTarget);
var createdIscsiTarget = client.IscsiTargets.Get(resourceGroupName, diskPoolName, iscsiTargetName);
Assert.NotNull(createdIscsiTarget);
Assert.Equal("Succeeded", createdIscsiTarget.ProvisioningState);
luns = new IscsiLun[] { new IscsiLun("lun1", disk1.Id), new IscsiLun("lun2", disk2.Id) };
var iscsiTargetUpdate = new IscsiTargetCreate();
iscsiTargetUpdate.Luns = luns;
client.IscsiTargets.CreateOrUpdate(resourceGroupName, diskPoolName, iscsiTargetName, iscsiTargetUpdate);
var updatedIscsiTarget = client.IscsiTargets.Get(resourceGroupName, diskPoolName, iscsiTargetName);
Assert.NotNull(updatedIscsiTarget);
Assert.Equal("Succeeded", updatedIscsiTarget.ProvisioningState);
// delete iscsi target
client.IscsiTargets.Delete(resourceGroupName, diskPoolName, iscsiTargetName);
// delete disk pool
client.DiskPools.Delete(resourceGroupName, diskPoolName);
}
finally
{
DeleteResourceGroup(context, resourceGroupName);
}
}
