コード例 #1
0
        public void ValidateAvailableExtesnion(VirtualMachineExtensionImageContext extension)
        {
            Utilities.PrintContext(extension);
            Assert.IsFalse(string.IsNullOrEmpty(extension.ExtensionName));
            Assert.IsFalse(string.IsNullOrEmpty(extension.Publisher));
            Assert.IsFalse(string.IsNullOrEmpty(extension.Version));

            if (!extension.IsJsonExtension)
            {
                switch (extension.ExtensionName)
                {
                case "DiagnosticsAgent":
                {
                    Assert.IsFalse(string.IsNullOrEmpty(extension.PublicConfigurationSchema));
                    break;
                }

                case "VMAccessAgent":
                {
                    Assert.IsFalse(string.IsNullOrEmpty(extension.PublicConfigurationSchema));
                    Assert.IsFalse(string.IsNullOrEmpty(extension.PrivateConfigurationSchema));
                    break;
                }
                }
            }
        }
コード例 #2
0
        public void AzureVMImageSizeTest()
        {
            vhdName = "os2.vhd";
            string newImageName  = Utilities.GetUniqueShortName("vmimage");
            string mediaLocation = string.Format("{0}{1}/{2}", blobUrlRoot, vhdContainerName, vhdName);

            try
            {
                var instanceSizes = vmPowershellCmdlets.GetAzureRoleSize().ToArray();
                int arrayLength   = instanceSizes.Count();

                for (int i = 0; i < arrayLength; i++)
                {
                    Utilities.PrintContext(instanceSizes[i]);
                    // Add-AzureVMImage test for VM size
                    OSImageContext result         = vmPowershellCmdlets.AddAzureVMImage(newImageName, mediaLocation, OS.Windows, null, instanceSizes[i].InstanceSize);
                    OSImageContext resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
                    Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));

                    // Update-AzureVMImage test for VM size
                    result         = vmPowershellCmdlets.UpdateAzureVMImage(newImageName, null, instanceSizes[Math.Max((i + 1) % arrayLength, 1)].InstanceSize);
                    resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
                    Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));

                    vmPowershellCmdlets.RemoveAzureVMImage(newImageName);
                }
            }
            catch (Exception e)
            {
                pass = false;
                Console.WriteLine("Exception occurred: {0}", e.ToString());
                throw;
            }
        }
コード例 #3
0
        private void ValidateVMAccessExtension(string vmName, string serviceName, bool enabled)
        {
            var vmExtension = GetAzureVMAccessExtesnion(vmName, serviceName);

            Utilities.PrintContext(vmExtension);
            if (enabled)
            {
                Console.WriteLine("Verifying the enabled extension");
                Assert.AreEqual("Enable", vmExtension.State, "State is not Enable");
                //Assert.IsFalse(string.IsNullOrEmpty(vmExtension.PublicConfiguration), "PublicConfiguration is empty.");
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(vmExtension.PublicConfiguration);
                XmlDocument inputPublicConfigDoc = new XmlDocument();
                inputPublicConfigDoc.LoadXml(publicConfiguration);
                Assert.AreEqual(inputPublicConfigDoc.GetElementsByTagName("PublicConfig")[0].InnerXml, doc.GetElementsByTagName("PublicConfig")[0].InnerXml);
                Console.WriteLine("Verifed the enabled extension successfully.");
            }
            else
            {
                Console.WriteLine("Verifying the disabled extension");
                Assert.AreEqual("Disable", vmExtension.State, "State is not Disable");
                Console.WriteLine("Verifed the disabled extension successfully.");
            }
            Assert.IsNull(vmExtension.PrivateConfiguration);
        }
コード例 #4
0
        public void NewAzureVMWithLinuxAndCustomData()
        {
            try
            {
                // Add-AzureProvisioningConfig without NoSSHEndpoint or DisableSSH option
                var          azureVMConfigInfo       = new AzureVMConfigInfo(_vmName, InstanceSize.Small.ToString(), _linuxImageName);
                var          azureProvisioningConfig = new AzureProvisioningConfigInfo(username, password, false, false, null, null, false, @".\cloudinittest.sh");
                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(_vmName, _serviceName));

                Console.WriteLine("The number of endpoints: {0}", endpoints.Count);
                foreach (var ep in endpoints)
                {
                    Utilities.PrintContext(ep);
                }
                Assert.AreEqual(1, endpoints.Count);
                pass = true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw;
            }
        }
コード例 #5
0
        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;
            }
        }
コード例 #6
0
        public void VerifyVMImage(string vmImageName, OS ImageFamily, string imageLabel, string osState, HostCaching hostCaching, int LUN, int LogicalDiskSizeInGB, int noOfDataDisks)
        {
            var vmImages = vmPowershellCmdlets.GetAzureVMImageReturningVMImages(vmImageName);

            Assert.IsTrue(vmImages.Count >= 1);
            var vmImageInfo = vmImages[0];

            Utilities.PrintContext(vmImageInfo);
            Utilities.PrintContext(vmImageInfo.OSDiskConfiguration);
            Utilities.PrintContext(vmImageInfo.DataDiskConfigurations[0]);
            //Verify ImageName
            Assert.IsTrue(vmImageName.Equals(vmImageInfo.ImageName));
            Assert.IsTrue(vmImageInfo.Label.Equals(imageLabel));
            //Verify Category
            Assert.IsTrue("User".Equals(vmImageInfo.Category, StringComparison.CurrentCultureIgnoreCase));
            //Verify LogicalDiskSizeInGB, HostCaching
            Assert.AreEqual(hostCaching.ToString(), vmImageInfo.OSDiskConfiguration.HostCaching, "Property HostCaching is not matching.");
            Assert.AreEqual(hostCaching.ToString(), vmImageInfo.DataDiskConfigurations[0].HostCaching, "Data disk HostCaching iproperty is not matching.");
            //Verify LogicalDiskSizeInGB,
            Assert.AreEqual(LogicalDiskSizeInGB, vmImageInfo.DataDiskConfigurations[0].LogicalDiskSizeInGB);
            //Verify OSstate
            Assert.AreEqual(osState, vmImageInfo.OSDiskConfiguration.OSState, "OsState is not matching.");
            //Verify OS
            Assert.AreEqual(ImageFamily.ToString(), vmImageInfo.OSDiskConfiguration.OS, "Os Family is not matching.");
            //Verify  LUN
            Assert.AreEqual(LUN, vmImageInfo.DataDiskConfigurations[0].Lun);
            //Verify the no of the data disks
            Assert.AreEqual(noOfDataDisks, vmImageInfo.DataDiskConfigurations.Count);
        }
コード例 #7
0
        static private void VerifyVmWithStaticCAIsReserved(string vmName, string svcName, string inputDip)
        {
            //Get the DIP of the VM (Get-AzureVM) VirtualNetworkStaticIPContext ipContext
            PersistentVMRoleContext vm = vmPowershellCmdlets.GetAzureVM(vmName, svcName);
            string confirguredVip      = vm.IpAddress;

            if (!string.IsNullOrEmpty(confirguredVip))
            {
                //Verify that the DIP of the VM is matched with an input DIP.
                Console.WriteLine("Verifying that the DIP of the VM {0} is matched with input DIP {1}.", inputDip, confirguredVip);
                Assert.AreEqual(inputDip, confirguredVip, string.Format("Static CA IpAddress {0} is not the same as the Input DIP {1}", confirguredVip, inputDip));
                Console.WriteLine("Verifyied that the DIP of the VM {0} is matched with input DIP {1}.", inputDip, confirguredVip);

                //Verify that the DIP is actually reserved.
                Console.WriteLine("Verifying that the DIP of the VM is actually reserved");
                var ipContext = vmPowershellCmdlets.GetAzureStaticVNetIP(vm.VM);
                Utilities.PrintContext(ipContext);
                Assert.AreEqual(inputDip, ipContext.IPAddress, string.Format("Reserved IPAddress {0}  is not equal to the input DIP {1}", ipContext.IPAddress, inputDip));
                Console.WriteLine("Verifyied that the DIP of the VM is actually reserved");

                //Verify that the IP is not available (Test-AzureStaticVNetIP –VnetName $vnet –IPAddress “10.0.0.5”)
                Console.WriteLine("Verifing that the IP {0} is not available", inputDip);
                VirtualNetworkStaticIPAvailabilityContext availibiltyContext = vmPowershellCmdlets.TestAzureStaticVNetIP(VNetName, inputDip);
                Console.WriteLine("IsAvailable:{0}", availibiltyContext.IsAvailable);
                Console.WriteLine("AvailableAddresses:{0}{1}", Environment.NewLine, availibiltyContext.AvailableAddresses.Aggregate((current, next) => current + Environment.NewLine + next));
                Assert.IsFalse(availibiltyContext.IsAvailable, string.Format("Test-AzureStaticVNetIP should return true as {0} is reserved", inputDip, vm.Name));
                Assert.IsFalse(availibiltyContext.AvailableAddresses.Contains(inputDip), string.Format("{0} is reserved for vm {1} and should not be in available addresses.", inputDip, vmName));
                Console.WriteLine("Verified that the IP {0} is not available", inputDip);
            }
            else
            {
                throw new Exception("Configured IPAddres value is null or empty");
            }
        }
        private void GetAzureServiceDomainJoinExtension()
        {
            var domianContext = vmPowershellCmdlets.GetAzureServiceDomainJoinExtension(_serviceName, DeploymentSlotType.Production);

            Utilities.PrintContext(domianContext);
            Assert.IsFalse(string.IsNullOrEmpty(domianContext.Extension), "Extension is empty or null.");
            Console.WriteLine("Service domain join extension fetched successfully.");
        }
コード例 #9
0
        private VirtualMachineExtensionContext GetAzureVMExtesnion(string vmName, string serviceName)
        {
            Console.WriteLine("Get Azure VM's extension");
            var vmExtension = vmPowershellCmdlets.GetAzureVMExtension(GetAzureVM(vmName, serviceName));

            Utilities.PrintContext(vmExtension);
            Console.WriteLine("Azure VM's extension info retrieved successfully.");
            return(vmExtension);
        }
コード例 #10
0
        private void CheckAvailabilityOfIpAddressAndAssertFalse(string vnetName, string ipaddress)
        {
            var availibiltyContext = vmPowershellCmdlets.TestAzureStaticVNetIP(vnetName, ipaddress);

            Utilities.PrintContext(availibiltyContext);
            Console.WriteLine("AvailableAddresses:{0}{1}", Environment.NewLine,
                              availibiltyContext.AvailableAddresses.Aggregate((current, next) => current + Environment.NewLine + next));
            Assert.IsFalse(availibiltyContext.IsAvailable, "Ipaddress {0} is avialable.", ipaddress);
        }
コード例 #11
0
        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;
            }
        }
コード例 #12
0
 private static void VerifyPublicIP(string publicIpName, PersistentVM vm1)
 {
     Utilities.ExecuteAndLog(() =>
     {
         var publicIpContext = vmPowershellCmdlets.GetAzurePublicIpName(publicIpName, vm1);
         Console.WriteLine("Public IP Context Properties:");
         Utilities.PrintContext(publicIpContext);
         Console.WriteLine("\n Verifing recquired properties");
         Utilities.LogAssert(() => Assert.AreEqual(publicIpName, publicIpContext.Name), "Public IP Name");
     }, "Verify Public ip of the VM");
 }
コード例 #13
0
        private void CheckAvailabilityofIpAddress(string vnetName, string ipaddress)
        {
            Console.WriteLine("Checking if VIP {0} is available and unreserved", ipaddress);
            VirtualNetworkStaticIPAvailabilityContext availibiltyContext = vmPowershellCmdlets.TestAzureStaticVNetIP(vnetName, ipaddress);

            Utilities.PrintContext(availibiltyContext);

            //Assert that it is available.
            Assert.IsTrue(availibiltyContext.IsAvailable, "ipaddress {0} is expected to be available", ipaddress);
            Console.WriteLine("Ip address {0} is available", ipaddress);
        }
コード例 #14
0
        public void VerifyOsImage(string ImageName, OSImageContext imageContext)
        {
            var vmImage = vmPowershellCmdlets.GetAzureVMImage(ImageName);

            Utilities.PrintContext(vmImage[0]);
            Assert.AreEqual(imageContext.ImageName, vmImage[0].ImageName, "ImageName property of the saved os image is not matching.");
            Assert.AreEqual(imageContext.Category, vmImage[0].Category, "Category property of the saved os image is not matching.");
            Assert.AreEqual(imageContext.Location, vmImage[0].Location, "Location property of the saved os image is not matching.");
            Assert.AreEqual(imageContext.Label, vmImage[0].Label, "Label property of the saved os image is not matching.");
            Assert.AreEqual(imageContext.OS, vmImage[0].OS, "OS property of the saved os image is not matching.");
        }
コード例 #15
0
 public void VerifyVM(PersistentVM vm, OS ImageFamily, HostCaching hostCaching, int LogicalDiskSizeInGB, int noOfDataDisks)
 {
     //Verify OS Disk
     Console.WriteLine("VM OS Virtual Hard Disk properties:");
     Utilities.PrintContext(vm.OSVirtualHardDisk);
     Assert.AreEqual(HostCaching.ReadWrite.ToString(), vm.OSVirtualHardDisk.HostCaching, "Os disk Property HostCaching is not matching.");
     Assert.AreEqual(ImageFamily.ToString(), vm.OSVirtualHardDisk.OS, "ImageFamily property is not matching.");
     //Verify Data Disk
     Console.WriteLine("VM Data Hard Disk properties:");
     Utilities.PrintContext(vm.DataVirtualHardDisks[0]);
     Assert.AreEqual(hostCaching.ToString(), vm.DataVirtualHardDisks[0].HostCaching, "Data disk Property HostCaching is not matching.");
     Assert.AreEqual(LogicalDiskSizeInGB, vm.DataVirtualHardDisks[0].LogicalDiskSizeInGB, "Data disk size is not matching.");
     Assert.AreEqual(noOfDataDisks, vm.DataVirtualHardDisks.Count, "Data disks count is not matching.");
 }
コード例 #16
0
        public void UpdateVMWithNewStaticCATest()
        {
            StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
            string vnet1   = VirtualNets[0];
            string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);

            try
            {
                const string ipaddress = "10.0.0.7";
                //Test a static CA
                Console.WriteLine("Checking if ipaddress {0} is available", ipaddress);
                CheckAvailabilityofIpAddress(vnet1, ipaddress);
                Console.WriteLine("ipaddress {0} is available", ipaddress);

                //Create an IaaS VM
                vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName1, serviceName, imageName, new string[1] {
                    StaticCASubnet0
                }, InstanceSize.Small, username, password, VNetName, AffinityGroup);

                //Update the IaaS VM with a static CA
                var    vmRoleContext      = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName);
                string nonStaticIpAddress = vmRoleContext.IpAddress;
                Console.WriteLine("Non static IpAddress of the vm {0} is {1}", vmName1, nonStaticIpAddress);
                var vm = vmPowershellCmdlets.SetAzureStaticVNetIP(ipaddress, vmRoleContext.VM);
                vmPowershellCmdlets.UpdateAzureVM(vmName1, serviceName, vm);

                //Verify that the DIP of the VM is matched with an input.
                VerifyVmWithStaticCAIsReserved(vmName1, serviceName, ipaddress);

                //Verify that the first DIP is released.
                Console.WriteLine("Checking for the availability of non static IpAdress after giving a static CA to the VM");

                Thread.Sleep(TimeSpan.FromMinutes(2));

                var availabilityContext = vmPowershellCmdlets.TestAzureStaticVNetIP(vnet1, nonStaticIpAddress);

                Utilities.RetryActionUntilSuccess(
                    () => Assert.IsTrue(availabilityContext.IsAvailable, "Non static IpAddress {0} is not realesed.", nonStaticIpAddress),
                    "Non static IpAddress", 3, 60);
                //Assert.IsTrue(availabilityContext.IsAvailable, "Non static IpAddress {0} is not realesed.",nonStaticIpAddress);
                Utilities.PrintContext(availabilityContext);
                pass = true;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw;
            }
        }
コード例 #17
0
 /// <summary>
 /// Verifies that the properties of the result of Get-azureInternalLoadBalancer is same as expected.
 /// </summary>
 /// <param name="ilbName"></param>
 private void VerifyInternalLoadBalancer(string verificationMessage, InternalLoadBalancerConfig expectedIlbConfig)
 {
     Utilities.ExecuteAndLog(() =>
     {
         var ilbConfig = vmPowershellCmdlets.GetAzureInternalLoadBalancer(serviceName);
         Console.WriteLine("ILB Context Properties:");
         Utilities.PrintContext(ilbConfig);
         Console.WriteLine("\n Verifing recquired properties");
         Utilities.LogAssert(() => Assert.AreEqual(expectedIlbConfig.InternalLoadBalancerName, ilbConfig.InternalLoadBalancerName), "InternalLoadBalancerName");
         Utilities.LogAssert(() => Assert.AreEqual(serviceName, ilbConfig.ServiceName), "ServiceName");
         Utilities.LogAssert(() => Assert.AreEqual(serviceName, ilbConfig.DeploymentName), "DeploymentName");
         Utilities.LogAssert(() => Assert.AreEqual(expectedIlbConfig.IPAddress, ilbConfig.IPAddress), "IPAddress");
         Utilities.LogAssert(() => Assert.AreEqual(expectedIlbConfig.SubnetName, ilbConfig.SubnetName), "SubnetName");
     }, verificationMessage);
 }
コード例 #18
0
 private VirtualMachineExtensionContext GetAzureVMAccessExtesnion(string vmName, string serviceName)
 {
     Console.WriteLine("Get Azure VM's extension");
     var vmExtensions = vmPowershellCmdlets.GetAzureVMExtension(GetAzureVM(vmName, serviceName), VmAccessAgentExtensionName, publisher);
     var vmExtension = vmExtensions !=null ? vmExtensions[0] : null;
     if (vmExtension != null)
     {
         Utilities.PrintContext(vmExtension);
         Console.WriteLine("Azure VM's extension info retrieved successfully.");
     }
     else
     {
         Console.WriteLine("VM Access extesnion is not applied to the VM");
     }
     return vmExtension;
 }
コード例 #19
0
        public void NewAzureVMWithLocation()
        {
            string _altLocation = GetAlternateLocation(locationName);

            try
            {
                // New-AzureService
                vmPowershellCmdlets.NewAzureService(_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);
                PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);

                // New-AzureVM
                try
                {
                    vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm }, _altLocation);
                    Assert.Fail("Should fail, but succeeded!");
                }
                catch (Exception ex)
                {
                    if (ex is AssertFailedException)
                    {
                        throw;
                    }
                    else
                    {
                        Console.WriteLine("Failure is expected.  Continue the tests...");
                    }
                }

                vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm }, locationName);
                Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
                var vmReturned = vmPowershellCmdlets.GetAzureVM(_vmName, _serviceName);

                Utilities.PrintContext(vmReturned);
                Assert.AreEqual(_serviceName, vmReturned.ServiceName);
                pass = true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw;
            }
        }
コード例 #20
0
        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;
            }
        }
コード例 #21
0
 internal static bool AzureReservedIP(ReservedIPContext rsvIP, string name, string label, string affname,
                                      string ip, string dep, string svcName, string id)
 {
     Utilities.PrintContext(rsvIP);
     Assert.AreEqual(name, rsvIP.ReservedIPName, "Reserved IP names are not equal!");
     Assert.AreEqual(label, rsvIP.Label, "Reserved IP labels are not equal!");
     Assert.AreEqual(affname, rsvIP.AffinityGroup, "Reserved IP affinity groups are not equal!");
     if (!string.IsNullOrEmpty(ip))
     {
         Assert.AreEqual(ip, rsvIP.Address, "Reserved IP addresses are not equal!");
     }
     Assert.AreEqual(dep, rsvIP.DeploymentName, "Reserved IP deployment names are not equal!");
     Assert.AreEqual(svcName, rsvIP.ServiceName, "Reserved IP service names are not equal!");
     if (!string.IsNullOrEmpty(id))
     {
         Assert.AreEqual(id, rsvIP.Id, "Reserved IP IDs are not equal!");
     }
     return(true);
 }
コード例 #22
0
        public void GetAzureServiceAvailableExtensionTest()
        {
            StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);

            try
            {
                Collection <ExtensionImageContext> resultExtensions = vmPowershellCmdlets.GetAzureServiceAvailableExtension();

                foreach (var extension in resultExtensions)
                {
                    Utilities.PrintContext(extension);
                }

                _extensionName     = resultExtensions[0].ExtensionName;
                _providerNamespace = resultExtensions[0].ProviderNameSpace;

                resultExtensions = vmPowershellCmdlets.GetAzureServiceAvailableExtension(
                    extensionName: _extensionName,
                    providerNamespace: _providerNamespace,
                    allVersion: true);

                foreach (var extension in resultExtensions)
                {
                    Utilities.PrintContext(extension);
                }

                string ver = resultExtensions[0].Version;

                resultExtensions = vmPowershellCmdlets.GetAzureServiceAvailableExtension(
                    extensionName: _extensionName,
                    providerNamespace: _providerNamespace,
                    version: ver);

                Utilities.PrintContext(resultExtensions[0]);

                pass = true;
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception occurred: {0}", e);
                throw;
            }
        }
コード例 #23
0
        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);
        }
コード例 #24
0
        /// <summary>
        /// Verify the properties of the reserved ip
        /// </summary>
        /// <param name="input">ReservedIpContext object containing expected values</param>
        private void VerifyReservedIp(ReservedIPContext input)
        {
            var reservedIps = vmPowershellCmdlets.GetAzureReservedIP(input.ReservedIPName);

            if (reservedIps.Count > 0)
            {
                var reservedIpContext = reservedIps[0];
                Utilities.PrintContext(reservedIpContext);
                Utilities.LogAssert(() => Assert.IsFalse(string.IsNullOrEmpty(reservedIpContext.Address)), "Address");
                Utilities.LogAssert(() => Assert.AreEqual(input.Location, reservedIpContext.Location), "Location");
                Utilities.LogAssert(() => Assert.AreEqual(input.ReservedIPName, reservedIpContext.ReservedIPName), "ReservedIPName");
                Utilities.LogAssert(() => Assert.AreEqual(input.State, reservedIpContext.State), "State");
                Utilities.LogAssert(() => Assert.AreEqual(input.DeploymentName, reservedIpContext.DeploymentName), "DeploymentName");
                Utilities.LogAssert(() => Assert.AreEqual(input.InUse, reservedIpContext.InUse), "InUse");
                Utilities.LogAssert(() => Assert.AreEqual(input.ServiceName, reservedIpContext.ServiceName), "ServiceName");
            }
            else
            {
                Assert.Fail("Didnt find reserved ip with name {0}", input.ReservedIPName);
            }
        }
コード例 #25
0
 private void VerifyDeployment(string verificationMessage, string internalLoadBalancerName = null, string vnet = null)
 {
     Utilities.ExecuteAndLog(() =>
     {
         var deploymentContext = vmPowershellCmdlets.GetAzureDeployment(serviceName);
         Console.WriteLine("Deployment Context Properties:");
         Utilities.PrintContext(deploymentContext);
         Console.WriteLine("\n Verifing recquired properties");
         Utilities.LogAssert(() => Assert.AreEqual(internalLoadBalancerName, deploymentContext.InternalLoadBalancerName), "InternalLoadBalancerName");
         Utilities.LogAssert(() =>
         {
             if (internalLoadBalancerName == null)
             {
                 Assert.AreEqual(deploymentContext.LoadBalancers.Count, 0);
             }
             else
             {
                 Assert.AreEqual(internalLoadBalancerName, deploymentContext.LoadBalancers[0].Name);
             }
         }, "LoadBalancers");
         Utilities.LogAssert(() => Assert.AreEqual(vnet, deploymentContext.VNetName), "VNetName");
     }, verificationMessage);
 }
コード例 #26
0
        public void ValidateAvailableExtesnion(VirtualMachineExtensionImageContext extension)
        {
            Utilities.PrintContext(extension);
            Assert.IsFalse(string.IsNullOrEmpty(extension.ExtensionName));
            Assert.IsFalse(string.IsNullOrEmpty(extension.Publisher));
            Assert.IsFalse(string.IsNullOrEmpty(extension.Version));

            // Intentionally commented as the cmdlet prod cmdlet doesnt have these properties and dogfood returns errors
            // now
            //Assert.IsTrue(extension.ReplicationCompleted);
            //Assert.IsTrue(Utilities.validateHttpUri(extension.PrivacyUri.ToString()));
            //Assert.IsTrue(Utilities.validateHttpUri(extension.PrivacyUri.ToString()));
            //Assert.IsTrue(Utilities.validateHttpUri(extension.Eula.ToString()));

            switch (extension.ExtensionName)
            {
            //case "BGInfo":
            //    {
            //        Assert.IsTrue(extension.ReplicationCompleted);
            //        break;
            //    }
            case "DiagnosticsAgent":
            {
                Assert.IsFalse(string.IsNullOrEmpty(extension.PublicConfigurationSchema));
                break;
            }

            case "VMAccessAgent":
            {
                Assert.IsFalse(string.IsNullOrEmpty(extension.PublicConfigurationSchema));
                Assert.IsFalse(string.IsNullOrEmpty(extension.PrivateConfigurationSchema));
                //Assert.IsFalse(string.IsNullOrEmpty(extension.SampleConfig));
                break;
            }
            }
        }
コード例 #27
0
        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
                //
                var          azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), 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,
                    null,
                    null,
                    LoadBalancerDistribution.SourceIP);

                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 without any parameter (List VMs)
                //
                var vmlist = vmPowershellCmdlets.GetAzureVM();
                Console.WriteLine("The number of VMs: {0}", vmlist.Count);
                Assert.AreNotSame(0, vmlist.Count, "No VM exists!!!");
                PersistentVMRoleListContext returnedVMlist =
                    vmlist.First(item => item.ServiceName.Equals(serviceName) && item.Name.Equals(newAzureVMName));
                Assert.IsNotNull(returnedVMlist, "Created VM does not exist!!!");
                Utilities.PrintContext((PersistentVMRoleContext)returnedVMlist);

                //
                // 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 RDP & PowerShell Endpoints
                //
                var endpoints = vmPowershellCmdlets.GetAzureEndPoint(vm);
                Assert.IsTrue(endpoints.Count(e => e.Name == "PowerShell" && e.LocalPort == 5986 && e.Protocol == "tcp") == 1);
                Assert.IsTrue(endpoints.Count(e => e.Name == "RemoteDesktop" && e.LocalPort == 3389 && e.Protocol == "tcp") == 1);

                //
                // 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
                //
                var vmSizeConfig = new SetAzureVMSizeConfig(InstanceSize.Medium.ToString());
                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;
            }
        }
コード例 #28
0
        public void CaptureGeneralizedLinuxVMAndDeploy()
        {
            string serviceName1   = Utilities.GetUniqueShortName(serviceNamePrefix);
            string linuxImageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Linux" }, false);

            try
            {
                //                a.	Deploy a new IaaS VM
                string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
                Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0} completed.---------------------", vmName);
                PersistentVM vm = CreateIaaSVMObjectWithDisk(vmName, InstanceSize.Small, linuxImageName, false, username, password);
                vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
                Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0} completed.---------------------", vmName);
                //b.	Stop the VM
                Console.WriteLine("--------------------------------Stopping vm :{0}--------------------------------", vmName);
                vmPowershellCmdlets.StopAzureVM(vmName, serviceName, force: true);
                Console.WriteLine("--------------------------------Stopped vm :{0}--------------------------------", vmName);
                //c.	Save the VM image
                Console.WriteLine("--------------------------------Save the VM image--------------------------------");
                vmImageName = vmName + "Image";
                vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, vmImageName, CONSTANT_GENERALIZED, vmImageName);
                Console.WriteLine("--------------------------------Saved VM image with name {0}----------------------");
                //d.	Verify the VM image by Get-AzureVMImage
                Console.WriteLine("--------------------------------Verify the VM image--------------------------------");
                VerifyVMImage(vmImageName, OS.Linux, vmImageName, CONSTANT_GENERALIZED, cahcing, lunSlot1, diskSize1, 1);
                Console.WriteLine("--------------------------------Verified that the VM image is saved successfully--------------------------------");
                //e.	Deploy a new IaaS VM with the save VM image
                Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
                string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
                vm = Utilities.CreateIaaSVMObject(vmName1, InstanceSize.Small, vmImageName, false, username, password);
                vmPowershellCmdlets.NewAzureVM(serviceName1, new[] { vm }, locationName);
                Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName1, vmImageName);
                //f.	Verify the VM by Get-AzureVM
                Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName1, vmImageName);
                var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName1);
                Utilities.PrintContext(vmRoleContext);
                Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName1);
                //g.	Add another IaaS VM with the save VM image to the existing service
                string vmName2 = Utilities.GetUniqueShortName(vmNamePrefix);
                Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
                vmPowershellCmdlets.NewAzureQuickVM(OS.Linux, vmName2, serviceName1, vmImageName, username, password);
                Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName2, vmImageName);
                //h.	Verify the VM by Get-AzureVM
                Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName2, vmImageName);
                vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName2, serviceName1);
                Utilities.PrintContext(vmRoleContext);
                Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName2);

                pass = true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
            finally
            {
                CleanupService(serviceName1);
                //Delete the VM image
                Console.WriteLine("------------------------------Delete the VM image---------------------------------");
                vmPowershellCmdlets.RemoveAzureVMImage(vmImageName, true);
                Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
            }
        }
コード例 #29
0
        public void AzureVMImageSizeTest()
        {
            string mediaLocation = UploadVhdFile();
            string newImageName  = Utilities.GetUniqueShortName("vmimage");

            try
            {
                var       instanceSizes        = vmPowershellCmdlets.GetAzureRoleSize().Where(r => r.Cores <= 2 && !r.InstanceSize.StartsWith("Standard_"));
                const int numOfMinimumInstSize = 3;
                Assert.IsTrue(instanceSizes.Count() >= numOfMinimumInstSize);
                var instanceSizesArr = instanceSizes.Take(numOfMinimumInstSize).ToArray();
                int arrayLength      = instanceSizesArr.Count();

                for (int i = 0; i < arrayLength; i++)
                {
                    Utilities.PrintContext(instanceSizesArr[i]);
                    // Add-AzureVMImage test for VM size
                    OSImageContext result         = vmPowershellCmdlets.AddAzureVMImage(newImageName, mediaLocation, OS.Windows, null, instanceSizesArr[i].InstanceSize);
                    OSImageContext resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
                    Assert.IsTrue(!string.IsNullOrEmpty(resultReturned.IOType));
                    Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));

                    // Update-AzureVMImage test for VM size
                    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
                    result         = vmPowershellCmdlets.UpdateAzureVMImage(newImageName, resultReturned.ImageName, instanceSizesArr[Math.Max((i + 1) % arrayLength, 1)].InstanceSize);
                    resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
                    Assert.IsTrue(!string.IsNullOrEmpty(resultReturned.IOType));
                    Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));

                    vmPowershellCmdlets.RemoveAzureVMImage(newImageName);
                    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
                    pass = true;
                }
            }
            catch (Exception e)
            {
                pass = false;
                System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
                vmPowershellCmdlets.RemoveAzureVMImage(newImageName, true);
                Console.WriteLine("Exception occurred: {0}", e.ToString());
                throw;
            }
            finally
            {
                try
                {
                    vmPowershellCmdlets.GetAzureVMImage(newImageName);
                    vmPowershellCmdlets.RemoveAzureVMImage(newImageName);
                }
                catch (Exception e)
                {
                    if (e.ToString().Contains("ResourceNotFound"))
                    {
                        Console.WriteLine("The vm image, {0}, is already deleted.", newImageName);
                    }
                    else
                    {
                        throw;
                    }
                }
            }
        }
コード例 #30
0
        public void CaptureSpecializedVMAndDeploy()
        {
            StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
            string serviceName1 = Utilities.GetUniqueShortName(serviceNamePrefix);

            try
            {
                //      a.	Deploy a new IaaS VM
                string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
                Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0}--------------------------------", vmName);
                var vm = CreateIaaSVMObjectWithDisk(vmName, InstanceSize.Small, imageName, true, username, password);
                vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
                Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0} completed.---------------------", vmName);
                //b.	Stop the VM
                Console.WriteLine("--------------------------------Stopping vm :{0}--------------------------------", vmName);
                vmPowershellCmdlets.StopAzureVM(vmName, serviceName, force: true);
                Console.WriteLine("--------------------------------Stopped vm :{0}--------------------------------", vmName);
                //c.	Save the VM image
                Console.WriteLine("--------------------------------Save the VM image--------------------------------");
                vmImageName = vmName + "Image";
                vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, vmImageName, CONSTANT_SPECIALIZED, vmImageName);
                Console.WriteLine("--------------------------------Saved VM image with name {0}----------------------");
                //d.	Verify the VM image by Get-AzureVMImage
                Console.WriteLine("--------------------------------Verify the VM image--------------------------------");
                VerifyVMImage(vmImageName, OS.Windows, vmImageName, CONSTANT_SPECIALIZED, cahcing, lunSlot1, diskSize1, 1);
                Console.WriteLine("--------------------------------Verified that the VM image is saved successfully--------------------------------");
                //e.	Deploy a new IaaS VM with the save VM image
                Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
                string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
                vm = Utilities.CreateIaaSVMObject(vmName1, InstanceSize.Small, vmImageName);
                vmPowershellCmdlets.NewAzureVM(serviceName1, new[] { vm }, locationName);
                Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName1, vmImageName);
                //f.	Verify the VM by Get-AzureVM
                Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName1, vmImageName);
                var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName1);
                Utilities.PrintContext(vmRoleContext);
                VerifyVM(vmRoleContext.VM, OS.Windows, HostCaching.ReadWrite, diskSize1, 1);
                Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName1);
                //g.	Add another IaaS VM with the save VM image to the existing service
                string vmName2 = Utilities.GetUniqueShortName(vmNamePrefix);
                Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
                vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName2, serviceName1, vmImageName);
                Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName2, vmImageName);
                //h.	Verify the VM by Get-AzureVM
                Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName2, vmImageName);
                vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName2, serviceName1);
                VerifyVM(vmRoleContext.VM, OS.Windows, HostCaching.ReadWrite, diskSize1, 1);
                Utilities.PrintContext(vmRoleContext);
                Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName2);

                pass = true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
            finally
            {
                CleanupService(serviceName1);
                //	Delete the VM image
                Console.WriteLine("------------------------------Delete the VM image---------------------------------");
                DeleteVMImageIfExists(vmImageName);
                Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
            }
        }