Пример #1
0
 // NoLB parameter set
 public AzureEndPointConfigInfo(ParameterSet paramset,
                                ProtocolInfo endpointProtocol,
                                int endpointLocalPort,
                                int endpointPublicPort,
                                string endpointName,
                                NetworkAclObject aclObj         = null,
                                bool directServerReturn         = false,
                                string internalLoadBalancer     = null,
                                string serviceName              = null,
                                string loadBalancerDistribution = null,
                                string VirtualIPName            = null)
 {
     this.Initialize(
         endpointProtocol,
         endpointLocalPort,
         endpointPublicPort,
         endpointName,
         string.Empty,
         0,
         ProtocolInfo.tcp,
         string.Empty,
         null,
         null,
         paramset,
         aclObj,
         directServerReturn,
         internalLoadBalancer,
         serviceName,
         loadBalancerDistribution,
         VirtualIPName);
 }
 // NoLB parameter set
 public AzureEndPointConfigInfo(ParameterSet paramset,
     ProtocolInfo endpointProtocol,
     int endpointLocalPort,
     int endpointPublicPort,
     string endpointName,
     NetworkAclObject aclObj = null,
     bool directServerReturn = false,
     string internalLoadBalancer = null,
     string serviceName = null,
     string loadBalancerDistribution = null,
     string VirtualIPName = null)
 {
     this.Initialize(
         endpointProtocol,
         endpointLocalPort,
         endpointPublicPort,
         endpointName, 
         string.Empty, 
         0, 
         ProtocolInfo.tcp, 
         string.Empty, 
         null, 
         null,
         paramset,
         aclObj,
         directServerReturn,
         internalLoadBalancer,
         serviceName,
         loadBalancerDistribution,
         VirtualIPName);
 }
        public void AddEndPointACLsonExistingDeployment()
        {
            StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
            string newAzureQuickVMName = Utilities.GetUniqueShortName(vmNamePrefix);

            imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows", "testvmimage" }, 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");

            AzureEndPointConfigInfo epConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 80, 80, "web", aclObj);

            vmPowershellCmdlets.AddEndPoint(newAzureQuickVMName, serviceName, new[] { epConfigInfo });

            // Cleanup
            vmPowershellCmdlets.RemoveAzureVM(newAzureQuickVMName, serviceName);
            Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName));

            pass = true;
        }
Пример #4
0
 internal static bool AzureAclConfig(NetworkAclObject expectedAcl, NetworkAclObject actualAcl)
 {
     for (int i = 0; i < expectedAcl.Rules.Count; i++)
     {
         Assert.IsTrue(CompareContext(expectedAcl.Rules[i], actualAcl.Rules[i]));
     }
     return(true);
 }
        public SetAzureAclConfigCmdletInfo(string aclConfig, NetworkAclObject aclObj, int?order, string aclAction, string remoteSubnet, string desc, int?ruleId)
        {
            this.cmdletName = Utilities.SetAzureAclConfigCmdletName;

            switch (aclConfig)
            {
            case "AddRule":
                this.cmdletParams.Add(new CmdletParam(aclConfig));
                this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
                this.cmdletParams.Add(new CmdletParam("Action", aclAction));
                this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));

                if (order.HasValue)
                {
                    this.cmdletParams.Add(new CmdletParam("Order", order));
                }
                if (desc != null)
                {
                    this.cmdletParams.Add(new CmdletParam("Description", desc));
                }
                break;

            case "RemoveRule":
                this.cmdletParams.Add(new CmdletParam(aclConfig));
                this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
                this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));
                break;

            case "SetRule":
                this.cmdletParams.Add(new CmdletParam(aclConfig));
                this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
                this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));

                if (order.HasValue)
                {
                    this.cmdletParams.Add(new CmdletParam("Order", order));
                }
                if (aclAction != null)
                {
                    this.cmdletParams.Add(new CmdletParam("Action", aclAction));
                }
                if (remoteSubnet != null)
                {
                    this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));
                }
                if (desc != null)
                {
                    this.cmdletParams.Add(new CmdletParam("Description", desc));
                }
                break;

            default:
                break;
            }
        }
        public SetAzureAclConfigCmdletInfo(string aclConfig, NetworkAclObject aclObj, int? order, string aclAction, string remoteSubnet, string desc, int? ruleId)
        {
            this.cmdletName = Utilities.SetAzureAclConfigCmdletName;

            switch(aclConfig)
            {
            case "AddRule" : 
                    this.cmdletParams.Add(new CmdletParam(aclConfig));
                    this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
                    this.cmdletParams.Add(new CmdletParam("Action", aclAction));
                    this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));

                    if (order.HasValue)
                    {
                        this.cmdletParams.Add(new CmdletParam("Order", order));
                    }
                    if (desc != null)
                    {
                        this.cmdletParams.Add(new CmdletParam("Description", desc));
                    }                    
                    break;
                                
                case "RemoveRule" : 
                    this.cmdletParams.Add(new CmdletParam(aclConfig));
                    this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
                    this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));
                    break;
                                
                case "SetRule" : 
                    this.cmdletParams.Add(new CmdletParam(aclConfig));
                    this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
                    this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));

                    if (order.HasValue)
                    {
                        this.cmdletParams.Add(new CmdletParam("Order", order));
                    }
                    if (aclAction != null)
                    {
                        this.cmdletParams.Add(new CmdletParam("Action", aclAction));
                    }
                    if (remoteSubnet != null)
                    {
                        this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));
                    }
                    if (desc != null)
                    {
                        this.cmdletParams.Add(new CmdletParam("Description", desc));
                    }
                    break;

                default:
                    break;
            }
        }
 //NoLB
 public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
                                int endpointPublicPort, string endpointName, NetworkAclObject aclObj = null, bool directServerReturn = false)
 {
     this.Initialize(
         endpointProtocol,
         endpointLocalPort,
         endpointPublicPort,
         endpointName,
         string.Empty,
         0,
         ProtocolInfo.tcp,
         string.Empty,
         null,
         null,
         paramset,
         aclObj,
         directServerReturn);
 }
 //NoLB
 public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
     int endpointPublicPort, string endpointName, NetworkAclObject aclObj = null, bool directServerReturn = false)
 {
     this.Initialize(
         endpointProtocol, 
         endpointLocalPort, 
         endpointPublicPort, 
         endpointName, 
         string.Empty, 
         0, 
         ProtocolInfo.tcp, 
         string.Empty, 
         null, 
         null,
         paramset,
         aclObj,
         directServerReturn);
 }
        internal void ExecuteCommand()
        {
            var role = this.VM.GetInstance(); 

            var networkConfiguration = role.ConfigurationSets.OfType<NetworkConfigurationSet>().SingleOrDefault();

            if (networkConfiguration != null 
                && networkConfiguration.InputEndpoints != null)
            {
                if (string.IsNullOrEmpty(this.EndpointName))
                {
                    var ret = new List<NetworkAclObject>();
                    foreach (var endpoint in networkConfiguration.InputEndpoints)
                    {
                        ret.Add(endpoint.EndpointAccessControlList);
                    }

                    this.WriteObject(ret, true);
                }
                else
                {
                    var endpoint = (from e in networkConfiguration.InputEndpoints
                                    where e.Name.Equals(this.EndpointName, StringComparison.InvariantCultureIgnoreCase)
                                    select e).SingleOrDefault();

                    if (endpoint == null)
                    {
                        this.ThrowTerminatingError(
                            new ErrorRecord(
                                    new InvalidOperationException(
                                        string.Format(
                                            CultureInfo.InvariantCulture,
                                            Resources.EndpointCanNotBeFoundInVMConfiguration,
                                            this.EndpointName)),
                                    string.Empty,
                                    ErrorCategory.InvalidData,
                                    null));
                    }

                    NetworkAclObject acl = endpoint.EndpointAccessControlList ?? new NetworkAclObject();
                    this.WriteObject(acl);
                }
            }
        }
 // CustoProbe
 public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort, 
     int endpointPublicPort, string endpointName, string lBSetName, int probePort,
     ProtocolInfo probeProtocol, string probePath, int? probeInterval, int? probeTimeout, NetworkAclObject aclObj = null, bool directServerReturn = false)
 {
     this.Initialize(
             endpointProtocol,
             endpointLocalPort,
             endpointPublicPort,
             endpointName,
             lBSetName,
             probePort,
             probeProtocol,
             probePath,
             probeInterval,
             probeTimeout,
             paramset,
             aclObj,
             directServerReturn);
 }
        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", "testvmimage" }, 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");

            AzureVMConfigInfo           azureVMConfigInfo1      = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall, imageName);
            AzureVMConfigInfo           azureVMConfigInfo2      = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.ExtraSmall, imageName);
            AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
            AddAzureDataDiskConfig      azureDataDiskConfigInfo = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0);
            AzureEndPointConfigInfo     azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.DefaultProbe, ProtocolInfo.tcp, 80, 80, "web", "lbweb", aclObj, true);

            PersistentVMConfigInfo persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
            PersistentVMConfigInfo persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);

            PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
            PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);

            PersistentVM[] VMs = { persistentVM1, persistentVM2 };
            vmPowershellCmdlets.NewAzureVM(serviceName, VMs);

            // Cleanup
            vmPowershellCmdlets.RemoveAzureVM(newAzureVM1Name, serviceName);
            vmPowershellCmdlets.RemoveAzureVM(newAzureVM2Name, serviceName);

            Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM1Name, serviceName));
            Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM2Name, serviceName));
            pass = true;
        }
 private void Initialize(ProtocolInfo protocol, int internalPort,
     int? externalPort, string endpointName, string lBSetName, int probePort,
     ProtocolInfo probeProtocol, string probePath, 
     int? probeInterval, int? probeTimeout, ParameterSet paramSet, NetworkAclObject aclObj, bool directServerReturn)
 {
     this.EndpointLocalPort = internalPort;
     this.EndpointProtocol = protocol;
     this.EndpointPublicPort = externalPort;
     this.EndpointName = endpointName;
     this.LBSetName = lBSetName;
     this.ProbePort = probePort;
     this.ProbeProtocol = probeProtocol;            
     this.ProbeInterval = probeInterval;
     this.ProbeTimeout = probeTimeout;
     this.ParamSet = paramSet;
     this.Acl = aclObj;
     this.DirectServerReturn = directServerReturn;
     if (this.ProbeProtocol.ToString().Equals("http"))
         this.ProbePath = probePath;
 }
 // ParameterSet.LoadBalancedNoProbe
 public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
     int endpointPublicPort, string endpointName, string lBSetName, NetworkAclObject aclObj = null, bool directServerReturn = false)
 {
     if ( (paramset == ParameterSet.LoadBalancedNoProbe) || (paramset == ParameterSet.DefaultProbe) )
     {
         this.Initialize(
             endpointProtocol,
             endpointLocalPort,
             endpointPublicPort,
             endpointName,
             lBSetName,
             0,
             ProtocolInfo.tcp,
             string.Empty,
             null,
             null,
             paramset,
             aclObj,
             directServerReturn);
     }
 }
Пример #14
0
 private void Initialize(
     ProtocolInfo protocol,
     int internalPort,
     int?externalPort,
     string endpointName,
     string lBSetName,
     int probePort,
     ProtocolInfo probeProtocol,
     string probePath,
     int?probeInterval,
     int?probeTimeout,
     ParameterSet paramSet,
     NetworkAclObject aclObj,
     bool directServerReturn,
     string internalLoadBalancer,
     string serviceName,
     string loadBalancerDistribution,
     string VirtualIPName)
 {
     this.EndpointLocalPort  = internalPort;
     this.EndpointProtocol   = protocol;
     this.EndpointPublicPort = externalPort;
     this.EndpointName       = endpointName;
     this.LBSetName          = lBSetName;
     this.ProbePort          = probePort;
     this.ProbeProtocol      = probeProtocol;
     this.ProbeInterval      = probeInterval;
     this.ProbeTimeout       = probeTimeout;
     this.ParamSet           = paramSet;
     this.Acl = aclObj;
     this.DirectServerReturn = directServerReturn;
     if (this.ProbeProtocol.ToString().Equals("http"))
     {
         this.ProbePath = probePath;
     }
     this.InternalLoadBalancerName = internalLoadBalancer;
     this.ServiceName = serviceName;
     this.LoadBalancerDistribution = loadBalancerDistribution;
     this.VirtualIPName            = VirtualIPName;
 }
Пример #15
0
 // CustomProbe parameter set
 public AzureEndPointConfigInfo(
     ParameterSet paramset,
     ProtocolInfo endpointProtocol,
     int endpointLocalPort,
     int endpointPublicPort,
     string endpointName,
     string lBSetName,
     int probePort,
     ProtocolInfo probeProtocol,
     string probePath,
     int?probeInterval,
     int?probeTimeout,
     NetworkAclObject aclObj         = null,
     bool directServerReturn         = false,
     string internalLoadBalancer     = null,
     string serviceName              = null,
     string loadBalancerDistribution = null,
     string VirtualIPName            = null)
 {
     this.Initialize(
         endpointProtocol,
         endpointLocalPort,
         endpointPublicPort,
         endpointName,
         lBSetName,
         probePort,
         probeProtocol,
         probePath,
         probeInterval,
         probeTimeout,
         paramset,
         aclObj,
         directServerReturn,
         internalLoadBalancer,
         serviceName,
         loadBalancerDistribution,
         VirtualIPName);
 }
        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.CustonProbe,
                ProtocolInfo.tcp,
                ep1LocalPort,
                ep1PublicPort,
                ep1Name,
                ep1LBSetName,
                ep1ProbePort,
                ProtocolInfo.tcp,
                ep1ProbePath,
                ep1ProbeInterval,
                ep1ProbeTimeout,
                ep1AclObj,
                ep1DirectServerReturn);

            AzureEndPointConfigInfo ep2Info = new AzureEndPointConfigInfo(
                AzureEndPointConfigInfo.ParameterSet.CustonProbe,
                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());
            }
        }
 // CustomProbe parameter set
 public AzureEndPointConfigInfo(
     ParameterSet paramset,
     ProtocolInfo endpointProtocol,
     int endpointLocalPort,
     int endpointPublicPort,
     string endpointName,
     string lBSetName,
     int probePort,
     ProtocolInfo probeProtocol,
     string probePath,
     int? probeInterval,
     int? probeTimeout,
     NetworkAclObject aclObj = null,
     bool directServerReturn = false,
     string internalLoadBalancer= null,
     string serviceName = null,
     string loadBalancerDistribution = null,
     string VirtualIPName = null)
 {
         this.Initialize(
             endpointProtocol,
             endpointLocalPort,
             endpointPublicPort,
             endpointName,
             lBSetName,
             probePort,
             probeProtocol,
             probePath,
             probeInterval,
             probeTimeout,
             paramset,
             aclObj,
             directServerReturn,
             internalLoadBalancer,
             serviceName,
             loadBalancerDistribution,
             VirtualIPName);
 }
 private void Initialize(ProtocolInfo protocol, int internalPort,
     int? externalPort, string endpointName, string lBSetName, int probePort,
     ProtocolInfo probeProtocol, string probePath, 
     int? probeInterval, int? probeTimeout, ParameterSet paramSet, NetworkAclObject aclObj, bool directServerReturn,string internalLoadBalancer,string serviceName)
 {
     this.EndpointLocalPort = internalPort;
     this.EndpointProtocol = protocol;
     this.EndpointPublicPort = externalPort;
     this.EndpointName = endpointName;
     this.LBSetName = lBSetName;
     this.ProbePort = probePort;
     this.ProbeProtocol = probeProtocol;            
     this.ProbeInterval = probeInterval;
     this.ProbeTimeout = probeTimeout;
     this.ParamSet = paramSet;
     this.Acl = aclObj;
     this.DirectServerReturn = directServerReturn;
     if (this.ProbeProtocol.ToString().Equals("http"))
         this.ProbePath = probePath;
     this.InternalLoadBalancerName = internalLoadBalancer;
     this.ServiceName = serviceName;
 }
 // CustoProbe
 public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
                                int endpointPublicPort, string endpointName, string lBSetName, int probePort,
                                ProtocolInfo probeProtocol, string probePath, int?probeInterval, int?probeTimeout, NetworkAclObject aclObj = null, bool directServerReturn = false)
 {
     this.Initialize(
         endpointProtocol,
         endpointLocalPort,
         endpointPublicPort,
         endpointName,
         lBSetName,
         probePort,
         probeProtocol,
         probePath,
         probeInterval,
         probeTimeout,
         paramset,
         aclObj,
         directServerReturn);
 }
Пример #20
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;
            }
        }