protected PSArgument[] CreateVirtualMachineVMImageReplicateParameters()
{
string vmImageName = string.Empty;
VirtualMachineVMImageReplicateParameters parameters = new VirtualMachineVMImageReplicateParameters();
return(ConvertFromObjectsToArguments(new string[] { "VMImageName", "Parameters" }, new object[] { vmImageName, parameters }));
}
protected void ExecuteVirtualMachineVMImageReplicateMethod(object[] invokeMethodInputParameters)
{
string vmImageName = (string)ParseParameter(invokeMethodInputParameters[0]);
VirtualMachineVMImageReplicateParameters parameters = (VirtualMachineVMImageReplicateParameters)ParseParameter(invokeMethodInputParameters[1]);
var result = VirtualMachineVMImageClient.Replicate(vmImageName, parameters);
WriteObject(result);
}
/// <summary>
/// Replicate an VM image to multiple target locations. This operation
/// is only for publishers. You have to be registered as image
/// publisher with Windows Azure to be able to call this.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.Compute.IVirtualMachineVMImageOperations.
/// </param>
/// <param name='vmImageName'>
/// Required. The name of the virtual machine image to replicate.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Replicate Virtual Machine
/// Image operation.
/// </param>
/// <returns>
/// The response body contains the published name of the image.
/// </returns>
public static Task <VirtualMachineVMImageReplicateResponse> ReplicateAsync(this IVirtualMachineVMImageOperations operations, string vmImageName, VirtualMachineVMImageReplicateParameters parameters)
{
return(operations.ReplicateAsync(vmImageName, parameters, CancellationToken.None));
}
/// <summary>
/// Replicate an VM image to multiple target locations. This operation
/// is only for publishers. You have to be registered as image
/// publisher with Windows Azure to be able to call this.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.Compute.IVirtualMachineVMImageOperations.
/// </param>
/// <param name='vmImageName'>
/// Required. The name of the virtual machine image to replicate.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Replicate Virtual Machine
/// Image operation.
/// </param>
/// <returns>
/// The response body contains the published name of the image.
/// </returns>
public static VirtualMachineVMImageReplicateResponse Replicate(this IVirtualMachineVMImageOperations operations, string vmImageName, VirtualMachineVMImageReplicateParameters parameters)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IVirtualMachineVMImageOperations)s).ReplicateAsync(vmImageName, parameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public void VMImage()
{
TestLogTracingInterceptor.Current.Start();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
var mgmt = fixture.GetManagementClient();
var compute = ComputeManagementTestUtilities.GetComputeManagementClient(fixture);
var storage = fixture.GetStorageManagementClient();
try
{
string storageAccountName = TestUtilities.GenerateName("rdfepir").ToLower();
var vmImageName = TestUtilities.GenerateName("vmimage").ToLower();
var vmImageBlobName = vmImageName + ".vhd";
var publicVMImageBlob_Linux_WestUS = new Uri("http://longlivedstoragerruswest.blob.core.test-cint.azure-test.net/vhdblobs/CoreOS-Stable-Generalized.30GB.vhd");
string location = "West US";
try
{
// **************
// SETUP
// **************
// Create storage account. Used to place vhd blobs.
storage.StorageAccounts.Create(
new StorageAccountCreateParameters
{
Location = location,
Label = storageAccountName,
Name = storageAccountName,
AccountType = StorageAccountTypes.StandardGRS
});
// Copy public vmimage blob into our storage account (needed for vmimage create call to work).
var vmImageBlobUri = Microsoft.Azure.Test.ComputeManagementTestUtilities.CopyPageBlobInStorage(
storageAccountName,
publicVMImageBlob_Linux_WestUS,
"vmimages",
vmImageBlobName);
// Create vmimage from vhd in our storage account blob. Now we can create VMs from this image.
compute.VirtualMachineVMImages.Create(
new VirtualMachineVMImageCreateParameters
{
Name = vmImageName,
Label = "test",
Description = "test",
Eula = "http://test.com",
SmallIconUri = "test",
IconUri = "test",
PrivacyUri = new Uri("http://test.com/"),
ShowInGui = false,
ImageFamily = "test",
Language = "test",
PublishedDate = DateTime.Now,
RecommendedVMSize = VirtualMachineRoleSize.Small,
OSDiskConfiguration = new OSDiskConfigurationCreateParameters
{
HostCaching = VirtualHardDiskHostCaching.ReadWrite,
OS = VirtualMachineVMImageOperatingSystemType.Windows,
OSState = VirtualMachineVMImageOperatingSystemState.Generalized,
MediaLink = vmImageBlobUri
}
});
// **************
// TESTS
// **************
var vmImageParamater = new VirtualMachineVMImageReplicateParameters()
{
TargetLocations = new[] { location },
ComputeImageAttributes = new ComputeImageAttributes()
{
Offer = "TestOffer",
Sku = "Standard",
Version = "1.0.0"
},
// Providing this should fail for a subscription that
// does not have image market place rights.
// Only one customer can hve image market place rights.
MarketplaceImageAttributes = new MarketplaceImageAttributes()
{
PublisherId = "publisherId",
Plan = new Plan()
{
Name = "PlanName",
Publisher = "PlanPublisher",
Product = "PlanProduct"
}
}
};
// Replicate (check new contract with ComputeImageAttributes and MarketplaceImageAttributes is accepted - 200 OK)
var replicateResponse = compute.VirtualMachineVMImages.Replicate(vmImageName, vmImageParamater);
Assert.Equal(HttpStatusCode.OK, replicateResponse.StatusCode);
Assert.True(!string.IsNullOrEmpty(replicateResponse.RequestId));
// ListDetails (check new contract with ComputeImageAttributes and MarketplaceImageAttributes is returned)
var vmImage = compute.VirtualMachineVMImages.GetDetails(vmImageName);
Assert.NotNull(vmImage.ComputeImageAttributes);
Assert.Equal(vmImageParamater.ComputeImageAttributes.Offer, vmImage.ComputeImageAttributes.Offer);
Assert.Equal(vmImageParamater.ComputeImageAttributes.Version, vmImage.ComputeImageAttributes.Version);
Assert.Equal(vmImageParamater.ComputeImageAttributes.Sku, vmImage.ComputeImageAttributes.Sku);
Assert.NotNull(vmImage.MarketplaceImageAttributes);
Assert.Equal(vmImageParamater.MarketplaceImageAttributes.PublisherId, vmImage.MarketplaceImageAttributes.PublisherId);
Assert.NotNull(vmImage.MarketplaceImageAttributes.Plan);
Assert.Equal(vmImageParamater.MarketplaceImageAttributes.Plan.Name, vmImage.MarketplaceImageAttributes.Plan.Name);
Assert.Equal(vmImageParamater.MarketplaceImageAttributes.Plan.Product, vmImage.MarketplaceImageAttributes.Plan.Product);
Assert.Equal(vmImageParamater.MarketplaceImageAttributes.Plan.Publisher, vmImage.MarketplaceImageAttributes.Plan.Publisher);
// Share async (check new async share succeeds)
var shareResponse = compute.VirtualMachineVMImages.Share(vmImageName, "Private");
Assert.Equal(OperationStatus.Succeeded, shareResponse.Status);
Assert.True(!string.IsNullOrEmpty(shareResponse.RequestId));
}
finally
{
// CLEANUP
// Unreplicate vm image
compute.VirtualMachineVMImages.Unreplicate(vmImageName);
// Delete vm image
compute.VirtualMachineVMImages.Delete(vmImageName, true);
// Delete storage account
storage.StorageAccounts.Delete(storageAccountName);
}
}
finally
{
undoContext.Dispose();
mgmt.Dispose();
compute.Dispose();
storage.Dispose();
TestLogTracingInterceptor.Current.Stop();
}
}
}
