public void NewAzureVMWithLinuxAndNoSSHEnpoint()
{
try
{
_serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
string newAzureLinuxVMName = Utilities.GetUniqueShortName("PSLinuxVM");
// Add-AzureProvisioningConfig with NoSSHEndpoint
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureLinuxVMName, InstanceSize.Small.ToString(), _linuxImageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(username, password, true);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
// New-AzureVM
vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm }, locationName);
Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
Collection<InputEndpointContext> endpoints = vmPowershellCmdlets.GetAzureEndPoint(vmPowershellCmdlets.GetAzureVM(newAzureLinuxVMName, _serviceName));
Console.WriteLine("The number of endpoints: {0}", endpoints.Count);
foreach (var ep in endpoints)
{
Utilities.PrintContext(ep);
}
Assert.AreEqual(0, endpoints.Count);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public void AdvancedProvisioning()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix);
string newAzureVM2Name = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
var azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName);
var azureVMConfigInfo2 = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var azureDataDiskConfigInfo = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0);
var azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.CustomProbe, ProtocolInfo.tcp, 80, 80, "web", "lbweb", 80, ProtocolInfo.http, @"/", null, null);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(serviceName, VMs);
// Cleanup
vmPowershellCmdlets.RemoveAzureVM(newAzureVM1Name, serviceName);
vmPowershellCmdlets.RemoveAzureVM(newAzureVM2Name, serviceName);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM1Name, serviceName));
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM2Name, serviceName));
pass = true;
}
private PersistentVM CreateIaaSVMObject(string vmName)
{
defaultAzureSubscription = vmPowershellCmdlets.SetAzureSubscription(defaultAzureSubscription.SubscriptionName, defaultAzureSubscription.SubscriptionId, CredentialHelper.DefaultStorageName);
vmPowershellCmdlets.SelectAzureSubscription(defaultAzureSubscription.SubscriptionName, true);
//Create an IaaS VM with a static CA.
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
return vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
}
public void NewAzureVMWithAffinityGroup()
{
_serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
string _affiniyGroupName1 = Utilities.GetUniqueShortName("aff");
string _affiniyGroupName2 = Utilities.GetUniqueShortName("aff");
try
{
// New-AzureService
vmPowershellCmdlets.NewAzureAffinityGroup(_affiniyGroupName1, locationName, "location1", "location1");
vmPowershellCmdlets.NewAzureAffinityGroup(_affiniyGroupName2, locationName, "location2", "location2");
vmPowershellCmdlets.NewAzureService(_serviceName, "service1", null, _affiniyGroupName1);
// New-AzureVMConfig
string newAzureVMName = Utilities.GetUniqueShortName("PSVM");
string imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
// Add-AzureProvisioningConfig
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
// New-AzureVM
try
{
vmPowershellCmdlets.NewAzureVMWithAG(_serviceName, new[] { vm }, _affiniyGroupName2);
Assert.Fail("Should fail, but succeeded!");
}
catch (Exception ex)
{
if (ex is AssertFailedException)
{
throw;
}
else
{
Console.WriteLine("Failure is expected. Continue the tests...");
}
}
vmPowershellCmdlets.NewAzureVMWithAG(_serviceName, new[] { vm }, _affiniyGroupName1);
Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
var vmReturned = vmPowershellCmdlets.GetAzureVM(newAzureVMName, _serviceName);
Utilities.PrintContext(vmReturned);
Assert.AreEqual(_serviceName, vmReturned.ServiceName);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public void AddEndPointACLsWithNewDeployment()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix);
string newAzureVM2Name = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
NetworkAclObject aclObj = vmPowershellCmdlets.NewAzureAclConfig();
vmPowershellCmdlets.SetAzureAclConfig(SetACLConfig.AddRule, aclObj, 100, ACLAction.Permit, "172.0.0.0/8", "notes1");
vmPowershellCmdlets.SetAzureAclConfig(SetACLConfig.AddRule, aclObj, 200, ACLAction.Deny, "10.0.0.0/8", "notes2");
var azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName);
var azureVMConfigInfo2 = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var azureDataDiskConfigInfo = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0);
var azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.DefaultProbe, ProtocolInfo.tcp, 80, 80, "web", "lbweb", aclObj, true);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(serviceName, VMs);
// Cleanup
vmPowershellCmdlets.RemoveAzureVM(newAzureVM1Name, serviceName);
vmPowershellCmdlets.RemoveAzureVM(newAzureVM2Name, serviceName);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM1Name, serviceName));
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM2Name, serviceName));
pass = true;
}
private PersistentVM CreateIaaSVMObject(string vmName)
{
//Create an IaaS VM with a static CA.
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
return vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
}
public void AzureMultiNicTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
var nic1 = "eth1";
var nic2 = "eth2";
var nic1Address = "10.0.1.40";
var nic2Address = "10.0.1.39";
// Create a VNet
var vnetConfig = vmPowershellCmdlets.GetAzureVNetConfig(null);
if (vnetConfig.Count > 0)
{
vmPowershellCmdlets.RunPSScript("Get-AzureService | Remove-AzureService -Force");
Utilities.RetryActionUntilSuccess(() => vmPowershellCmdlets.RemoveAzureVNetConfig(), "in use", 5, 30);
}
vmPowershellCmdlets.SetAzureVNetConfig(Directory.GetCurrentDirectory() + "\\VnetconfigWithLocation.netcfg");
var sites = vmPowershellCmdlets.GetAzureVNetSite(null);
var subnet = sites[0].Subnets.First().Name;
var vnetName = sites[0].Name;
// Create a new service
vmPowershellCmdlets.NewAzureService(serviceName, locationName);
// Create the VM
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Large.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
vm = (PersistentVM)vmPowershellCmdlets.SetAzureSubnet(vm, new string[] {subnet});
// AddNetworkInterfaceConfig
vm = (PersistentVM)vmPowershellCmdlets.AddAzureNetworkInterfaceConfig(nic1, subnet, nic1Address, vm);
vm = (PersistentVM)vmPowershellCmdlets.AddAzureNetworkInterfaceConfig(nic2, subnet, vm);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces.Count, 2);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[0].Name, nic1);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[0].IPConfigurations[0].SubnetName, subnet);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[0].IPConfigurations[0].StaticVirtualNetworkIPAddress, nic1Address);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[1].Name, nic2);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[1].IPConfigurations[0].SubnetName, subnet);
Assert.IsNull(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[1].IPConfigurations[0].StaticVirtualNetworkIPAddress);
// Verify SetNetworkInterfaceConfig
vm = (PersistentVM)vmPowershellCmdlets.SetAzureNetworkInterfaceConfig(nic2, subnet, nic2Address, vm);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[1].Name, nic2);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[1].IPConfigurations[0].SubnetName, subnet);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[1].IPConfigurations[0].StaticVirtualNetworkIPAddress, nic2Address);
// Verify RemoveNetworkInterfaceConfig
vm = (PersistentVM)vmPowershellCmdlets.RemoveAzureNetworkInterfaceConfig(nic2, vm);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces.Count, 1);
Assert.AreEqual(((NetworkConfigurationSet)vm.ConfigurationSets[1]).NetworkInterfaces[0].Name, nic1);
// Verify the create vm using NIC
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, vnetName, null, null, null, null, null, null, null, null, null, false );
// Verify GetNetworkInterfaceConfig
var getVM = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
Assert.AreEqual(getVM.NetworkInterfaces[0].Name, nic1);
Assert.AreEqual(getVM.NetworkInterfaces[0].IpConfigurations[0].SubnetName, subnet);
Assert.IsNotNull(getVM.NetworkInterfaces[0].MacAddress);
var getNic = vmPowershellCmdlets.GetAzureNetworkInterfaceConfig(nic1, getVM);
Assert.AreEqual(getNic.Name, nic1);
Assert.AreEqual(getNic.IpConfigurations[0].SubnetName, subnet);
Assert.IsNotNull(getNic.MacAddress);
pass = true;
}
catch (Exception e)
{
pass = false;
Console.WriteLine("Exception occurred: {0}", e.ToString());
throw;
}
}
public void AzureDnsTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
const string dnsName = "OpenDns1";
const string ipAddress = "208.67.222.222";
try
{
vmPowershellCmdlets.NewAzureService(serviceName, locationName);
DnsServer dns = vmPowershellCmdlets.NewAzureDns(dnsName, ipAddress);
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, null, new[] { dns }, null, null, null, null);
Assert.IsTrue(Verify.AzureDns(vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings, dns));
pass = true;
}
catch (Exception e)
{
pass = false;
Console.WriteLine("Exception occurred: {0}", e.ToString());
throw;
}
}
public void StopAzureVMsDeprovisionedTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
// starting the test.
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
var azureVMConfigInfo2 = new AzureVMConfigInfo(vmName2, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig2 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig2, null, null);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(svcName, VMs);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine("The VM is successfully created: {0}", vmName2);
WaitForReadyState(svcName, vmName1);
WaitForReadyState(svcName, vmName2);
var vm1 = vmPowershellCmdlets.GetAzureVM(vmName1, svcName);
var vm2 = vmPowershellCmdlets.GetAzureVM(vmName2, svcName);
Assert.AreEqual(vm1.HostName, vmName1);
Assert.AreEqual(vm2.HostName, vmName2);
// Stop and deallocate the VMs
vmPowershellCmdlets.StopAzureVM("*", svcName, false, true);
WaitForStoppedState(svcName, vmName1);
WaitForStoppedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
// Start the VMs
Utilities.RetryActionUntilSuccess(() => vmPowershellCmdlets.StartAzureVM("*", svcName), "HTTP Status Code: 409", 10, 60);
//StartAzureVMs("*", svcName);
WaitForStartedState(svcName, vmName1);
WaitForStartedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { readyState, provisioningState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { readyState, provisioningState }));
try
{
// Try to Stop and deallocate VM2 without Force. Should fail and give a warning message.
vmPowershellCmdlets.StopAzureVM("*", svcName);
Assert.Fail();
}
catch (Exception e)
{
if (e is AssertFailedException)
{
throw;
}
else
{
Console.WriteLine(e.ToString());
}
}
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { readyState, provisioningState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { readyState, provisioningState }));
// Stop and deallocate VMs
vmPowershellCmdlets.StopAzureVM("*", svcName, false, true);
WaitForStoppedState(svcName, vmName1);
WaitForStoppedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
public void StopAzureVMsStayProvisionedTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
// starting the test.
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
var azureVMConfigInfo2 = new AzureVMConfigInfo(vmName2, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig2 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig2, null, null);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(svcName, VMs);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine("The VM is successfully created: {0}", vmName2);
WaitForStartingState(svcName, vmName1);
WaitForStartingState(svcName, vmName2);
vmPowershellCmdlets.StopAzureVM("*", svcName, true, true);
WaitForStoppedState(svcName, vmName1);
WaitForStoppedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedProvisionedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedProvisionedState }));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
public void CaptureImagingExportingImportingVMConfig()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
// Create a unique VM name
string newAzureVMName = Utilities.GetUniqueShortName("PSTestVM");
Console.WriteLine("VM Name: {0}", newAzureVMName);
// Create a unique Service Name
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
Console.WriteLine("Service Name: {0}", serviceName);
if (string.IsNullOrEmpty(imageName))
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
// starting the test.
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName); // parameters for New-AzureVMConfig (-Name -InstanceSize -ImageName)
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password); // parameters for Add-AzureProvisioningConfig (-Windows -Password)
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM persistentVM = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo); // New-AzureVMConfig & Add-AzureProvisioningConfig
PersistentVM[] VMs = { persistentVM };
vmPowershellCmdlets.NewAzureVM(serviceName, VMs); // New-AzureVM
Console.WriteLine("The VM is successfully created: {0}", persistentVM.RoleName);
PersistentVMRoleContext vmRoleCtxt = vmPowershellCmdlets.GetAzureVM(persistentVM.RoleName, serviceName);
Assert.AreEqual(vmRoleCtxt.Name, persistentVM.RoleName, true);
vmPowershellCmdlets.StopAzureVM(newAzureVMName, serviceName, true); // Stop-AzureVM
for (int i = 0; i < 3; i++)
{
vmRoleCtxt = vmPowershellCmdlets.GetAzureVM(persistentVM.RoleName, serviceName);
if (vmRoleCtxt.InstanceStatus == "StoppedVM")
{
Console.WriteLine("The status of the VM {0} : {1}", persistentVM.RoleName, vmRoleCtxt.InstanceStatus);
break;
}
Console.WriteLine("The status of the VM {0} : {1}", persistentVM.RoleName, vmRoleCtxt.InstanceStatus);
Thread.Sleep(120000);
}
Assert.AreEqual(vmRoleCtxt.InstanceStatus, "StoppedVM", true);
// Save-AzureVMImage
vmPowershellCmdlets.SaveAzureVMImage(serviceName, newAzureVMName, newAzureVMName);
// Verify VM image.
var image = vmPowershellCmdlets.GetAzureVMImage(newAzureVMName)[0];
Assert.AreEqual("Windows", image.OS, "OS is not matching!");
Assert.AreEqual(newAzureVMName, image.ImageName, "Names are not matching!");
// Verify that the VM is removed
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(persistentVM.RoleName, serviceName));
// Cleanup the registered image
vmPowershellCmdlets.RemoveAzureVMImage(newAzureVMName, true);
pass = true;
}
public void DevTestProvisioning()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix);
//Find a Windows VM Image
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
//Specify a small Windows image, with username and pw
AzureVMConfigInfo azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName);
AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
AzureEndPointConfigInfo azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 80, 80, "Http");
PersistentVMConfigInfo persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, null, azureEndPointConfigInfo);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
//Add all the endpoints that are added by the Dev Test feature in Azure Tools
azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 443, 443, "Https");
azureEndPointConfigInfo.Vm = persistentVM1;
persistentVM1 = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo);
azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 1433, 1433, "MSSQL");
azureEndPointConfigInfo.Vm = persistentVM1;
persistentVM1 = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo);
azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 8172, 8172, "WebDeploy");
azureEndPointConfigInfo.Vm = persistentVM1;
persistentVM1 = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo);
// Make a storage account named "devtestNNNNN"
string storageAcctName = "devtest" + new Random().Next(10000, 99999);
vmPowershellCmdlets.NewAzureStorageAccount(storageAcctName, locationName);
// When making a new azure VM, you can't specify a location if you want to use the existing service
PersistentVM[] VMs = { persistentVM1 };
vmPowershellCmdlets.NewAzureVM(serviceName, VMs, locationName);
var svcDeployment = vmPowershellCmdlets.GetAzureDeployment(serviceName);
Assert.AreEqual(svcDeployment.ServiceName, serviceName);
var vmDeployment = vmPowershellCmdlets.GetAzureVM(newAzureVM1Name, serviceName);
Assert.AreEqual(vmDeployment.InstanceName, newAzureVM1Name);
// Cleanup
vmPowershellCmdlets.RemoveAzureVM(newAzureVM1Name, serviceName);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM1Name, serviceName));
Utilities.RetryActionUntilSuccess(() => vmPowershellCmdlets.RemoveAzureStorageAccount(storageAcctName), "in use", 10, 30);
pass = true;
}
public void NewAzureVMDomainJoinTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
var newAzureVMName = Utilities.GetUniqueShortName(vmNamePrefix);
const string joinDomainStr = "www.microsoft.com";
const string domainStr = "microsoft.com";
const string domainUser = "******";
const string domainPassword = "******";
try
{
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo("WindowsDomain", username, password,
joinDomainStr, domainStr, domainUser,
domainPassword);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null,
null);
PersistentVM persistentVM = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
PersistentVM[] VMs = { persistentVM };
vmPowershellCmdlets.NewAzureVM(serviceName, VMs);
// Todo: Check the domain of the VM
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
public void AzureIaaSBVT()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
DateTime prevTime = DateTime.Now;
string diskLabel1 = "disk1";
int diskSize1 = 30;
int lunSlot1 = 0;
string diskLabel2 = "disk2";
int diskSize2 = 50;
int lunSlot2 = 2;
string ep1Name = "tcp1";
int ep1LocalPort = 60010;
int ep1PublicPort = 60011;
string ep1LBSetName = "lbset1";
int ep1ProbePort = 60012;
string ep1ProbePath = string.Empty;
int? ep1ProbeInterval = 7;
int? ep1ProbeTimeout = null;
NetworkAclObject ep1AclObj = vmPowershellCmdlets.NewAzureAclConfig();
bool ep1DirectServerReturn = false;
string ep2Name = "tcp2";
int ep2LocalPort = 60020;
int ep2PublicPort = 60021;
int ep2LocalPortChanged = 60030;
int ep2PublicPortChanged = 60031;
string ep2LBSetName = "lbset2";
int ep2ProbePort = 60022;
string ep2ProbePath = @"/";
int? ep2ProbeInterval = null;
int? ep2ProbeTimeout = 32;
NetworkAclObject ep2AclObj = vmPowershellCmdlets.NewAzureAclConfig();
bool ep2DirectServerReturn = false;
string cerFileName = "testcert.cer";
string thumbprintAlgorithm = "sha1";
try
{
// Create a certificate
X509Certificate2 certCreated = Utilities.CreateCertificate(password);
byte[] certData2 = certCreated.Export(X509ContentType.Cert);
File.WriteAllBytes(cerFileName, certData2);
// Install the .cer file to local machine.
StoreLocation certStoreLocation = StoreLocation.CurrentUser;
StoreName certStoreName = StoreName.My;
X509Certificate2 installedCert = Utilities.InstallCert(cerFileName, certStoreLocation, certStoreName);
PSObject certToUpload = vmPowershellCmdlets.RunPSScript(
String.Format("Get-Item cert:\\{0}\\{1}\\{2}", certStoreLocation.ToString(), certStoreName.ToString(), installedCert.Thumbprint))[0];
string certData = Convert.ToBase64String(((X509Certificate2)certToUpload.BaseObject).RawData);
string newAzureVMName = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
RecordTimeTaken(ref prevTime);
//
// New-AzureService and verify with Get-AzureService
//
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
Assert.IsTrue(Verify.AzureService(serviceName, serviceName, locationName));
RecordTimeTaken(ref prevTime);
//
// Add-AzureCertificate and verify with Get-AzureCertificate
//
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
Assert.IsTrue(Verify.AzureCertificate(serviceName, certCreated.Thumbprint, thumbprintAlgorithm, certData));
RecordTimeTaken(ref prevTime);
//
// Remove-AzureCertificate
//
vmPowershellCmdlets.RemoveAzureCertificate(serviceName, certCreated.Thumbprint, thumbprintAlgorithm);
Assert.IsTrue(Utilities.CheckRemove(vmPowershellCmdlets.GetAzureCertificate, serviceName, certCreated.Thumbprint, thumbprintAlgorithm));
RecordTimeTaken(ref prevTime);
//
// New-AzureVMConfig
//
AzureVMConfigInfo azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small, imageName);
PersistentVM vm = vmPowershellCmdlets.NewAzureVMConfig(azureVMConfigInfo);
RecordTimeTaken(ref prevTime);
//
// Add-AzureCertificate
//
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
//
// New-AzureCertificateSetting
//
CertificateSettingList certList = new CertificateSettingList();
certList.Add(vmPowershellCmdlets.NewAzureCertificateSetting(certStoreName.ToString(), installedCert.Thumbprint));
RecordTimeTaken(ref prevTime);
//
// Add-AzureProvisioningConfig
//
AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, certList, username, password);
azureProvisioningConfig.Vm = vm;
vm = vmPowershellCmdlets.AddAzureProvisioningConfig(azureProvisioningConfig);
RecordTimeTaken(ref prevTime);
//
// Add-AzureDataDisk (two disks)
//
AddAzureDataDiskConfig azureDataDiskConfigInfo1 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize1, diskLabel1, lunSlot1);
azureDataDiskConfigInfo1.Vm = vm;
vm = vmPowershellCmdlets.AddAzureDataDisk(azureDataDiskConfigInfo1);
AddAzureDataDiskConfig azureDataDiskConfigInfo2 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize2, diskLabel2, lunSlot2);
azureDataDiskConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.AddAzureDataDisk(azureDataDiskConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Add-AzureEndpoint (two endpoints)
//
AzureEndPointConfigInfo azureEndPointConfigInfo1 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep1LocalPort,
ep1PublicPort,
ep1Name,
ep1LBSetName,
ep1ProbePort,
ProtocolInfo.tcp,
ep1ProbePath,
ep1ProbeInterval,
ep1ProbeTimeout,
ep1AclObj,
ep1DirectServerReturn);
azureEndPointConfigInfo1.Vm = vm;
vm = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo1);
AzureEndPointConfigInfo azureEndPointConfigInfo2 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPort,
ep2PublicPort,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
azureEndPointConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Set-AzureAvailabilitySet
//
string testAVSetName = "testAVSet1";
vm = vmPowershellCmdlets.SetAzureAvailabilitySet(testAVSetName, vm);
RecordTimeTaken(ref prevTime);
//
// New-AzureDns
//
string dnsName = "OpenDns1";
string ipAddress = "208.67.222.222";
DnsServer dns = vmPowershellCmdlets.NewAzureDns(dnsName, ipAddress);
RecordTimeTaken(ref prevTime);
//
// New-AzureVM
//
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, null, new[] { dns }, null, null, null, null);
RecordTimeTaken(ref prevTime);
//
// Get-AzureVM
//
PersistentVMRoleContext returnedVM = vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName);
vm = returnedVM.VM;
RecordTimeTaken(ref prevTime);
//
// Verify AzureDataDisk
//
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel1, diskSize1, lunSlot1, HostCaching.None), "Data disk is not properly added");
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel2, diskSize2, lunSlot2, HostCaching.None), "Data disk is not properly added");
Console.WriteLine("Data disk added correctly.");
RecordTimeTaken(ref prevTime);
//
// Verify AzureEndpoint
//
Assert.IsTrue(Verify.AzureEndpoint(vm, new[]{azureEndPointConfigInfo1, azureEndPointConfigInfo2}));
//
// Verify AzureDns
//
Assert.IsTrue(Verify.AzureDns(vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings, dns));
//
// Verify AzureAvailibilitySet
//
Assert.IsTrue(Verify.AzureAvailabilitySet(vm, testAVSetName));
//
// Verify AzureOsDisk
//
Assert.IsTrue(Verify.AzureOsDisk(vm, "Windows", HostCaching.ReadWrite));
//
// Set-AzureDataDisk
//
SetAzureDataDiskConfig setAzureDataDiskConfigInfo = new SetAzureDataDiskConfig(HostCaching.ReadOnly, lunSlot1);
setAzureDataDiskConfigInfo.Vm = vm;
vm = vmPowershellCmdlets.SetAzureDataDisk(setAzureDataDiskConfigInfo);
RecordTimeTaken(ref prevTime);
//
// Remove-AzureDataDisk
//
RemoveAzureDataDiskConfig removeAzureDataDiskConfig = new RemoveAzureDataDiskConfig(lunSlot2, vm);
vm = vmPowershellCmdlets.RemoveAzureDataDisk(removeAzureDataDiskConfig);
RecordTimeTaken(ref prevTime);
//
// Set-AzureEndpoint
//
azureEndPointConfigInfo2 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPortChanged,
ep2PublicPortChanged,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
azureEndPointConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.SetAzureEndPoint(azureEndPointConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Remove-AzureEndpoint
//
vm = vmPowershellCmdlets.RemoveAzureEndPoint(azureEndPointConfigInfo1.EndpointName, vm);
RecordTimeTaken(ref prevTime);
//
// Set-AzureVMSize
//
SetAzureVMSizeConfig vmSizeConfig = new SetAzureVMSizeConfig(InstanceSize.Medium);
vmSizeConfig.Vm = vm;
vm = vmPowershellCmdlets.SetAzureVMSize(vmSizeConfig);
RecordTimeTaken(ref prevTime);
//
// Set-AzureOSDisk
//
vm = vmPowershellCmdlets.SetAzureOSDisk(HostCaching.ReadOnly, vm);
//
// Update-AzureVM
//
vmPowershellCmdlets.UpdateAzureVM(newAzureVMName, serviceName, vm);
RecordTimeTaken(ref prevTime);
//
// Get-AzureVM and Verify the VM
//
vm = vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName).VM;
// Verify setting data disk
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel1, diskSize1, lunSlot1, HostCaching.ReadOnly), "Data disk is not properly added");
// Verify removing a data disk
Assert.AreEqual(1, vmPowershellCmdlets.GetAzureDataDisk(vm).Count, "DataDisk is not removed.");
// Verify setting an endpoint
Assert.IsTrue(Verify.AzureEndpoint(vm, new[]{azureEndPointConfigInfo2}));
// Verify removing an endpoint
Assert.IsFalse(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo1 }));
// Verify os disk
Assert.IsTrue(Verify.AzureOsDisk(vm, "Windows", HostCaching.ReadOnly));
//
// Remove-AzureVM
//
vmPowershellCmdlets.RemoveAzureVM(newAzureVMName, serviceName);
RecordTimeTaken(ref prevTime);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
public AddAzureProvisioningConfigCmdletInfo(AzureProvisioningConfigInfo provConfig)
{
this.cmdletName = Utilities.AddAzureProvisioningConfigCmdletName;
this.cmdletParams.Add(new CmdletParam("VM", provConfig.Vm));
var parameterSet = string.IsNullOrEmpty(provConfig.Option) ? provConfig.OS.ToString() : provConfig.Option;
this.cmdletParams.Add(new CmdletParam(parameterSet));
if (!string.IsNullOrEmpty(provConfig.Password))
{
this.cmdletParams.Add(new CmdletParam("Password", provConfig.Password));
}
if (!string.IsNullOrEmpty(provConfig.CustomDataFile))
{
this.cmdletParams.Add(new CmdletParam("CustomDataFile", provConfig.CustomDataFile));
}
// For Linux parameter set
if (parameterSet.Equals(OS.Linux.ToString()))
{
this.cmdletParams.Add(new CmdletParam("LinuxUser", provConfig.LinuxUser));
if (provConfig.DisableSSH)
{
this.cmdletParams.Add(new CmdletParam("DisableSSH"));
}
if (provConfig.NoSSHEndpoint)
{
this.cmdletParams.Add(new CmdletParam("NoSSHEndpoint"));
}
if (provConfig.SSHKeyPairs != null && provConfig.SSHKeyPairs.Count != 0)
{
this.cmdletParams.Add(new CmdletParam("SSHKeyPairs", provConfig.SSHKeyPairs));
}
if (provConfig.SshPublicKeys != null && provConfig.SshPublicKeys.Count != 0)
{
this.cmdletParams.Add(new CmdletParam("SSHPublicKeys", provConfig.SshPublicKeys));
}
if(provConfig.NoSSHPassword)
{
this.cmdletParams.Add(new CmdletParam("NoSSHPassword"));
}
}
// For Windows/WindowsDomain parameter set
if (parameterSet.Equals(provConfig.WindowsDomain) || parameterSet.Equals(OS.Windows.ToString()))
{
this.cmdletParams.Add(new CmdletParam("AdminUsername", provConfig.AdminUsername));
if (provConfig.DisableAutomaticUpdate)
{
this.cmdletParams.Add(new CmdletParam("DisableAutomaticUpdates"));
}
if (provConfig.DisableGuestAgent)
{
this.cmdletParams.Add(new CmdletParam("DisableGuestAgent"));
}
if (provConfig.DisableWinRMHttps)
{
this.cmdletParams.Add(new CmdletParam("DisableWinRMHttps"));
}
if (provConfig.EnableWinRMHttp)
{
this.cmdletParams.Add(new CmdletParam("EnableWinRMHttp"));
}
if (provConfig.NoWinRMEndpoint)
{
this.cmdletParams.Add(new CmdletParam("NoWinRMEndpoint"));
}
if (provConfig.Reset)
{
this.cmdletParams.Add(new CmdletParam("ResetPasswordOnFirstLogon"));
}
if (provConfig.NoExportPrivateKey)
{
this.cmdletParams.Add(new CmdletParam("NoExportPrivateKey"));
}
if (provConfig.NoRDPEndpoint)
{
this.cmdletParams.Add(new CmdletParam("NoRDPEndpoint"));
}
if (!string.IsNullOrEmpty(provConfig.TimeZone))
{
this.cmdletParams.Add(new CmdletParam("TimeZone", provConfig.TimeZone));
}
if (provConfig.Certs != null && provConfig.Certs.Count != 0)
{
this.cmdletParams.Add(new CmdletParam("Certificates", provConfig.Certs));
}
if (provConfig.WinRMCertificate != null)
{
this.cmdletParams.Add(new CmdletParam("WinRMCertificate", provConfig.WinRMCertificate));
}
if (provConfig.X509Certificates != null)
{
this.cmdletParams.Add(new CmdletParam("X509Certificates", provConfig.X509Certificates));
}
}
// For WindowsDomain parameter set
if (parameterSet.Equals(provConfig.WindowsDomain))
{
this.cmdletParams.Add(new CmdletParam("Domain", provConfig.Domain));
this.cmdletParams.Add(new CmdletParam("JoinDomain", provConfig.JoinDomain));
this.cmdletParams.Add(new CmdletParam("DomainUserName", provConfig.DomainUserName));
this.cmdletParams.Add(new CmdletParam("DomainPassword", provConfig.DomainPassword));
if (!string.IsNullOrEmpty(provConfig.MachineObjectOU))
{
this.cmdletParams.Add(new CmdletParam("MachineObjectOU", provConfig.MachineObjectOU));
}
}
}
public void CreateVirtualMachineUsingVMImageWithDataDisks()
{
StartTest(MethodBase.GetCurrentMethod().Name, DateTime.Now);
try
{
// Try to get VM image with data disks
var vmImages = vmPowershellCmdlets.GetAzureVMImageReturningVMImages();
var vmImage = vmImages.Where(t => t.OS == "Windows" && t.Category == "Public" && t.DataDiskConfigurations != null
&& t.Location.Contains(locationName) && t.DataDiskConfigurations.Any()).FirstOrDefault();
// New-AzureService and verify with Get-AzureService
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
Assert.IsTrue(Verify.AzureService(serviceName, serviceName, locationName));
// New-AzureVMConfig
var vmName = Utilities.GetUniqueShortName(vmNamePrefix);
var vmSize = InstanceSize.ExtraLarge.ToString();
var currentStorage = vmPowershellCmdlets.GetAzureStorageAccount(defaultAzureSubscription.CurrentStorageAccountName).First();
var mediaLocationStr = ("mloc" + vmName).ToLower();
var vmMediaLocation = currentStorage.Endpoints.Where(p => p.Contains("blob")).First() + mediaLocationStr;
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, vmSize, vmImage.ImageName, vmMediaLocation);
PersistentVM vm = vmPowershellCmdlets.NewAzureVMConfig(azureVMConfigInfo);
// Add-AzureProvisioningConfig
AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password, true);
azureProvisioningConfig.Vm = vm;
vm = vmPowershellCmdlets.AddAzureProvisioningConfig(azureProvisioningConfig);
// New-AzureVM
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, null, null, null, null, null, null, null, null, null, null, true);
pass = true;
// Get-AzureVM
var returnedVM = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
Assert.IsTrue(returnedVM.VM.DataVirtualHardDisks != null && returnedVM.VM.DataVirtualHardDisks.Count() == vmImage.DataDiskConfigurations.Count());
Assert.IsTrue(returnedVM.VM.DataVirtualHardDisks.All(t => t.MediaLink.ToString().StartsWith(vmMediaLocation)));
// Remove-AzureVM
vmPowershellCmdlets.RemoveAzureVM(vmName, serviceName);
// Remove-AzureService
vmPowershellCmdlets.RemoveAzureService(serviceName, true);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
public void AzureCertificateSettingTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
// Create a certificate
string cerFileName = Convert.ToString(TestContext.DataRow["cerFileName"]);
X509Certificate2 certCreated = Utilities.CreateCertificate(password);
byte[] certData2 = certCreated.Export(X509ContentType.Cert);
File.WriteAllBytes(cerFileName, certData2);
// Install the .cer file to local machine.
StoreLocation certStoreLocation = StoreLocation.CurrentUser;
StoreName certStoreName = StoreName.My;
X509Certificate2 installedCert = Utilities.InstallCert(cerFileName, certStoreLocation, certStoreName);
PSObject certToUpload = vmPowershellCmdlets.RunPSScript(
String.Format("Get-Item cert:\\{0}\\{1}\\{2}", certStoreLocation.ToString(), certStoreName.ToString(), installedCert.Thumbprint))[0];
try
{
vmPowershellCmdlets.NewAzureService(serviceName, locationName);
var certList = new CertificateSettingList();
certList.Add(vmPowershellCmdlets.NewAzureCertificateSetting(certStoreName.ToString(), installedCert.Thumbprint));
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, certList, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
// Negative Test:
// Try to deploy a VM with a certificate that does not exist in the hosted service.
// This should fail.
try
{
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm });
Assert.Fail(
"Should have failed, but it succeeded !! New-AzureVM should fail if it contains a thumbprint that does not exist in the hosted service.");
}
catch (Exception e)
{
if (e is AssertFailedException)
{
throw;
}
Console.WriteLine("This exception is expected: {0}", e);
}
// Now we add the certificate to the hosted service.
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm });
PersistentVMRoleContext result = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
Console.WriteLine("{0} is created", result.Name);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine(e.InnerException);
throw;
}
finally
{
Utilities.UninstallCert(installedCert, certStoreLocation, certStoreName);
}
}
public void StopAzureVMsOnDeallocatedVMTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
// Configure VM1
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
// Configure VM2
var azureVMConfigInfo2 = new AzureVMConfigInfo(vmName2, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig2 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig2, null, null);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(svcName, VMs, null, true);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine("The VM is successfully created: {0}", vmName2);
// Stop and deallocate the VMs
vmPowershellCmdlets.StopAzureVM("*", svcName, false, true);
WaitForStoppedState(svcName, vmName1);
WaitForStoppedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
try
{
// Try to stop the VMs with StayProvisioned. Should fail.
vmPowershellCmdlets.StopAzureVM("*", svcName, true, true);
Assert.Fail();
}
catch (Exception e)
{
if (e is AssertFailedException)
{
throw;
}
else
{
Console.WriteLine(e.ToString());
}
}
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
try
{
// Try to stop the VMs without any option. Should fail and give a warning message.
vmPowershellCmdlets.StopAzureVM("*", svcName);
Assert.Fail();
}
catch (Exception e)
{
if (e is AssertFailedException)
{
throw;
}
else
{
Console.WriteLine(e.ToString());
}
}
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
// Try to stop and deallocate the VM again.
vmPowershellCmdlets.StopAzureVM("*", svcName, false, true);
WaitForStoppedState(svcName, vmName1);
WaitForStoppedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
public void AzureDnsTest2()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
const string dnsName = "OpenDns1";
const string ipAddress = "208.67.222.222";
const string ipAddress2 = "127.0.0.1";
try
{
vmPowershellCmdlets.NewAzureService(serviceName, locationName);
// Create a VM
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm });
// Add a DNS server
vmPowershellCmdlets.AddAzureDns(dnsName, ipAddress, serviceName);
var dnsServer = vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings.DnsServers[0];
Assert.AreEqual(dnsName, dnsServer.Name);
Assert.AreEqual(ipAddress, dnsServer.Address);
// Edit the DNS server
vmPowershellCmdlets.SetAzureDns(dnsName, ipAddress2, serviceName);
dnsServer = vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings.DnsServers[0];
Assert.AreEqual(dnsName, dnsServer.Name);
Assert.AreEqual(ipAddress2, dnsServer.Address);
// Remove the DNS server
vmPowershellCmdlets.RemoveAzureDns(dnsName, serviceName, force:true);
Assert.IsNull(vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings);
pass = true;
}
catch (Exception e)
{
pass = false;
Console.WriteLine("Exception occurred: {0}", e.ToString());
throw;
}
}
public void RestartAzureVMTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
DateTime prevTime = DateTime.Now;
// starting the test.
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
PersistentVM[] VMs = { persistentVM1 };
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.NewAzureVM(svcName, VMs, null, true);
Utilities.RecordTimeTaken(ref prevTime);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine(vmPowershellCmdlets.GetAzureVM(vmName1, svcName).InstanceStatus);
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.StopAzureVM(vmName1, svcName, true);
Utilities.RecordTimeTaken(ref prevTime);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedProvisionedState }));
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.StartAzureVM(vmName1, svcName);
Utilities.RecordTimeTaken(ref prevTime);
WaitForReadyState(svcName, vmName1);
Utilities.RecordTimeTaken(ref prevTime);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { readyState }));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
public void AzureSubnetTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
//vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
string[] subs = { "subnet1", "subnet2", "subnet3" };
PersistentVM vm = vmPowershellCmdlets.SetAzureSubnet(vmPowershellCmdlets.AddAzureProvisioningConfig(azureProvisioningConfig), subs);
SubnetNamesCollection subnets = vmPowershellCmdlets.GetAzureSubnet(vm);
foreach (string subnet in subnets)
{
Console.WriteLine("Subnet: {0}", subnet);
}
CollectionAssert.AreEqual(subnets, subs);
pass = true;
}
catch (Exception e)
{
Console.WriteLine("Exception occurred: {0}", e);
throw;
}
}
public void StopAzureVMStayProvisionedTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
// starting the test.
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
var azureVMConfigInfo2 = new AzureVMConfigInfo(vmName2, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig2 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig2, null, null);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(svcName, VMs);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine("The VM is successfully created: {0}", vmName2);
WaitForStartingState(svcName, vmName1);
vmPowershellCmdlets.StopAzureVM(vmName1, svcName, true); // Stop-AzureVM -StayProvisioned against VM1
for (int i = 0; i < 10 ; i++)
{
if (CheckRoleInstanceState(svcName, vmName1, new string[] {stoppedProvisionedState}))
{
break;
}
Thread.Sleep(1000);
}
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedProvisionedState }));
// Stop-AzureVM -StayProvisioned against VM2
vmPowershellCmdlets.RunPSScript(string.Format("{0} -ServiceName {1} -Name {2} | {3} -StayProvisioned",
Utilities.GetAzureVMCmdletName, svcName, vmName2, Utilities.StopAzureVMCmdletName));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string [] {stoppedProvisionedState}));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string [] {stoppedProvisionedState}));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
private void CreateNewAzureVM()
{
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
}
public void RestartAzureVMAfterDeallocateTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
DateTime prevTime = DateTime.Now;
// starting the test.
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
PersistentVM[] VMs = { persistentVM1 };
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.NewAzureVM(svcName, VMs, null, true);
Utilities.RecordTimeTaken(ref prevTime);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine(vmPowershellCmdlets.GetAzureVM(vmName1, svcName).InstanceStatus);
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.StopAzureVM(vmName1, svcName, false, true);
Utilities.RecordTimeTaken(ref prevTime);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
for (int i = 0 ; i < 10 ; i++)
{
try
{
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.StartAzureVM(vmName1, svcName);
Utilities.RecordTimeTaken(ref prevTime);
break;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Thread.Sleep(60 * 1000);
}
}
WaitForReadyState(svcName, vmName1);
Utilities.RecordTimeTaken(ref prevTime);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new [] { readyState }));
var vm = vmPowershellCmdlets.GetAzureVM(vmName1, svcName).VM;
var vmSizeConfig = new SetAzureVMSizeConfig(InstanceSize.Medium.ToString());
vmSizeConfig.Vm = vm;
vm = vmPowershellCmdlets.SetAzureVMSize(vmSizeConfig);
vmPowershellCmdlets.UpdateAzureVM(vmName1, svcName, vm);
vm = vmPowershellCmdlets.GetAzureVM(vmName1, svcName).VM;
Console.WriteLine("RoleSize: {0}", vm.RoleSize);
Assert.AreEqual(InstanceSize.Medium.ToString(), vm.RoleSize);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
public void NewAzureVMWithWindowsAndCustomData()
{
try
{
_serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
string newAzureVMName = Utilities.GetUniqueShortName("PSWinVM");
var customDataFile = @".\CustomData.bin";
var customDataContent = File.ReadAllText(customDataFile);
// Add-AzureProvisioningConfig with X509Certificate
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(username, password, customDataFile);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
// New-AzureVM
vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm }, locationName);
Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
StopAzureVMTest.WaitForReadyState(_serviceName, newAzureVMName, 60, 30);
// Get-AzureVM
var vmContext = vmPowershellCmdlets.GetAzureVM(newAzureVMName, _serviceName);
// Get-AzureCertificate
var winRmCert = vmPowershellCmdlets.GetAzureCertificate(_serviceName, vmContext.VM.DefaultWinRmCertificateThumbprint, "sha1").First();
// Install the WinRM cert to the local machine's root location.
InstallCertificate(winRmCert, StoreLocation.LocalMachine, StoreName.Root);
// Invoke Command
var connUri = vmPowershellCmdlets.GetAzureWinRMUri(_serviceName, newAzureVMName);
var cred = new PSCredential(username, Utilities.convertToSecureString(password));
var scriptBlock = ScriptBlock.Create(@"Get-Content -Path 'C:\AzureData\CustomData.bin'");
var invokeInfo = new InvokeCommandCmdletInfo(connUri, cred, scriptBlock);
var invokeCmd = new PowershellCmdlet(invokeInfo);
var results = invokeCmd.Run(false);
Assert.IsTrue(customDataContent == results.First().BaseObject as string);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public void RestartAzureVMsAfterDeallocateTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
// starting the test.
DateTime prevTime = DateTime.Now;
// Configure VM1
var azureVMConfigInfo1 = new AzureVMConfigInfo(vmName1, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig1 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig1, null, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
// Configure VM2
var azureVMConfigInfo2 = new AzureVMConfigInfo(vmName2, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig2 = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig2, null, null);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.NewAzureVM(svcName, VMs, null, true);
Utilities.RecordTimeTaken(ref prevTime);
Console.WriteLine("The VM is successfully created: {0}", vmName1);
Console.WriteLine("The VM is successfully created: {0}", vmName2);
Console.WriteLine(vmPowershellCmdlets.GetAzureVM(vmName1, svcName).InstanceStatus);
Console.WriteLine(vmPowershellCmdlets.GetAzureVM(vmName2, svcName).InstanceStatus);
// Stop VM1 one only using wildcard name
string vm1WildcardName = vmName1.Replace(prefixVMName, "*");
Utilities.RecordTimeTaken(ref prevTime);
Utilities.RetryActionUntilSuccess(() => vmPowershellCmdlets.StopAzureVM(vm1WildcardName, svcName, false, true), "HTTP Status Code: 409", 10, 60);
Utilities.RecordTimeTaken(ref prevTime);
WaitForStoppedState(svcName, vmName1);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
// Start VM1 one only using wildcard name
Utilities.RecordTimeTaken(ref prevTime);
Utilities.RetryActionUntilSuccess(() => vmPowershellCmdlets.StartAzureVM(vm1WildcardName, svcName), "HTTP Status Code: 409", 10, 60);
Utilities.RecordTimeTaken(ref prevTime);
WaitForReadyState(svcName, vmName1);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { readyState }));
Utilities.RecordTimeTaken(ref prevTime);
vmPowershellCmdlets.StopAzureVM("*", svcName, false, true);
Utilities.RecordTimeTaken(ref prevTime);
WaitForStoppedState(svcName, vmName1);
WaitForStoppedState(svcName, vmName2);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { stoppedDeallocatedState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { stoppedDeallocatedState }));
Utilities.RecordTimeTaken(ref prevTime);
Utilities.RetryActionUntilSuccess(() => vmPowershellCmdlets.StartAzureVM("*", svcName), "HTTP Status Code: 409", 10, 60);
Utilities.RecordTimeTaken(ref prevTime);
WaitForReadyState(svcName, vmName1);
WaitForReadyState(svcName, vmName2);
Utilities.RecordTimeTaken(ref prevTime);
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName1, new string[] { readyState }));
Assert.IsTrue(CheckRoleInstanceState(svcName, vmName2, new string[] { readyState }));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
if ((cleanupIfPassed && pass) || (cleanupIfFailed && !pass))
{
vmPowershellCmdlets.RemoveAzureService(svcName);
}
}
}
public void NewAzureVMWithWinRMCertificateTest()
{
try
{
_serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
string newAzureVMName = Utilities.GetUniqueShortName("PSWinVM");
// Add-AzureProvisioningConfig with X509Certificate
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(username, password, _installedCert);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
// New-AzureVM
vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm }, null);
Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
var result = vmPowershellCmdlets.GetAzureVM(newAzureVMName, _serviceName);
Assert.AreEqual(_installedCert.Thumbprint, result.VM.WinRMCertificate.Thumbprint);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public void StaticCAExhautionTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string vnet1 = VirtualNets[0];
string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
try
{
//Test a static CA
//Test-AzureStaticVNetIP-VNetName $vnet -IPAddress “10.0.0.5”
const string ipaddress = "10.64.0.5";
var availibiltyContext = vmPowershellCmdlets.TestAzureStaticVNetIP(vnet1, ipaddress);
//Assert that it is available.
Assert.IsTrue(availibiltyContext.IsAvailable);
var vm = CreatIaasVMObject(vmName1, ipaddress, StaticCASubnet1);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, vnet1, new DnsServer[1] { DnsServers[0] },
serviceName, "service for DeployVMWithStaticCATest", string.Empty, string.Empty, null, AffinityGroup);
Console.WriteLine("New Azure service with name:{0} created successfully.", serviceName);
availibiltyContext = vmPowershellCmdlets.TestAzureStaticVNetIP(vnet1, ipaddress);
int availableVIPsCount = availibiltyContext.AvailableAddresses.Count();
Console.WriteLine(string.Format("AvailableAddresses:{0}{1}", Environment.NewLine, availibiltyContext.AvailableAddresses.Aggregate((current, next) => current + Environment.NewLine + next)));
Console.WriteLine("VIPs avilable now:{0}", availableVIPsCount);
int i = 0;
foreach (string ip in availibiltyContext.AvailableAddresses)
{
Console.WriteLine("Creating VM-{0} with IP: {1}", ++i,ip);
vm = CreatIaasVMObject(Utilities.GetUniqueShortName(vmNamePrefix), ip, StaticCASubnet1);
vmPowershellCmdlets.NewAzureVM(serviceName,new[] {vm},null);
Console.WriteLine("Created VM-{0} with IP: {1}", i,ip);
}
//try to create an vm and verify that it fails
Console.WriteLine("Creating VM-{0}", ++i);
vm = vmPowershellCmdlets.NewAzureVMConfig(new AzureVMConfigInfo(Utilities.GetUniqueShortName(vmNamePrefix), InstanceSize.Small.ToString(), imageName));
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
azureProvisioningConfig.Vm = vm;
vm = vmPowershellCmdlets.AddAzureProvisioningConfig(azureProvisioningConfig);
vm = vmPowershellCmdlets.SetAzureSubnet(vm, new [] { StaticCASubnet1 });
Utilities.VerifyFailure(() => vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }),BadRequestException);
Console.WriteLine("Creating VM-{0} failed as expected.",i);
pass = true;
}
catch (Exception)
{
pass = false;
throw;
}
}
public void NewAzureLinuxVMWithoutPasswordAndNoSSHEnpoint()
{
try
{
_serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
//Create service
vmPowershellCmdlets.NewAzureService(_serviceName, locationName);
//Add installed certificate to the service
PSObject certToUpload = vmPowershellCmdlets.RunPSScript(
String.Format("Get-Item cert:\\{0}\\{1}\\{2}", certStoreLocation.ToString(), certStoreName.ToString(), _installedCert.Thumbprint))[0];
vmPowershellCmdlets.AddAzureCertificate(_serviceName, certToUpload);
string newAzureLinuxVMName = Utilities.GetUniqueShortName("PSLinuxVM");
var key = vmPowershellCmdlets.NewAzureSSHKey(NewAzureSshKeyType.PublicKey, _installedCert.Thumbprint, keyPath);
var sshKeysList = new Model.LinuxProvisioningConfigurationSet.SSHPublicKeyList();
sshKeysList.Add(key);
// Add-AzureProvisioningConfig without password and NoSSHEndpoint
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureLinuxVMName, InstanceSize.Small.ToString(), _linuxImageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(username, noSshEndpoint: true, sSHPublicKeyList: sshKeysList);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
// New-AzureVM
vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm });
Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
Collection<InputEndpointContext> endpoints = vmPowershellCmdlets.GetAzureEndPoint(vmPowershellCmdlets.GetAzureVM(newAzureLinuxVMName, _serviceName));
Console.WriteLine("The number of endpoints: {0}", endpoints.Count);
foreach (var ep in endpoints)
{
Utilities.PrintContext(ep);
}
Assert.AreEqual(0, endpoints.Count);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
private PersistentVM CreatIaasVMObject(string vmName, string ipaddress, string subnet)
{
//Create an IaaS VM with a static CA.
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
//Set-AzureSubnet
vm = vmPowershellCmdlets.SetAzureSubnet(vm, new [] { subnet });
//Set-AzureStaticVNetIP
vm = vmPowershellCmdlets.SetAzureStaticVNetIP(ipaddress, vm);
return vm;
}