public SetAzureEndpointCmdletInfo(AzureEndPointConfigInfo endPointConfig) { this.cmdletName = Utilities.SetAzureEndpointCmdletName; this.cmdletParams.Add(new CmdletParam("Name", endPointConfig.EndpointName)); this.cmdletParams.Add(new CmdletParam("LocalPort", endPointConfig.EndpointLocalPort)); if (endPointConfig.EndpointPublicPort.HasValue) { this.cmdletParams.Add(new CmdletParam("PublicPort", endPointConfig.EndpointPublicPort)); } this.cmdletParams.Add(new CmdletParam("Protocol", endPointConfig.EndpointProtocol.ToString())); this.cmdletParams.Add(new CmdletParam("VM", endPointConfig.Vm)); if (endPointConfig.Acl != null) { this.cmdletParams.Add(new CmdletParam("ACL", endPointConfig.Acl)); } if (endPointConfig.DirectServerReturn) { this.cmdletParams.Add(new CmdletParam("DirectServerReturn", endPointConfig.DirectServerReturn)); } if (!string.IsNullOrEmpty(endPointConfig.LoadBalancerDistribution)) { this.cmdletParams.Add(new CmdletParam("LoadBalancerDistribution", endPointConfig.LoadBalancerDistribution)); } if (!string.IsNullOrEmpty(endPointConfig.VirtualIPName)) { this.cmdletParams.Add(new CmdletParam("VirtualIPName", endPointConfig.VirtualIPName)); } }
public void AddEndPointACLsonExistingDeployment() { StartTest(MethodBase.GetCurrentMethod().Name, testStartTime); string newAzureQuickVMName = Utilities.GetUniqueShortName(vmNamePrefix); const string endpointName = "web"; imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false); vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, newAzureQuickVMName, serviceName, imageName, username, password, locationName); PersistentVMRoleContext vmRoleCtxt = vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName); Assert.AreEqual(newAzureQuickVMName, vmRoleCtxt.Name, true); NetworkAclObject aclObj = vmPowershellCmdlets.NewAzureAclConfig(); vmPowershellCmdlets.SetAzureAclConfig(SetACLConfig.AddRule, aclObj, 100, ACLAction.Deny, "172.0.0.0/8", "notes3"); var epConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 80, 80, endpointName, aclObj); vmPowershellCmdlets.AddEndPoint(newAzureQuickVMName, serviceName, new[] { epConfigInfo }); var returnedVm = vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName); var returnedAclContext = vmPowershellCmdlets.GetAzureAclConfig(returnedVm.VM, endpointName); Assert.IsTrue(Verify.AzureAclConfig(aclObj, returnedAclContext)); pass = true; }
public AddAzureEndpointCmdletInfo(AzureEndPointConfigInfo endPointConfig) { this.cmdletName = Utilities.AddAzureEndpointCmdletName; this.cmdletParams.Add(new CmdletParam("Name", endPointConfig.EndpointName)); this.cmdletParams.Add(new CmdletParam("LocalPort", endPointConfig.EndpointLocalPort)); if (endPointConfig.EndpointPublicPort.HasValue) { this.cmdletParams.Add(new CmdletParam("PublicPort", endPointConfig.EndpointPublicPort)); } if (endPointConfig.Acl != null) { this.cmdletParams.Add(new CmdletParam("ACL", endPointConfig.Acl)); } this.cmdletParams.Add(new CmdletParam("Protocol", endPointConfig.EndpointProtocol.ToString())); this.cmdletParams.Add(new CmdletParam("VM", endPointConfig.Vm)); if (endPointConfig.ParamSet == AzureEndPointConfigInfo.ParameterSet.DefaultProbe) { this.cmdletParams.Add(new CmdletParam("LBSetName", endPointConfig.LBSetName)); this.cmdletParams.Add(new CmdletParam("DefaultProbe")); } if (endPointConfig.ParamSet == AzureEndPointConfigInfo.ParameterSet.LoadBalancedNoProbe) { this.cmdletParams.Add(new CmdletParam("LBSetName", endPointConfig.LBSetName)); this.cmdletParams.Add(new CmdletParam("NoProbe")); } else if (endPointConfig.ParamSet == AzureEndPointConfigInfo.ParameterSet.CustomProbe) { this.cmdletParams.Add(new CmdletParam("LBSetName", endPointConfig.LBSetName)); this.cmdletParams.Add(new CmdletParam("ProbePort", endPointConfig.ProbePort)); this.cmdletParams.Add(new CmdletParam("ProbeProtocol", endPointConfig.ProbeProtocol.ToString())); if ("http" == endPointConfig.ProbeProtocol.ToString()) { this.cmdletParams.Add(new CmdletParam("ProbePath", endPointConfig.ProbePath)); } if (endPointConfig.ProbeInterval.HasValue) { this.cmdletParams.Add(new CmdletParam("ProbeIntervalInSeconds", endPointConfig.ProbeInterval)); } if (endPointConfig.ProbeTimeout.HasValue) { this.cmdletParams.Add(new CmdletParam("ProbeTimeoutInSeconds", endPointConfig.ProbeTimeout)); } } if (endPointConfig.DirectServerReturn) { this.cmdletParams.Add(new CmdletParam("DirectServerReturn", endPointConfig.DirectServerReturn)); } if (!string.IsNullOrEmpty(endPointConfig.InternalLoadBalancerName)) { this.cmdletParams.Add(new CmdletParam("InternalLoadBalancerName", endPointConfig.InternalLoadBalancerName)); } }
public AzureEndPointConfigInfo(AzureEndPointConfigInfo other) { this.Initialize( other.EndpointProtocol, other.EndpointLocalPort, other.EndpointPublicPort, other.EndpointName, other.LBSetName, other.ProbePort, other.ProbeProtocol, other.ProbePath, other.ProbeInterval, other.ProbeTimeout, other.ParamSet, other.Acl, other.DirectServerReturn); }
public SetAzureLoadBalancedEndpointCmdletInfo(AzureEndPointConfigInfo endPointConfig, AzureEndPointConfigInfo.ParameterSet paramset) { this.cmdletName = Utilities.SetAzureLoadBalancedEndpointCmdletName; this.cmdletParams.Add(new CmdletParam("ServiceName", endPointConfig.ServiceName)); this.cmdletParams.Add(new CmdletParam("LocalPort", endPointConfig.EndpointLocalPort)); if (endPointConfig.EndpointPublicPort.HasValue) { this.cmdletParams.Add(new CmdletParam("PublicPort", endPointConfig.EndpointPublicPort)); } this.cmdletParams.Add(new CmdletParam("Protocol", endPointConfig.EndpointProtocol.ToString())); this.cmdletParams.Add(new CmdletParam("LBSetName", endPointConfig.LBSetName)); switch (paramset) { case AzureEndPointConfigInfo.ParameterSet.CustomProbe : switch (endPointConfig.ProbeProtocol.ToString()) { case "tcp": this.cmdletParams.Add(new CmdletParam("ProbeProtocolTCP")); break; case "http": this.cmdletParams.Add(new CmdletParam("ProbeProtocolHTTP")); this.cmdletParams.Add(new CmdletParam("ProbePath", endPointConfig.ProbePath)); break; default: break; } break; case AzureEndPointConfigInfo.ParameterSet.DefaultProbe : case AzureEndPointConfigInfo.ParameterSet.LoadBalancedNoProbe : default : break; } if (endPointConfig.Acl != null) { this.cmdletParams.Add(new CmdletParam("ACL", endPointConfig.Acl)); } if (endPointConfig.DirectServerReturn) { this.cmdletParams.Add(new CmdletParam("DirectServerReturn", endPointConfig.DirectServerReturn)); } }
public AzureEndPointConfigInfo(AzureEndPointConfigInfo other) { this.Initialize( other.EndpointProtocol, other.EndpointLocalPort, other.EndpointPublicPort, other.EndpointName, other.LBSetName, other.ProbePort, other.ProbeProtocol, other.ProbePath, other.ProbeInterval, other.ProbeTimeout, other.ParamSet, other.Acl, other.DirectServerReturn, other.InternalLoadBalancerName, other.ServiceName, other.LoadBalancerDistribution); }
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; }
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; } }
private bool CheckEndpointRemoved(string vmName, string serviceName, AzureEndPointConfigInfo[] epInfos) { var serverEndpoints = vmPowershellCmdlets.GetAzureEndPoint(vmPowershellCmdlets.GetAzureVM(vmName, serviceName)); // List the endpoints found for debugging. Console.WriteLine("***** Checking for Removed Endpoints ******************************************"); Console.WriteLine("***** Listing Returned Endpoints"); foreach (InputEndpointContext ep in serverEndpoints) { Console.WriteLine("Endpoint - Name:{0} Protocol:{1} Port:{2} LocalPort:{3} Vip:{4}", ep.Name, ep.Protocol, ep.Port, ep.LocalPort, ep.Vip); if (!string.IsNullOrEmpty(ep.LBSetName)) { Console.WriteLine("\t- LBSetName:{0}", ep.LBSetName); Console.WriteLine("\t- Probe - Port:{0} Protocol:{1} Interval:{2} Timeout:{3}", ep.ProbePort, ep.ProbeProtocol, ep.ProbeIntervalInSeconds, ep.ProbeTimeoutInSeconds); } } Console.WriteLine("*******************************************************************************"); // Check if the specified endpoints were found. foreach (AzureEndPointConfigInfo epInfo in epInfos) { bool found = false; foreach (InputEndpointContext ep in serverEndpoints) { if (epInfo.CheckInputEndpointContext(ep)) { found = true; Console.WriteLine("Endpoint found: {0}", epInfo.EndpointName); break; } } Assert.IsFalse(found, string.Format("Error: Endpoint '{0}' was found!", epInfo.EndpointName)); } return true; }
public void AzureEndpointTest() { StartTest(MethodBase.GetCurrentMethod().Name, testStartTime); 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 = null; 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 = null; bool ep2DirectServerReturn = false; AzureEndPointConfigInfo ep1Info = new AzureEndPointConfigInfo( AzureEndPointConfigInfo.ParameterSet.CustomProbe, ProtocolInfo.tcp, ep1LocalPort, ep1PublicPort, ep1Name, ep1LBSetName, ep1ProbePort, ProtocolInfo.tcp, ep1ProbePath, ep1ProbeInterval, ep1ProbeTimeout, ep1AclObj, ep1DirectServerReturn); AzureEndPointConfigInfo ep2Info = new AzureEndPointConfigInfo( AzureEndPointConfigInfo.ParameterSet.CustomProbe, ProtocolInfo.tcp, ep2LocalPort, ep2PublicPort, ep2Name, ep2LBSetName, ep2ProbePort, ProtocolInfo.http, ep2ProbePath, ep2ProbeInterval, ep2ProbeTimeout, ep2AclObj, ep2DirectServerReturn); string defaultVm = Utilities.GetUniqueShortName(vmNamePrefix); Assert.IsNull(vmPowershellCmdlets.GetAzureVM(defaultVm, serviceName)); vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, defaultVm, serviceName, imageName, username, password, locationName); Console.WriteLine("Service Name: {0} is created.", serviceName); try { foreach (AzureEndPointConfigInfo.ParameterSet p in Enum.GetValues(typeof(AzureEndPointConfigInfo.ParameterSet))) { string pSetName = Enum.GetName(typeof(AzureEndPointConfigInfo.ParameterSet), p); Console.WriteLine("--Begin Endpoint Test with '{0}' parameter set.", pSetName); ep1Info.ParamSet = p; ep2Info.ParamSet = p; ep1Info.Acl = vmPowershellCmdlets.NewAzureAclConfig(); ep2Info.Acl = vmPowershellCmdlets.NewAzureAclConfig(); ep2Info.EndpointLocalPort = ep2LocalPort; ep2Info.EndpointPublicPort = ep2PublicPort; // Add two new endpoints Console.WriteLine("-----Add 2 new endpoints."); vmPowershellCmdlets.AddEndPoint(defaultVm, serviceName, new[] { ep1Info, ep2Info }); // Add-AzureEndpoint with Get-AzureVM and Update-AzureVm CheckEndpoint(defaultVm, serviceName, new[] { ep1Info, ep2Info }); // Change the endpoint if (p == AzureEndPointConfigInfo.ParameterSet.NoLB) { Console.WriteLine("-----Change the second endpoint."); ep2Info.EndpointLocalPort = ep2LocalPortChanged; ep2Info.EndpointPublicPort = ep2PublicPortChanged; vmPowershellCmdlets.SetEndPoint(defaultVm, serviceName, ep2Info); // Set-AzureEndpoint with Get-AzureVM and Update-AzureVm CheckEndpoint(defaultVm, serviceName, new[] { ep2Info }); } else { Console.WriteLine("-----Change the second endpoint."); ep2Info.ServiceName = serviceName; ep2Info.EndpointLocalPort = ep2LocalPortChanged; ep2Info.EndpointPublicPort = ep2PublicPortChanged; vmPowershellCmdlets.SetLBEndPoint(defaultVm, serviceName, ep2Info, p); CheckEndpoint(defaultVm, serviceName, new[] { ep2Info }); } // Remove Endpoint Console.WriteLine("-----Remove endpoints."); vmPowershellCmdlets.RemoveEndPoint(defaultVm, serviceName, new[] { ep1Name, ep2Name }); // Remove-AzureEndpoint CheckEndpointRemoved(defaultVm, serviceName, new[] { ep1Info, ep2Info }); Console.WriteLine("Endpoint Test passed with '{0}' parameter set.", pSetName); } pass = true; } catch (Exception e) { pass = false; Assert.Fail("Exception occurred: {0}", e.ToString()); } }
/// <summary> /// /// </summary> /// <param name="vm"></param> /// <param name="epInfos"></param> /// <returns></returns> internal static bool AzureEndpoint(PersistentVM vm, AzureEndPointConfigInfo[] epInfos) { try { var serverEndpoints = vmPowershellCmdlets.GetAzureEndPoint(vm); // List the endpoints found for debugging. Console.WriteLine("***** Checking for Endpoints **************************************************"); Console.WriteLine("***** Listing Returned Endpoints"); foreach (InputEndpointContext ep in serverEndpoints) { Console.WriteLine("Endpoint - Name:{0} Protocol:{1} Port:{2} LocalPort:{3} Vip:{4}", ep.Name, ep.Protocol, ep.Port, ep.LocalPort, ep.Vip); if (!string.IsNullOrEmpty(ep.LBSetName)) { Console.WriteLine("\t- LBSetName:{0}", ep.LBSetName); Console.WriteLine("\t- Probe - Port:{0} Protocol:{1} Interval:{2} Timeout:{3}", ep.ProbePort, ep.ProbeProtocol, ep.ProbeIntervalInSeconds, ep.ProbeTimeoutInSeconds); } } Console.WriteLine("*******************************************************************************"); // Check if the specified endpoints were found. foreach (AzureEndPointConfigInfo epInfo in epInfos) { bool found = false; foreach (InputEndpointContext ep in serverEndpoints) { if (epInfo.CheckInputEndpointContext(ep)) { found = true; Console.WriteLine("Endpoint found: {0}", epInfo.EndpointName); break; } } Assert.IsTrue(found, string.Format("Error: Endpoint '{0}' was not found!", epInfo.EndpointName)); } return true; } catch (Exception e) { Console.WriteLine(e.ToString()); return false; } }
public void ModifyingVM() { StartTest(MethodBase.GetCurrentMethod().Name, testStartTime); string newAzureQuickVMName = Utilities.GetUniqueShortName(vmNamePrefix); if (string.IsNullOrEmpty(imageName)) imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false); vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, newAzureQuickVMName, serviceName, imageName, username, password, locationName); AddAzureDataDiskConfig azureDataDiskConfigInfo1 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0); AddAzureDataDiskConfig azureDataDiskConfigInfo2 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk2", 1); AzureEndPointConfigInfo azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 1433, 2000, "sql"); AddAzureDataDiskConfig[] dataDiskConfig = { azureDataDiskConfigInfo1, azureDataDiskConfigInfo2 }; vmPowershellCmdlets.AddVMDataDisksAndEndPoint(newAzureQuickVMName, serviceName, dataDiskConfig, azureEndPointConfigInfo); SetAzureDataDiskConfig setAzureDataDiskConfig1 = new SetAzureDataDiskConfig(HostCaching.ReadWrite, 0); SetAzureDataDiskConfig setAzureDataDiskConfig2 = new SetAzureDataDiskConfig(HostCaching.ReadWrite, 0); SetAzureDataDiskConfig[] diskConfig = { setAzureDataDiskConfig1, setAzureDataDiskConfig2 }; vmPowershellCmdlets.SetVMDataDisks(newAzureQuickVMName, serviceName, diskConfig); vmPowershellCmdlets.GetAzureDataDisk(newAzureQuickVMName, serviceName); // Cleanup vmPowershellCmdlets.RemoveAzureVM(newAzureQuickVMName, serviceName); Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName)); pass = true; }
public void StopDeallocationReservedIPTest() { try { string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix); string newAzureVM2Name = Utilities.GetUniqueShortName(vmNamePrefix); if (string.IsNullOrEmpty(imageName)) { imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false); } var azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName); var azureVMConfigInfo2 = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.Small.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, null); PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1); PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2); PersistentVM[] VMs = { persistentVM1, persistentVM2 }; // Create a new deployment vmPowershellCmdlets.NewAzureVM(svcNameLoc, VMs, locationName); // Reserve the ip of the deployment vmPowershellCmdlets.NewAzureAffinityGroup(affName1, locationName, null, null); vmPowershellCmdlets.NewAzureReservedIP(rsvIpName1, affName1, svcNameLoc, svcNameLoc, rsvIPLabel); // Get the deployment and verify var deploymentReturned = vmPowershellCmdlets.GetAzureDeployment(svcNameLoc); Utilities.PrintContext(deploymentReturned); // Verify the reserved ip var reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0]; Verify.AzureReservedIPInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1, deploymentReturned.VirtualIPs[0].Address, deploymentReturned.DeploymentName, deploymentReturned.ServiceName); // Stop the first VM and verify the reserved ip Console.WriteLine("Stopping the first VM..."); vmPowershellCmdlets.StopAzureVM(newAzureVM1Name, svcNameLoc); // Verify the reserved ip reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0]; Verify.AzureReservedIPInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1, deploymentReturned.VirtualIPs[0].Address, deploymentReturned.DeploymentName, deploymentReturned.ServiceName); // Stop the second VM and verify the reserved ip Console.WriteLine("Stopping the second VM..."); vmPowershellCmdlets.StopAzureVM(newAzureVM2Name, svcNameLoc, false, true); // Verify the reserved ip reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0]; Verify.AzureReservedIPInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1, deploymentReturned.VirtualIPs[0].Address, deploymentReturned.DeploymentName, deploymentReturned.ServiceName); deploymentReturned = vmPowershellCmdlets.GetAzureDeployment(svcNameLoc); Utilities.PrintContext(deploymentReturned); Assert.AreEqual(0, deploymentReturned.VirtualIPs.Count, "The deployment still holds a VIP!"); // Restart the VM and verify vmPowershellCmdlets.StartAzureVM(newAzureVM1Name, svcNameLoc); deploymentReturned = vmPowershellCmdlets.GetAzureDeployment(svcNameLoc); Utilities.PrintContext(deploymentReturned); // Verify the reserved ip reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0]; Verify.AzureReservedIPInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1, deploymentReturned.VirtualIPs[0].Address, deploymentReturned.DeploymentName, deploymentReturned.ServiceName); deploymentReturned = vmPowershellCmdlets.GetAzureDeployment(svcNameLoc); Utilities.PrintContext(deploymentReturned); // Remove all VMs and service vmPowershellCmdlets.RemoveAzureService(svcNameLoc); reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0]; Verify.AzureReservedIPNotInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1); // Remove the reserved IP and verify vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1); Utilities.VerifyFailure( () => vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1), ResourceNotFoundException); pass = true; } catch (Exception e) { Console.WriteLine(e); throw; } }
private static PersistentVM CreateVMWithEndpointDataDiskAndPublicIP(string vmName, string endpointName, string disklabel1, string publicIpName, string serviceName, int localPort, int publicport, string publicIpDomainNameLabel = null) { var vm1 = Utilities.CreateIaaSVMObject(vmName, InstanceSize.Small, imageName, true, username, password); var endpointConfiginput = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, TCP_PROTOCAL, localPort, publicport, endpointName, serviceName: serviceName); endpointConfiginput.Vm = vm1; vm1 = vmPowershellCmdlets.AddAzureEndPoint(endpointConfiginput); var dataDiskConfig1 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 128, disklabel1, 0); dataDiskConfig1.Vm = vm1; vm1 = vmPowershellCmdlets.AddAzureDataDisk(dataDiskConfig1); vm1 = (PersistentVM)vmPowershellCmdlets.SetAzurePublicIp(publicIpName, vm1, publicIpDomainNameLabel); return vm1; }
public void CreateDeploymentWithILBIPaddressAndSetILBEndpoint() { try { string ilbName = Utilities.GetUniqueShortName("ILB"); string vmName = Utilities.GetUniqueShortName(vmNamePrefix); string endpointName = Utilities.GetUniqueShortName("endpoint"); IPAddress ipAddress = IPAddress.Parse(GetAvailableIpAddressinVnet()); string lbsetName = Utilities.GetUniqueShortName("LbSet"); var ilbConfig = vmPowershellCmdlets.NewAzureInternalLoadBalancerConfig(ilbName, subNet, ipAddress); Utilities.ExecuteAndLog(() => { var vm = Utilities.CreateIaaSVMObject(vmName, InstanceSize.Small, imageName, true, username, password, false); var endpointConfiginput = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.LoadBalancedNoProbe, TCP_PROTOCAL, LOCAL_PORT_NUMBER1, PUBLIC_PORT_NUMBER1, endpointName, lbsetName, null, false, ilbName); endpointConfiginput.Vm = vm; vm = vmPowershellCmdlets.AddAzureEndPoint(endpointConfiginput); vmPowershellCmdlets.NewAzureVMWithInternalLoadBalancer(serviceName, new[] { vm }, ilbConfig, vnetName, locationName); }, string.Format("Create a Vm with Internal load balancer {0}", ilbName)); ilbConfig.SubnetName = subNet; ilbConfig.IPAddress = ipAddress.ToString(); VerifyInternalLoadBalancer("Verify Internal Load Balancer", ilbConfig); var loadBalancerEndpointConfig = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.LoadBalancedNoProbe, UDP_PROTOCAL, LOCAL_PORT_NUMBER2, PUBLIC_PORT_NUMBER2, endpointName, lbsetName, internalLoadBalancer: ilbName, serviceName: serviceName); vmPowershellCmdlets.SetAzureLoadBalancedEndPoint(loadBalancerEndpointConfig, AzureEndPointConfigInfo.ParameterSet.LoadBalancedNoProbe); VerifyInternalLoadBalancer("Verify Internal Load Balancer", ilbConfig); VerifyEndpoint("Verify Azure endpoint", vmName, loadBalancerEndpointConfig); VerifyDeployment("Verify internal load balancer name and vnet name of the deployment", ilbName, vnetName); ilbConfig.IPAddress = ipAddress.ToString(); VerifyInternalLoadBalancer("Verify ILB name, subnet, ip address of the ILB", ilbConfig); pass = true; } catch (Exception ex) { pass = false; Console.WriteLine(ex.InnerException.ToString()); throw ex; } }
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; }
public void TestVirtualIPLifecycle() { try { string dnsName = Utilities.GetUniqueShortName("Dns"); string vmName = Utilities.GetUniqueShortName(vmNamePrefix); string vipName = Utilities.GetUniqueShortName("Vip"); string endpointName = Utilities.GetUniqueShortName("Endpoint"); // Create a new VM with the reserved ip. DnsServer dns = null; Utilities.ExecuteAndLog(() => { dns = vmPowershellCmdlets.NewAzureDns(dnsName, DNS_IP); }, "Create a new Azure DNS"); PersistentVM vm = null; Utilities.ExecuteAndLog(() => { vm = Utilities.CreateVMObjectWithDataDiskSubnetAndAvailibilitySet(vmName, OS.Windows, username, password, subnet); vmPowershellCmdlets.NewAzureVM(serviceName, new[] {vm}, vnet, new[] {dns}, location: locationName); }, "Create a new windows azure vm without reserved ip."); Utilities.ExecuteAndLog(() => vmPowershellCmdlets.AddAzureVirtualIP(vipName, serviceName), "Adding Azure VirtualIP"); var deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production); var retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName)); Assert.IsNotNull(retrievedVip); Assert.IsTrue(string.IsNullOrEmpty(retrievedVip.Address)); AzureEndPointConfigInfo endpointInfo = new AzureEndPointConfigInfo { EndpointName = endpointName, EndpointProtocol = ProtocolInfo.tcp, EndpointLocalPort = 1000, EndpointPublicPort = 444, VirtualIPName = vipName, Vm = vm }; var updatedVM = vmPowershellCmdlets.AddAzureEndPoint(endpointInfo); vmPowershellCmdlets.UpdateAzureVM(vmName, serviceName, updatedVM); deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production); retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName)); Assert.IsNotNull(retrievedVip); Assert.IsTrue(!string.IsNullOrEmpty(retrievedVip.Address)); AzureEndPointConfigInfo removeEndpointInfo = new AzureEndPointConfigInfo { EndpointName = endpointName, EndpointProtocol = ProtocolInfo.tcp, EndpointLocalPort = 1000, EndpointPublicPort = 444, VirtualIPName = vipName, Vm = updatedVM }; updatedVM = vmPowershellCmdlets.RemoveAzureEndPoint(endpointName, updatedVM); vmPowershellCmdlets.UpdateAzureVM(vmName, serviceName, updatedVM); deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production); retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName)); Assert.IsNotNull(retrievedVip); Assert.IsTrue(string.IsNullOrEmpty(retrievedVip.Address)); Utilities.ExecuteAndLog(() => vmPowershellCmdlets.RemoveAzureVirtualIP(vipName, serviceName), "Adding Azure VirtualIP"); deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production); retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName)); Assert.IsNull(retrievedVip); cleanupIfPassed = false; vmPowershellCmdlets.RemoveAzureDeployment(serviceName, "Production", true); pass = true; } catch (Exception ex) { pass = false; Console.WriteLine(ex.ToString()); throw; } }
public void CreateDeploymentWithILBSubnetAndAddILBEndpoint() { try { string ilbName = Utilities.GetUniqueShortName("ILB"); string vmName = Utilities.GetUniqueShortName(vmNamePrefix); string endpointName = Utilities.GetUniqueShortName("endpoint"); var ilbConfig = vmPowershellCmdlets.NewAzureInternalLoadBalancerConfig(ilbName, subNet); Utilities.ExecuteAndLog(() => { var vm = Utilities.CreateIaaSVMObject(vmName, InstanceSize.Small, imageName, true, username, password, false); vm = vmPowershellCmdlets.SetAzureSubnet(vm, new string[] { subNet }); vmPowershellCmdlets.NewAzureVMWithInternalLoadBalancer(serviceName, new[] { vm }, ilbConfig, vnetName, locationName); }, string.Format("Create a Vm with Internal load balancer {0}", ilbName)); ilbConfig.SubnetName = subNet; VerifyInternalLoadBalancer("Verify Internal Load Balancer", ilbConfig); var endpointConfig = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, TCP_PROTOCAL, LOCAL_PORT_NUMBER1, PUBLIC_PORT_NUMBER1, endpointName, internalLoadBalancer: ilbName); Utilities.ExecuteAndLog(() => { var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName, serviceName); endpointConfig.Vm = vmRoleContext.VM; var vm = vmPowershellCmdlets.AddAzureEndPoint(endpointConfig); vmPowershellCmdlets.UpdateAzureVM(vmName, serviceName, vm); }, "Add Azure endpoint to the vm"); VerifyEndpoint("Verify Azure endpoint", vmName, endpointConfig); VerifyDeployment("Verify internal load balancer name and vnet name of the deployment", ilbName, vnetName); ilbConfig.IPAddress = ipAddress; VerifyInternalLoadBalancer("Verify ILB name, subnet, ip address of the ILB", ilbConfig); pass = true; } catch (Exception ex) { pass = false; Console.WriteLine(ex.InnerException.ToString()); throw ex; } }
public AzureEndPointConfigInfo(AzureEndPointConfigInfo other) { this.Initialize( other.EndpointProtocol, other.EndpointLocalPort, other.EndpointPublicPort, other.EndpointName, other.LBSetName, other.ProbePort, other.ProbeProtocol, other.ProbePath, other.ProbeInterval, other.ProbeTimeout, other.ParamSet, other.Acl, other.DirectServerReturn, other.InternalLoadBalancerName, other.ServiceName); }
public void ILBonExistingDeploymentWithVnet() { try { string ilbName = Utilities.GetUniqueShortName("ILB"); string vmName = Utilities.GetUniqueShortName(vmNamePrefix); string endpointName = Utilities.GetUniqueShortName("endpoint"); IPAddress ipAddress = IPAddress.Parse(GetAvailableIpAddressinVnet()); string lbsetName = Utilities.GetUniqueShortName("LbSet"); var ilbConfig = vmPowershellCmdlets.NewAzureInternalLoadBalancerConfig(ilbName, subNet, ipAddress); Utilities.ExecuteAndLog(() => { vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName, serviceName, imageName, username, password, locationName, InstanceSize.Small.ToString(), null, null, vnetName); }, "Create a Vm using New-AzureQuickVM"); vmPowershellCmdlets.AddAzureInternalLoadBalancer(ilbName, serviceName, subNet, ipAddress); ilbConfig.SubnetName = subNet; ilbConfig.IPAddress = ipAddress.ToString(); VerifyInternalLoadBalancer("Verify Internal Load Balancer", ilbConfig); var endpointConfig = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, TCP_PROTOCAL, LOCAL_PORT_NUMBER1, PUBLIC_PORT_NUMBER1, endpointName, internalLoadBalancer: ilbName); Utilities.ExecuteAndLog(() => { var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName, serviceName); endpointConfig.Vm = vmRoleContext.VM; var vm = vmPowershellCmdlets.AddAzureEndPoint(endpointConfig); vmPowershellCmdlets.UpdateAzureVM(vmName, serviceName, vm); }, "Add Azure endpoint to the vm"); VerifyEndpoint("Verify Azure endpoint", vmName, endpointConfig); pass = true; } catch (Exception ex) { pass = false; Console.WriteLine(ex.InnerException.ToString()); throw ex; } }
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; }
private void VerifyEndpoint(string verificationMessage, string vmName, AzureEndPointConfigInfo endpointConfig) { Utilities.ExecuteAndLog(() => { var vmRole = vmPowershellCmdlets.GetAzureVM(vmName, serviceName); var endpointCollection = vmPowershellCmdlets.GetAzureEndPoint(vmRole.VM); var inputEndpointCollection = from c in endpointCollection where c.Name.Equals(endpointConfig.EndpointName) select c; var endpointConfigInfo = inputEndpointCollection.First(); Console.WriteLine("Endpoint Configuraion Properties:"); Utilities.PrintContext(endpointConfigInfo); ipAddress = endpointConfigInfo.Vip; Console.WriteLine("\n Verifing recquired properties"); Utilities.LogAssert(() => Assert.AreEqual(string.IsNullOrEmpty(endpointConfig.LBSetName) ? null : endpointConfig.LBSetName, endpointConfigInfo.LBSetName), "LBSetName"); Utilities.LogAssert(() => Assert.AreEqual(endpointConfig.EndpointLocalPort, endpointConfig.EndpointLocalPort), "EndpointLocalPort"); Utilities.LogAssert(() => Assert.AreEqual(endpointConfig.EndpointName, endpointConfig.EndpointName), "EndpointName"); Utilities.LogAssert(() => Assert.AreEqual(endpointConfig.EndpointProtocol, endpointConfig.EndpointProtocol), "EndpointProtocol"); Utilities.LogAssert(() => Assert.AreEqual(endpointConfig.InternalLoadBalancerName, endpointConfig.InternalLoadBalancerName), "InternalLoadBalancerName"); }, verificationMessage); }
public void CreateDeploymentWithReservedIPNegativeTest() { try { string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix); string newAzureVM2Name = Utilities.GetUniqueShortName(vmNamePrefix); if (string.IsNullOrEmpty(imageName)) { imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false); } var azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName); var azureVMConfigInfo2 = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.Small.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, null); PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1); PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2); PersistentVM[] VMs = { persistentVM1, persistentVM2 }; // AG1 on location 1 vmPowershellCmdlets.NewAzureAffinityGroup(affName1, locationName, null, null); // AG2 on location 2 var anotherLocation = GetLocation("PersistentVMRole", locationName); vmPowershellCmdlets.NewAzureAffinityGroup(affName2, anotherLocation.Name, null, null); // Reserve an ip on AG1 vmPowershellCmdlets.NewAzureReservedIP(rsvIpName1, affName2); var rsvIPreturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0]; Verify.AzureReservedIPNotInUse(rsvIPreturned, rsvIpName1, null, affName2); // Try to create a new deployment with AG2 and the reserved IP Utilities.VerifyFailure( () => vmPowershellCmdlets.NewAzureVMWithReservedIP(svcNameAG, VMs, rsvIpName1, affName1), BadRequestException); // Create a new deployment with location 2, and then reserved the IP of it vmPowershellCmdlets.NewAzureVM(svcNameLoc, VMs, locationName); Utilities.VerifyFailure( () => vmPowershellCmdlets.NewAzureReservedIP(rsvIpName2, affName2, svcNameLoc, svcNameLoc), BadRequestException); // Remove the reserved IP and verify vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1); Utilities.VerifyFailure( () => vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1), ResourceNotFoundException); pass = true; } catch (Exception e) { Console.WriteLine(e); throw; } }