You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by ts...@apache.org on 2013/10/15 08:47:07 UTC
git commit: updated refs/heads/master to 56ccb28
Updated Branches:
refs/heads/master 76dbb64cf -> 56ccb2835
Automation Tests for HA Proxy Stickiness
Reviewed-by: Suresh Sadhu <Su...@citrix.com>
Signed-off-by: Prasanna Santhanam <ts...@apache.org>
Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/56ccb283
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/56ccb283
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/56ccb283
Branch: refs/heads/master
Commit: 56ccb2835b28c04bbecc3910b20cc5c0b016bda5
Parents: 76dbb64
Author: Girish Shilamkar <gi...@clogeny.com>
Authored: Thu Oct 10 02:21:47 2013 -0400
Committer: Prasanna Santhanam <ts...@apache.org>
Committed: Tue Oct 15 12:14:01 2013 +0530
----------------------------------------------------------------------
test/integration/component/test_haproxy.py | 874 ++++++++++++++++++++++++
1 file changed, 874 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/56ccb283/test/integration/component/test_haproxy.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_haproxy.py b/test/integration/component/test_haproxy.py
new file mode 100644
index 0000000..799cfa3
--- /dev/null
+++ b/test/integration/component/test_haproxy.py
@@ -0,0 +1,874 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+""" P1 tests for VPN users
+"""
+# Import Local Modules
+from nose.plugins.attrib import attr
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.integration.lib.base import (
+ Account,
+ ServiceOffering,
+ VirtualMachine,
+ PublicIPAddress,
+ Network,
+ LoadBalancerRule,
+ Alert,
+ Router,
+ Vpn,
+ NATRule
+ )
+from marvin.integration.lib.common import (get_domain,
+ get_zone,
+ get_template,
+ cleanup_resources,
+ random_gen
+ )
+from marvin.cloudstackAPI import createLBStickinessPolicy
+from marvin.remoteSSHClient import remoteSSHClient
+
+
+class Services:
+ """Test VPN users Services
+ """
+
+ def __init__(self):
+ self.services = {
+ "account": {
+ "email": "test@test.com",
+ "firstname": "Test",
+ "lastname": "User",
+ "username": "test",
+ # Random characters are appended for unique
+ # username
+ "password": "password",
+ },
+ "service_offering": {
+ "name": "Tiny Instance",
+ "displaytext": "Tiny Instance",
+ "cpunumber": 1,
+ "cpuspeed": 100, # in MHz
+ "memory": 128, # In MBs
+ },
+ "disk_offering": {
+ "displaytext": "Small Disk Offering",
+ "name": "Small Disk Offering",
+ "disksize": 1
+ },
+ "virtual_machine": {
+ "displayname": "TestVM",
+ "username": "root",
+ "password": "password",
+ "ssh_port": 22,
+ "hypervisor": 'XenServer',
+ "privateport": 22,
+ "publicport": 22,
+ "protocol": 'TCP',
+ },
+ "vpn_user": {
+ "username": "test",
+ "password": "test",
+ },
+ "natrule": {
+ "privateport": 22,
+ "publicport": 22,
+ "protocol": "TCP",
+ "username":"root",
+ "password": "password"
+ },
+ "network": {
+ "name": "Test Network",
+ "displaytext": "Test Network",
+ "netmask": '255.255.255.0'
+ },
+ "lbrule": {
+ "name": "SSH",
+ "alg": "roundrobin",
+ # Algorithm used for load balancing
+ "privateport": 22,
+ "publicport": 2222,
+ "openfirewall": False,
+ "startport": 22,
+ "endport": 2222,
+ "protocol": "TCP",
+ "cidrlist": '0.0.0.0/0',
+ },
+ "ostype": 'CentOS 5.3 (64-bit)',
+ "sleep": 60,
+ "timeout": 10,
+ "mode": 'advanced',
+ # Networking mode: Advanced, Basic
+ }
+
+
+class TestHAProxyStickyness(cloudstackTestCase):
+
+ @classmethod
+ def setUpClass(cls):
+ cls.api_client = super(TestHAProxyStickyness,
+ cls).getClsTestClient().getApiClient()
+ cls.services = Services().services
+ # Get Zone, Domain and templates
+ cls.domain = get_domain(cls.api_client, cls.services)
+ cls.zone = get_zone(cls.api_client, cls.services)
+
+ cls.template = get_template(
+ cls.api_client,
+ cls.zone.id,
+ cls.services["ostype"]
+ )
+
+ cls.services["virtual_machine"]["zoneid"] = cls.zone.id
+ cls.service_offering = ServiceOffering.create(
+ cls.api_client,
+ cls.services["service_offering"]
+ )
+
+ cls._cleanup = [cls.service_offering, ]
+ return
+
+ @classmethod
+ def tearDownClass(cls):
+ try:
+ # Cleanup resources used
+ cleanup_resources(cls.api_client, cls._cleanup)
+ except Exception as e:
+ raise Exception("Warning: Exception during cleanup : %s" % e)
+ return
+
+ def setUp(self):
+ self.apiclient = self.testClient.getApiClient()
+ self.dbclient = self.testClient.getDbConnection()
+ self.account = Account.create(
+ self.apiclient,
+ self.services["account"],
+ domainid=self.domain.id
+ )
+ self.virtual_machine = VirtualMachine.create(
+ self.apiclient,
+ self.services["virtual_machine"],
+ templateid=self.template.id,
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id
+ )
+
+ self.virtual_machine_2 = VirtualMachine.create(
+ self.apiclient,
+ self.services["virtual_machine"],
+ templateid=self.template.id,
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id
+ )
+ self.public_ip = PublicIPAddress.create(
+ self.apiclient,
+ self.virtual_machine.account,
+ self.virtual_machine.zoneid,
+ self.virtual_machine.domainid,
+ self.services["virtual_machine"]
+ )
+
+ NATRule.create(
+ self.apiclient,
+ self.virtual_machine,
+ self.services["natrule"],
+ ipaddressid=self.public_ip.ipaddress.id
+ )
+
+ self.cleanup = [self.account, ]
+ return
+
+ def tearDown(self):
+ try:
+ # Clean up, terminate the created instance, volumes and snapshots
+ cleanup_resources(self.apiclient, self.cleanup)
+ pass
+ except Exception as e:
+ raise Exception("Warning: Exception during cleanup : %s" % e)
+ return
+
+ def get_Network(self, account):
+ """Returns a network for account"""
+
+ networks = Network.list(
+ self.apiclient,
+ account=account.name,
+ domainid=account.domainid,
+ listall=True
+ )
+ self.assertIsInstance(networks,
+ list,
+ "List networks should return a valid response")
+ return networks[0]
+
+ def create_LB_Rule(self, public_ip, network, vmarray, services=None):
+ """Create and validate the load balancing rule"""
+
+ self.debug("Creating LB rule for IP address: %s" %
+ public_ip.ipaddress.ipaddress)
+ objservices = None
+ if services:
+ objservices = services
+ else:
+ objservices = self.services["lbrule"]
+
+ lb_rule = LoadBalancerRule.create(
+ self.apiclient,
+ objservices,
+ ipaddressid=public_ip.ipaddress.id,
+ accountid=self.account.name,
+ networkid=network.id,
+ domainid=self.account.domainid
+ )
+ self.debug("Adding virtual machines %s to LB rule" % str(vmarray))
+ lb_rule.assign(self.apiclient, vmarray)
+ return lb_rule
+
+ def configure_Stickiness_Policy(self, lb_rule, method, paramDict=None):
+ """Configure the stickiness policy on lb rule"""
+ try:
+ result = lb_rule.createSticky(
+ self.apiclient,
+ methodname=method,
+ name="-".join([method, random_gen()]),
+ param=paramDict
+ )
+ self.debug("Response: %s" % result)
+ return result
+ except Exception as e:
+ self.fail("Configure sticky policy failed with exception: %s" % e)
+
+ def validate_Stickiness_Policy(self, lb_rule, method, publicip):
+ """Validates the stickiness policy"""
+
+ sticky_policies = lb_rule.listStickyPolicies(self.apiclient,
+ lbruleid=lb_rule.id,
+ listall=True)
+ self.assertIsInstance(sticky_policies,
+ list,
+ "List sticky policies should return a valid list")
+ sticky_policy = sticky_policies[0]
+
+ self.debug("Stickiness policy method: %s" %
+ sticky_policy.stickinesspolicy[0].methodname)
+ self.assertEqual(sticky_policy.stickinesspolicy[0].methodname,
+ method,
+ "Stickiness policy should have method as - %s" % method)
+
+ hostnames = []
+
+ hostnames = self.try_ssh(publicip, hostnames)
+ hostnames = self.try_ssh(publicip, hostnames)
+
+ self.debug("hostnames: %s" % hostnames)
+ self.debug("set(hostnames): %s" % set(hostnames))
+
+ #For each ssh, host should be the same, else stickiness policy is not working properly
+ if len(hostnames) == len(set(hostnames)):
+ raise Exception("Stickyness policy: %s not working properly, got hostnames %s"
+ % (method, hostnames))
+ return
+
+ def delete_Stickiness_policy(self, policy, lb_rule):
+ """Deletes the stickiness policy"""
+
+ try:
+ lb_rule.deleteSticky(self.apiclient, id=policy.id)
+ except Exception as e:
+ self.fail("Failed to delete the stickiness policy: %s" % e)
+
+ sticky_policies = lb_rule.listStickyPolicies(self.apiclient,
+ lbruleid=lb_rule.id,
+ listall=True)
+ self.assertIsInstance(sticky_policies, list,
+ "List stickiness policies shall return a valid response")
+
+ policy = sticky_policies[0]
+
+ self.assertEqual(len(policy.stickinesspolicy),
+ 0,
+ "List stickiness policy should return nothing")
+ return
+
+ def check_stickiness_supported_methods(self, supportedMethods, value):
+
+ for i, dic in enumerate(supportedMethods):
+ if dic["methodname"] == value:
+ return True
+ return False
+
+ def acquire_Public_Ip(self):
+ """Acquires the public IP"""
+
+ try:
+ self.debug("Acquiring public IP for account: %s" %
+ self.account.name)
+ public_ip = PublicIPAddress.create(
+ self.apiclient,
+ self.virtual_machine.account,
+ self.virtual_machine.zoneid,
+ self.virtual_machine.domainid,
+ self.services["virtual_machine"]
+ )
+ self.debug("Acquired public IP: %s" %
+ public_ip.ipaddress.ipaddress)
+
+ self.debug("Configuring NAT rule for the acquired public ip")
+
+ NATRule.create(
+ self.apiclient,
+ self.virtual_machine,
+ self.services["natrule"],
+ ipaddressid=public_ip.ipaddress.id
+ )
+
+ return public_ip
+ except Exception as e:
+ self.fail("Failed to acquire new public IP: %s" % e)
+
+ def get_router(self, account):
+ """Returns a default router for account"""
+
+ routers = Router.list(self.apiclient,
+ account=self.account.name,
+ domainid=self.account.domainid,
+ listall=True)
+ self.assertIsInstance(routers, list,
+ "List routers should return a valid repsonse")
+ return routers[0]
+
+ def create_VPN(self, public_ip):
+ """Creates VPN for the network"""
+
+ self.debug("Creating VPN with public IP: %s" % public_ip.ipaddress.id)
+ try:
+ # Assign VPN to Public IP
+ vpn = Vpn.create(self.apiclient,
+ self.public_ip.ipaddress.id,
+ account=self.account.name,
+ domainid=self.account.domainid)
+
+ self.debug("Verifying the remote VPN access")
+ vpns = Vpn.list(self.apiclient,
+ publicipid=public_ip.ipaddress.id,
+ listall=True)
+ self.assertEqual(
+ isinstance(vpns, list),
+ True,
+ "List VPNs shall return a valid response"
+ )
+ return vpn
+ except Exception as e:
+ self.fail("Failed to create remote VPN access: %s" % e)
+
+ def try_ssh(self, ip_addr, hostnames):
+ try:
+ self.debug(
+ "SSH into NAT Rule (Public IP: %s)" % ip_addr)
+
+ # If Round Robin Algorithm is chosen,
+ # each ssh command should alternate between VMs
+
+ ssh_1 = remoteSSHClient(
+ ip_addr,
+ 22,
+ self.services["natrule"]["username"],
+ self.services["natrule"]["password"]
+ )
+ hostnames.append(ssh_1.execute("hostname")[0])
+ self.debug(hostnames)
+ except Exception as e:
+ self.fail("%s: SSH failed for VM with IP Address: %s" %
+ (e, ip_addr))
+ return hostnames
+
+ @attr(tags=["advanced", "advancedns"])
+ @attr(speed="slow")
+ def test_01_create_sticky_policy_default_values(self):
+ """Test Configure stickiness policies with default values"""
+
+ # Validate the following
+ # 1. Create a LB rule with round robin. listLoadBalancerRules should
+ # show newly created load balancer rule.
+ # 2. Configure the Source based, app cookie and lb cookie based policy
+ # listLBStickinessPolicies should show newly created stickiness
+
+ self.debug("Creating a load balancing rule on IP: %s" %
+ self.public_ip.ipaddress.ipaddress)
+
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2])
+
+ methods = ["SourceBased", "AppCookie", "LBCookie"]
+ for method in methods:
+ self.debug("Creating stickiness policy for the LB rule: %s" %
+ lb_rule.id)
+ policies = self.configure_Stickiness_Policy(lb_rule, method=method)
+
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, method, self.public_ip.ipaddress.ipaddress)
+ self.debug("Deleting the stickiness policy for lb rule: %s" %
+ lb_rule.name)
+ self.delete_Stickiness_policy(policy, lb_rule)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ @attr(speed="slow")
+ def test_02_create_sticky_policy_custom_values(self):
+ """Test Configure stickiness policies with custom values"""
+
+ # Validate the following
+ # 1. Create a LB rule with roundrobin, leastconn and source.
+ # listLoadBalancerRules should show newly created load balancer rule
+ # 2. Configure the Source based, app cookie and lb cookie based policy
+ # with custom parameters
+ # listLBStickinessPolicies should show newly created stickiness
+
+ lb_methods = ["roundrobin", "leastconn", "source"]
+
+ configs = {"SourceBased": {"tablesize": '100k'},
+ "AppCookie": {"request-learn": "true"},
+ "LBCookie": {"nocache": "true"}}
+
+ for lb_method in lb_methods:
+ self.debug("Creating a load balancing rule on IP %s and algo %s" %
+ (self.public_ip.ipaddress.ipaddress, lb_method))
+
+ services = self.services["lbrule"]
+ services["alg"] = lb_method
+
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2],
+ services=services)
+
+ for method, params in configs.items():
+ self.debug("Creating stickiness policy for the LB rule: %s" %
+ lb_rule.id)
+ policies = self.configure_Stickiness_Policy(lb_rule,
+ method=method,
+ paramDict=params)
+
+ policy = policies.stickinesspolicy[0]
+ self.debug("Policy: %s" % str(policy))
+
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, method, self.public_ip.ipaddress.ipaddress)
+ self.debug("Deleting the stickiness policy for lb rule: %s" %
+ lb_rule.name)
+ self.delete_Stickiness_policy(policy, lb_rule)
+ self.debug("Deleting the LB rule: %s" % lb_rule.name)
+ lb_rule.delete(self.apiclient)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ @attr(speed="slow")
+ def test_03_supported_policies_by_network(self):
+ """Test listnetworks response to check supported stickiness policies"""
+
+ # Validate the following
+ # 1. List networks for the account in advance network mode
+ # 2. List of supported sticky methods should be present under
+ # SupportedStickinessMethods tag
+
+ self.debug("List networks for account: %s" % self.account.name)
+ networks = Network.list(self.apiclient,
+ account=self.account.name,
+ domainid=self.account.domainid,
+ listall=True)
+
+ self.assertIsInstance(networks,
+ list,
+ "List network should return a valid response")
+ network = networks[0]
+ self.debug("Network: %s" % network)
+ self.assertEqual(hasattr(network, "SupportedStickinessMethods"),
+ True,
+ "Network should have SupportedStickinessMethods param")
+
+ self.assertEqual(hasattr(network, "LbCookie"),
+ True,
+ "Network should have LbCookie LB method param")
+
+ self.assertEqual(hasattr(network, "AppCookie"),
+ True,
+ "Network should have AppCookie LB method param")
+
+ self.assertEqual(hasattr(network, "SourceBased"),
+ True,
+ "Network should have SourceBased LB method param")
+
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ @attr(speed="slow")
+ def test_04_delete_lb_rule(self):
+ """Test LB rule before/after stickiness policy creation"""
+
+ # Validate the following
+ # 1. Create a LB rule with roundrobin, leastconn and source.
+ # listLoadBalancerRules should show newly created load balancer rule
+ # 2. Delete the loadbalancer rule. Delete loadbalancer rule should be
+ # successful
+ # 3. Configure the Source based, app cookie and lb cookie based policy
+ # with custom parameters listLBStickinessPolicies should show newly
+ # created stickiness
+ # 4. Delete load balancer rule. Delete should be successful
+
+ lb_methods = ["roundrobin", "leastconn", "source"]
+
+ configs = {"SourceBased": {"tablesize": '100k'},
+ "AppCookie": {"request-learn": "true"},
+ "LBCookie": {"nocache": "true"}}
+ for lb_method in lb_methods:
+ for method, params in configs.items():
+ self.debug("Creating load balancing rule on IP %s & algo %s" %
+ (self.public_ip.ipaddress.ipaddress, lb_method))
+
+ services = self.services["lbrule"]
+ services["alg"] = lb_method
+
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2],
+ services=services)
+ self.debug(
+ "Deleting the LB rule before stickiness policy creation")
+ lb_rule.delete(self.apiclient)
+
+ with self.assertRaises(Exception):
+ LoadBalancerRule.list(self.apiclient,
+ id=lb_rule.id,
+ listall=True)
+
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2],
+ services=services)
+ self.debug("Creating stickiness policy for the LB rule: %s" %
+ lb_rule.id)
+ policies = self.configure_Stickiness_Policy(lb_rule,
+ method=method,
+ paramDict=params)
+
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, method, self.public_ip.ipaddress.ipaddress)
+
+ self.debug("Deleting the LB rule: %s" % lb_rule.name)
+ lb_rule.delete(self.apiclient)
+ with self.assertRaises(Exception):
+ LoadBalancerRule.list(self.apiclient, id=lb_rule.id)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ @attr(speed="slow")
+ def test_05_error_alerts_after_create(self):
+ """Test error/alerts after creating stickiness policy"""
+
+ # Validate the following
+ # 1. Create a LB rule with round Robin/Least connections/Source
+ # listLoadBalancerRules should show newly created load balancer rule
+ # 2. Configure the Stickiness policy to above created LB rule.
+ # listLBStickinessPolicies Api should show newly created stickiness
+ # 3. update & delete stickiness policy see error related to stickiness
+ # 4. No errors should be shown in the logs and alerts
+
+ lb_methods = ["roundrobin", "leastconn", "source"]
+ configs = {"SourceBased": {"tablesize": '100k'},
+ "AppCookie": {"request-learn": "true"},
+ "LBCookie": {"nocache": "true"}}
+ for lb_method in lb_methods:
+ for method, params in configs.items():
+ self.debug("Creating load balancing rule on IP %s & algo %s" %
+ (self.public_ip.ipaddress.ipaddress, lb_method))
+
+ services = self.services["lbrule"]
+ services["alg"] = lb_method
+
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2],
+ services=services)
+
+ self.debug("Creating stickiness policy for the LB rule: %s" %
+ lb_rule.id)
+ policies = self.configure_Stickiness_Policy(lb_rule,
+ method=method,
+ paramDict=params)
+
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, method, self.public_ip.ipaddress.ipaddress)
+
+ self.debug("Deleting the LB rule: %s" % lb_rule.name)
+ lb_rule.delete(self.apiclient)
+
+ with self.assertRaises(Exception):
+ LoadBalancerRule.list(self.apiclient,
+ id=lb_rule.id,
+ listall=True)
+ alerts = Alert.list(self.apiclient, keyword="stickiness",
+ listall=True)
+ self.debug(
+ "Create/update/delete should not produce any alert/error")
+ self.assertEqual(alerts, None,
+ "Create/update/delete should not produce any alert/error")
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ @attr(speed="slow")
+ def test_06_release_ip(self):
+ """Test release public IP with stickiness policy"""
+
+ # 1. Configure load balancing rule. Listloadbalancerrule should list
+ # valid list
+ # 2. Create stickiness policy. liststickinesspolicy should return valid
+ # response
+ # 3. Release public Ip. liststickiness policy should return a valid
+ # response
+
+ lb_methods = ["roundrobin", "leastconn", "source"]
+
+ configs = {"SourceBased": {"tablesize": '100k'},
+ "AppCookie": {"request-learn": "true"},
+ "LBCookie": {"nocache": "true"}}
+
+ for lb_method in lb_methods:
+ for method, params in configs.items():
+ self.debug("Setting up environment - acquire public IP")
+ public_ip = self.acquire_Public_Ip()
+
+ self.debug(
+ "Creating a load balancing rule on IP %s and algo %s" %
+ (public_ip.ipaddress.ipaddress, lb_method))
+
+ services = self.services["lbrule"]
+ services["alg"] = lb_method
+
+ lb_rule = self.create_LB_Rule(public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2],
+ services=services)
+
+ policies = self.configure_Stickiness_Policy(lb_rule,
+ method=method,
+ paramDict=params)
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, method, public_ip.ipaddress.ipaddress)
+
+ self.debug("Releasing public Ip: %s" %
+ public_ip.ipaddress.ipaddress)
+ public_ip.delete(self.apiclient)
+
+ self.debug("Checking the response of liststickiness policies")
+
+ with self.assertRaises(Exception):
+ lb_rule.listStickyPolicies(self.apiclient,
+ lbruleid=lb_rule.id,
+ listall=True)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ def test_07_delete_account(self):
+ """Test Delete account and check the router and its rules"""
+
+ # Validate the following
+ # 1. create an account
+ # 2. using that account,create an instances
+ # 3. select the Source NAT IP and configure the stikiness policy
+ # 4. Delete account
+ # 5. The corresponding stikiness policy should be removed
+ # listLBStickinessPolicies Api shouldnot show deleted stikiness policy
+
+ self.debug("Creating LB rule for account: %s" %
+ self.account.name)
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2])
+
+ policies = self.configure_Stickiness_Policy(lb_rule, method="LbCookie")
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, "LbCookie", self.public_ip.ipaddress.ipaddress)
+
+ # removing account from cleanup list as we're deleting account
+ self.cleanup.pop()
+ self.debug("Deleting account: %s" % self.account.name)
+
+ try:
+ self.account.delete(self.apiclient)
+ except Exception as e:
+ self.fail("Failed to delete account: %s" % e)
+ self.debug("Checking the response of liststickiness policies")
+
+ with self.assertRaises(Exception):
+ lb_rule.listStickyPolicies(self.apiclient,
+ lbruleid=lb_rule.id,
+ listall=True)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ def test_08_create_policy_router_stopped(self):
+ """Test verify create stickiness policy when router is stopped state"""
+
+ # Validate the following
+ # 1. stop the router
+ # 2. create stikiness policy from UI
+ # 3. start the router. listLBStickinessPolicies Api should show created
+ # stikiness policy
+
+ self.debug("Creating LB rule for account: %s" % self.account.name)
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2])
+
+ self.debug("Fetching routers for the account: %s" %
+ self.account.name)
+ router = self.get_router(self.account)
+
+ self.debug("Stopping the router: %s" % router.name)
+ Router.stop(self.apiclient, id=router.id)
+
+ policies = self.configure_Stickiness_Policy(lb_rule, method="LbCookie")
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Starting the router: %s" % router.name)
+ Router.start(self.apiclient, id=router.id)
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, "LbCookie", self.public_ip.ipaddress.ipaddress)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ def test_09_create_policy_router_destroy(self):
+ """Test check the stickiness policy rules after destroying router"""
+
+ # Validate the following
+ # 1. create an account
+ # 2. using that account,create an instances
+ # 3. select the Source NAT IP and configure the stikiness policy
+ # 4. destroy the router.
+
+ self.debug("Creating LB rule for account: %s" % self.account.name)
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2])
+
+ self.debug("Fetching routers for the account: %s" %
+ self.account.name)
+ router = self.get_router(self.account)
+
+ policies = self.configure_Stickiness_Policy(lb_rule, method="LbCookie")
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, "LbCookie", self.public_ip.ipaddress.ipaddress)
+
+ self.debug("Destroying the router: %s" % router.name)
+ Router.destroy(self.apiclient, id=router.id)
+
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ def test_10_create_policy_enable_disable_vpn(self):
+ """Test enable/disable the VPN after applying sticky policy rules"""
+
+ # Validate the following
+ # 1. create an account
+ # 2. using that account,create an instances
+ # 3. select the Source NAT IP and configure the stikiness policy
+ # 4. enable /disable the VPN. It should not impact the ceated rules
+ # listLBStickinessPolicies Api should show created stikiness policy
+
+ self.debug("Creating LB rule for account: %s" % self.account.name)
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2])
+
+ policies = self.configure_Stickiness_Policy(lb_rule, method="LbCookie")
+ policy = policies.stickinesspolicy[0]
+
+ self.debug("Policy: %s" % str(policy))
+ self.debug("Validating the stickiness policy")
+ self.validate_Stickiness_Policy(lb_rule, "LbCookie", self.public_ip.ipaddress.ipaddress)
+
+ self.debug("Enabling VPN on Public Ip: %s" %
+ self.public_ip.ipaddress.ipaddress)
+ self.create_VPN(self.public_ip)
+
+ self.debug("Validating the stickiness policy after enabling VPN")
+ self.validate_Stickiness_Policy(lb_rule, "LbCookie", self.public_ip.ipaddress.ipaddress)
+ return
+
+ @attr(tags=["advanced", "advancedns"])
+ def test_11_invalid_params(self):
+ """Test verfify functionality syncronous and asyncronous validations"""
+
+ # Validate the following
+ # verify the validation while creating or attaching stikiness policy
+ # by doing the following scenaios
+ # * by passing the Invlaid parameter
+ # * Invalid method name
+ # * required parameter not present
+ # * passing invalid values to valid paramters.
+
+ self.debug("Creating LB rule for account: %s" % self.account.name)
+ lb_rule = self.create_LB_Rule(self.public_ip,
+ network=self.get_Network(self.account),
+ vmarray=[self.virtual_machine, self.virtual_machine_2])
+
+ self.debug("Creating stickiness policy with invalid method")
+ with self.assertRaises(Exception):
+ self.configure_Stickiness_Policy(lb_rule, method="InvalidMethod")
+
+ self.debug("Creating stickiness policy with invalid params")
+ with self.assertRaises(Exception):
+ self.configure_Stickiness_Policy(lb_rule, method="LbCookie",
+ params={"Test": 10})
+
+ self.debug("Passing invalid parameter")
+ with self.assertRaises(Exception):
+ cmd = createLBStickinessPolicy.createLBStickinessPolicyCmd()
+ cmd.lbruleid = lb_rule.id
+ cmd.method = "LbCookie"
+ cmd.name = "LbCookie"
+ self.apiclient.createLBStickinessPolicy(cmd)
+
+ self.debug("Creating stickiness policy not passing required param")
+ with self.assertRaises(Exception):
+ cmd = createLBStickinessPolicy.createLBStickinessPolicyCmd()
+ cmd.lbruleid = lb_rule.id
+ cmd.name = "LbCookie"
+ self.apiclient.createLBStickinessPolicy(cmd)
+
+ return