/// <summary>Set the initial property of the activity entity</summary>
/// <param name="scaleSetVm">The vm</param>
/// <param name="scheduleRule">Event activity entity.</param>
/// /// <param name="enableRollback">Event activity entity.</param>
private static void SetInitialEventActivity(IVirtualMachineScaleSetVM scaleSetVm, ScheduledRules scheduleRule, bool enableRollback)
{
if (enableRollback)
{
scheduleRule.RollbackInitialState = scaleSetVm.PowerState.Value;
scheduleRule.RollbackExecutionStartTime = DateTime.UtcNow;
}
else
{
scheduleRule.InitialState = scaleSetVm.PowerState.Value;
scheduleRule.ExecutionStartTime = DateTime.UtcNow;
}
}
/// <summary>Convert the Virtual machine to virtual machine crawler response entity.</summary>
/// <param name="scaleSetVirtualMachines">The virtual machine.</param>
/// <param name="resourceGroup">The resource group name.</param>
/// <param name="virtualMachineScaleSetId">Scale set name of the vm.</param>
/// <param name="partitionKey">The partition key for the virtaul machine entity.</param>
/// <param name="availabilityZone">The availability zone value for the virtual machine scale set vm instance</param>
/// <param name="vmGroup">Virtual machine group name.</param>
/// <returns></returns>
public static VirtualMachineCrawlerResponse ConvertToVirtualMachineEntity(IVirtualMachineScaleSetVM scaleSetVirtualMachines, string resourceGroup,
string virtualMachineScaleSetId, string partitionKey, int?availabilityZone,
string vmGroup = "")
{
var virtualMachineCrawlerResponseEntity = new VirtualMachineCrawlerResponse(partitionKey, scaleSetVirtualMachines.Id.Replace(Delimeters.ForwardSlash, Delimeters.Exclamatory))
{
RegionName = scaleSetVirtualMachines.RegionName,
ResourceGroupName = resourceGroup,
ResourceName = scaleSetVirtualMachines.Name,
ResourceType = scaleSetVirtualMachines.Type,
VirtualMachineScaleSetId = virtualMachineScaleSetId,
AvailabilityZone = availabilityZone != 0 ? availabilityZone : 0,
VirtualMachineGroup = string.IsNullOrWhiteSpace(vmGroup) ? VirtualMachineGroup.VirtualMachines.ToString() : vmGroup,
State = scaleSetVirtualMachines.PowerState?.Value
};
return(virtualMachineCrawlerResponseEntity);
}
/// <summary>Perform the Chaos Operation</summary>
/// <param name="actionType">Action type</param>
/// <param name="scaleSetVm">Virtual Machine instance</param>
/// <param name="scheduleRule">Event activity entity</param>
/// <param name="enableRollback">Event activity entity</param>
/// <returns></returns>
private static async Task PerformChaos(string action, IVirtualMachineScaleSetVM scaleSetVm, ScheduledRules scheduleRule, bool enableRollback)
{
ActionType actionType;
if (!Enum.TryParse(action, out actionType))
{
return;
}
switch (actionType)
{
case ActionType.Start:
await scaleSetVm.StartAsync();
break;
case ActionType.PowerOff:
case ActionType.Stop:
await scaleSetVm.PowerOffAsync();
break;
case ActionType.Restart:
await scaleSetVm.RestartAsync();
break;
}
if (enableRollback)
{
scheduleRule.RollbackExecutionStatus = Status.Executing.ToString();
}
else
{
scheduleRule.ExecutionStatus = Status.Executing.ToString();
}
}
public void CanCreateUpdateFromPIRWithManagedDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vmssName = SdkContext.RandomResourceName("vmss", 10);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var networkManager = TestHelper.CreateNetworkManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var network = networkManager
.Networks
.Define(SdkContext.RandomResourceName("vmssvnet", 15))
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
var publicLoadBalancer = ScaleSet.CreateHttpLoadBalancers(resourceManager, resourceGroup, "1", Location);
var vmScaleSet = computeManager.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardD5v2)
.WithExistingPrimaryNetworkSubnet(network, "subnet1")
.WithExistingPrimaryInternetFacingLoadBalancer(publicLoadBalancer)
.WithoutPrimaryInternalLoadBalancer()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("jvuser")
.WithRootPassword(TestUtilities.GenerateName("Pa5$"))
.WithNewDataDisk(100)
.WithNewDataDisk(100, 1, CachingTypes.ReadWrite)
.WithNewDataDisk(100, 2, CachingTypes.ReadOnly)
.Create();
var virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
var virtualMachines = virtualMachineScaleSetVMs.List();
Assert.Equal(virtualMachines.Count(), vmScaleSet.Capacity);
foreach (var vm in virtualMachines)
{
Assert.True(vm.IsOSBasedOnPlatformImage);
Assert.False(vm.IsOSBasedOnCustomImage);
Assert.False(vm.IsOSBasedOnStoredImage);
Assert.True(vm.IsManagedDiskEnabled);
Assert.NotNull(vm.UnmanagedDataDisks);
Assert.Empty(vm.UnmanagedDataDisks);
Assert.NotNull(vm.DataDisks);
Assert.Equal(3, vm.DataDisks.Count);
}
vmScaleSet.Update()
.WithoutDataDisk(0)
.WithNewDataDisk(50)
.Apply();
virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
virtualMachines = virtualMachineScaleSetVMs.List();
Assert.Equal(virtualMachines.Count(), vmScaleSet.Capacity);
foreach (var vm in virtualMachines)
{
Assert.NotNull(vm.DataDisks);
Assert.Equal(3, vm.DataDisks.Count);
}
// test attach/detach data disk to single instance
string diskName = SdkContext.RandomResourceName("disk", 10);
IDisk disk0 = computeManager.Disks
.Define(diskName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithData()
.WithSizeInGB(32)
.Create();
var vmEnumerator = virtualMachines.GetEnumerator();
vmEnumerator.MoveNext();
IVirtualMachineScaleSetVM vm0 = vmEnumerator.Current;
vmEnumerator.MoveNext();
IVirtualMachineScaleSetVM vm1 = vmEnumerator.Current;
int existDiskLun = 2;
int newDiskLun = 10;
// cannot detach non-exist disk
Assert.Throws <InvalidOperationException>(
() => vm0.Update().WithoutDataDisk(newDiskLun)
);
// cannot detach disk from VMSS model
Assert.Throws <InvalidOperationException>(
() => vm0.Update().WithoutDataDisk(existDiskLun)
);
// cannot attach disk with same lun
Assert.Throws <InvalidOperationException>(
() => vm0.Update().WithExistingDataDisk(disk0, existDiskLun, CachingTypes.None)
);
// cannot attach disk with same lun
Assert.Throws <InvalidOperationException>(
() => vm0.Update().WithExistingDataDisk(disk0, newDiskLun, CachingTypes.None).WithExistingDataDisk(disk0, newDiskLun, CachingTypes.None)
);
// attach disk
int vmssModelDiskCount = vm0.DataDisks.Count;
vm0.Update()
.WithExistingDataDisk(disk0, newDiskLun, CachingTypes.ReadWrite)
.Apply();
Assert.Equal(vmssModelDiskCount + 1, vm0.DataDisks.Count);
// cannot attach disk that already attached
disk0.Refresh();
Assert.Throws <InvalidOperationException>(
() => vm1.Update()
.WithExistingDataDisk(disk0, newDiskLun, CachingTypes.None)
.Apply()
);
// detach disk
vm0.Update()
.WithoutDataDisk(newDiskLun)
.Apply();
Assert.Equal(vmssModelDiskCount, vm0.DataDisks.Count);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
