public async Task Flash(IDisk disk, string imagePath, IOperationProgress progressObserver = null)
{
Log.Information("Flashing GPT image...");
ISubject <string> outputSubject = new Subject <string>();
IDisposable stdOutputSubscription = null;
bool isValidating = false;
if (progressObserver != null)
{
stdOutputSubscription = outputSubject
.Do(s =>
{
if (!isValidating && CultureInfo.CurrentCulture.CompareInfo.IndexOf(s, "validating", 0, CompareOptions.IgnoreCase) != -1)
{
progressObserver?.Percentage.OnNext(double.NaN);
Log.Information("Validating flashed image...");
isValidating = true;
}
})
.Select(GetPercentage)
.Where(d => !double.IsNaN(d))
.Subscribe(progressObserver.Percentage);
}
var args = $@"-d \\.\PHYSICALDRIVE{disk.Number} ""{imagePath}"" --yes --no-unmount";
Log.Verbose("We are about to run Etcher: {ExecName} {Parameters}", EtcherPath, args);
var processResults = await ProcessMixin.RunProcess(EtcherPath, args, outputObserver : outputSubject);
if (processResults.ExitCode != 0)
{
Log.Error("Cannot flash the image with Etcher. Execution results: {Results}", processResults);
throw new FlashException($"Cannot flash the image: {imagePath} to {disk}");
}
progressObserver?.Percentage.OnNext(double.NaN);
stdOutputSubscription?.Dispose();
await disk.Refresh();
await EnsureDiskHasNewGuid(disk);
Log.Information("GPT image flashed");
}
public async Task Clean(IPhone toClean)
{
Log.Information("Performing cleanup of possible existing deployments");
disk = await toClean.GetDeviceDisk();
using (var context = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
RemoveWellKnownPartitions(context);
// This code is not there because it's considered unsafe. It's here just in case it's useful for a rare case.
// RemovePartitionsAfterData(context);
}
Log.Information("Cleanup done");
await disk.Refresh();
}
private async Task CreatePartitions()
{
Log.Verbose("Creating partitions");
using (var t = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
t.Add(new EntryBuilder(PartitionName.System, systemSize, PartitionType.Esp)
.NoAutoMount()
.Build());
t.Add(new EntryBuilder(PartitionName.Reserved, reservedSize, PartitionType.Reserved)
.NoAutoMount()
.Build());
var windowsSize = t.AvailableSize;
t.Add(new EntryBuilder(PartitionName.Windows, windowsSize, PartitionType.Basic)
.NoAutoMount()
.Build());
}
await disk.Refresh();
}
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 { }
}
}
}