static IVirtualMachineCustomImage GetVMImageWithRetry(IAzure azure, string resourceGroupName, string imageName, int maxRetry = 3)
{
var i = 0;
IVirtualMachineCustomImage img = null;
while (i < maxRetry)
{
try
{
img = azure.VirtualMachineCustomImages.GetByResourceGroup(resourceGroupName, imageName);
}
catch (Exception e)
{
Util.Log(e.ToString());
if (i + 1 < maxRetry)
{
Util.Log($"Fail to get VM image for {e.Message} and will retry");
}
else
{
Util.Log($"Fail to get VM image for {e.Message} and retry has reached max limit, will return with failure");
}
}
i++;
}
return(img);
}
/// <summary>
/// Specifies that the provided custom image needs to be used as source of the image version.
/// </summary>
/// <param name="customImage">The custom image.</param>
/// <return>The next definition stage.</return>
GalleryImageVersion.Definition.IWithCreate GalleryImageVersion.Definition.IWithSource.WithSourceCustomImage(IVirtualMachineCustomImage customImage)
{
return(this.WithSourceCustomImage(customImage));
}
private IVirtualMachineCustomImage PrepareCustomImage(string rgName, Region region, IAzure azure)
{
string vmName = TestUtilities.GenerateName("muldvm");
string uname = "javauser";
string password = "******";
KnownLinuxVirtualMachineImage linuxImage = KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts;
string publicIpDnsLabel = TestUtilities.GenerateName("pip");
string storageName = TestUtilities.GenerateName("stg");
IVirtualMachine linuxVM = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIpDnsLabel)
.WithPopularLinuxImage(linuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(30)
.WithCaching(CachingTypes.ReadWrite)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(60)
.WithCaching(CachingTypes.ReadOnly)
.Attach()
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(storageName)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
//
TestHelper.DeprovisionAgentInLinuxVM(linuxVM.GetPrimaryPublicIPAddress().Fqdn, 22, uname, password);
//
linuxVM.Deallocate();
linuxVM.Generalize();
//
string vhdBasedImageName = TestUtilities.GenerateName("img");
//
var creatableDisk = azure
.VirtualMachineCustomImages
.Define(vhdBasedImageName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized)
.WithOSDiskCaching(linuxVM.OSDiskCachingType);
foreach (IVirtualMachineUnmanagedDataDisk disk in linuxVM.UnmanagedDataDisks.Values)
{
creatableDisk.DefineDataDiskImage()
.WithLun(disk.Lun)
.FromVhd(disk.VhdUri)
.WithDiskCaching(disk.CachingType)
.WithDiskSizeInGB(disk.Size + 10) // Resize each data disk image by +10GB
.Attach();
}
//
IVirtualMachineCustomImage customImage = creatableDisk.Create();
return(customImage);
}
public void CanCreateUpdateGetDeleteGalleryImageVersion()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
Region region = Region.USWestCentral;
string rgName = TestUtilities.GenerateName("vmexttest");
string galleryName = TestUtilities.GenerateName("jsim");
string galleryImageName = "SampleImages";
var azure = TestHelper.CreateRollupClient();
try
{
IGallery gallery = azure.Galleries.Define(galleryName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithDescription("java's image gallery")
.Create();
//
// Create an image in the gallery (a container to hold custom linux image)
//
IGalleryImage galleryImage = azure.GalleryImages.Define(galleryImageName)
.WithExistingGallery(gallery)
.WithLocation(region)
.WithIdentifier("JavaSDKTeam", "JDK", "Jdk-9")
.WithGeneralizedLinux()
.Create();
//
// Create a custom image to base the version on
//
IVirtualMachineCustomImage customImage = PrepareCustomImage(rgName, region, azure);
// String customImageId = "/subscriptions/0b1f6471-1bf0-4dda-aec3-cb9272f09590/resourceGroups/javacsmrg91482/providers/Microsoft.Compute/images/img96429090dee3";
//
// Create a image version based on the custom image
//
string versionName = "0.0.4";
IGalleryImageVersion imageVersion = azure.GalleryImageVersions.Define(versionName)
.WithExistingImage(rgName, gallery.Name, galleryImage.Name)
.WithLocation(region.ToString())
.WithSourceCustomImage(customImage)
// Options - Start
.WithRegionAvailability(Region.USEast2, 1)
// Options - End
.Create();
Assert.NotNull(imageVersion);
Assert.NotNull(imageVersion.Inner);
Assert.NotNull(imageVersion.PublishingProfile.TargetRegions);
Assert.Equal(2, imageVersion.PublishingProfile.TargetRegions.Count);
Assert.False(imageVersion.IsExcludedFromLatest);
imageVersion = azure.GalleryImageVersions.GetByGalleryImage(rgName, gallery.Name, galleryImage.Name, imageVersion.Name);
Assert.NotNull(imageVersion);
Assert.Null(imageVersion.ReplicationStatus);
imageVersion = azure.GalleryImageVersions.GetByGalleryImageWithReplicationStatus(rgName, gallery.Name, galleryImage.Name, imageVersion.Name);
Assert.NotNull(imageVersion);
Assert.NotNull(imageVersion.ReplicationStatus);
Assert.NotNull(imageVersion.ReplicationStatus.AggregatedState);
//
// Update image version
//
imageVersion.Update()
.WithoutRegionAvailability(Region.USEast2)
.Apply();
Assert.NotNull(imageVersion.PublishingProfile.TargetRegions);
Assert.Equal(1, imageVersion.PublishingProfile.TargetRegions.Count);
Assert.False(imageVersion.IsExcludedFromLatest);
//
// List image versions
//
IEnumerable <IGalleryImageVersion> versions = galleryImage.ListVersions();
Assert.NotNull(versions);
Assert.True(versions.Count() > 0);
//
// Delete the image version
//
azure.GalleryImageVersions.DeleteByGalleryImage(rgName, galleryName, galleryImageName, versionName);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCreateImageFromNativeVhd()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vhdBasedImageName = SdkContext.RandomResourceName("img", 20);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var linuxVM = PrepareGeneralizedVMWith2EmptyDataDisks(rgName,
SdkContext.RandomResourceName("muldvm", 15),
Location,
computeManager);
//
var creatableDisk = computeManager.VirtualMachineCustomImages.Define(vhdBasedImageName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized)
.WithOSDiskCaching(linuxVM.OSDiskCachingType);
foreach (var disk in linuxVM.UnmanagedDataDisks.Values)
{
creatableDisk.DefineDataDiskImage()
.WithLun(disk.Lun)
.FromVhd(disk.VhdUri)
.WithDiskCaching(disk.CachingType)
.WithDiskSizeInGB(disk.Size + 10) // Resize each data disk image by +10GB
.Attach();
}
var customImage = creatableDisk.Create();
Assert.NotNull(customImage.Id);
Assert.Equal(customImage.Name, vhdBasedImageName);
Assert.False(customImage.IsCreatedFromVirtualMachine);
Assert.Null(customImage.SourceVirtualMachineId);
Assert.NotNull(customImage.OSDiskImage);
Assert.NotNull(customImage.OSDiskImage.BlobUri);
Assert.Equal(CachingTypes.ReadWrite, customImage.OSDiskImage.Caching);
Assert.Equal(OperatingSystemStateTypes.Generalized, customImage.OSDiskImage.OsState);
Assert.Equal(OperatingSystemTypes.Linux, customImage.OSDiskImage.OsType);
Assert.NotNull(customImage.DataDiskImages);
Assert.Equal(customImage.DataDiskImages.Count, linuxVM.UnmanagedDataDisks.Count);
Assert.Equal(customImage.HyperVGeneration, HyperVGenerationTypes.V1);
foreach (ImageDataDisk diskImage in customImage.DataDiskImages.Values)
{
IVirtualMachineUnmanagedDataDisk matchedDisk = null;
foreach (var vmDisk in linuxVM.UnmanagedDataDisks.Values)
{
if (vmDisk.Lun == diskImage.Lun)
{
matchedDisk = vmDisk;
break;
}
}
Assert.NotNull(matchedDisk);
Assert.Equal(matchedDisk.CachingType, diskImage.Caching);
Assert.Equal(matchedDisk.VhdUri, diskImage.BlobUri);
Assert.Equal((long)matchedDisk.Size + 10, (long)diskImage.DiskSizeGB);
}
var image = computeManager
.VirtualMachineCustomImages
.GetByResourceGroup(rgName, vhdBasedImageName);
Assert.NotNull(image);
var images = computeManager
.VirtualMachineCustomImages
.ListByResourceGroup(rgName);
Assert.True(images.Count() > 0);
// Create virtual machine from custom image
//
var virtualMachine = computeManager.VirtualMachines
.Define(SdkContext.RandomResourceName("cusvm", 15))
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(image.Id)
.WithRootUsername("javauser")
.WithRootPassword(TestUtilities.GenerateName("Pa5$"))
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
var dataDisks = virtualMachine.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(dataDisks.Count, image.DataDiskImages.Count);
//Create a hyperv Gen2 image
var creatableDiskGen2 = computeManager
.VirtualMachineCustomImages
.Define(vhdBasedImageName + "Gen2")
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithHyperVGeneration(HyperVGenerationTypes.V2)
.WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized)
.WithOSDiskCaching(linuxVM.OSDiskCachingType);
foreach (var disk in linuxVM.UnmanagedDataDisks.Values)
{
creatableDisk.DefineDataDiskImage()
.WithLun(disk.Lun)
.FromVhd(disk.VhdUri)
.WithDiskCaching(disk.CachingType)
.WithDiskSizeInGB(disk.Size + 10) // Resize each data disk image by +10GB
.Attach();
}
IVirtualMachineCustomImage customImageGen2 = creatableDiskGen2.Create();
Assert.NotNull(customImageGen2.Id);
Assert.Equal(customImageGen2.Name, vhdBasedImageName + "Gen2");
Assert.False(customImageGen2.IsCreatedFromVirtualMachine);
Assert.Null(customImageGen2.SourceVirtualMachineId);
Assert.NotNull(customImageGen2.OSDiskImage);
Assert.NotNull(customImageGen2.OSDiskImage);
Assert.Equal(CachingTypes.ReadWrite, customImageGen2.OSDiskImage.Caching);
Assert.Equal(OperatingSystemStateTypes.Generalized, customImageGen2.OSDiskImage.OsState);
Assert.Equal(OperatingSystemTypes.Linux, customImageGen2.OSDiskImage.OsType);
Assert.NotNull(customImageGen2.DataDiskImages);
Assert.Equal(0, customImageGen2.DataDiskImages.Count);
Assert.Equal(customImageGen2.HyperVGeneration, HyperVGenerationTypes.V2);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
///GENMHASH:241ACB6281D149D09A2157D0A5B10B64:D8ACFED2D38DB0F51BD0ED4DB649ED5E
public GalleryImageVersionImpl WithSourceCustomImage(IVirtualMachineCustomImage customImage)
{
return(this.WithSourceCustomImage(customImage.Id));
}
