cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tall...@apache.org
Subject git commit: updated refs/heads/master to 2103068
Date Fri, 25 Oct 2013 08:59:53 GMT
Updated Branches:
  refs/heads/master a77435dab -> 210306881


CLOUDSTACK-702: Added tests for alias ip verifications on VR 1. Moved vm deployment code to
setup and vm deletion code teadDown methods 2. Added two tests which would verify alias removal
after last vm expunge in CIDR and alias status after VR reboot

CLOUDSTACK-702: Test for verifying ip alias after VR stop start
     1.Deploy vm in new cidr which will create ip alias on existing VR
	Stop,start VR and verify ip alias

Conflicts:

	test/integration/component/maint/test_multiple_ip_ranges.py

Signed-off-by: SrikanteswaraRao Talluri <talluri@apache.org>


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/21030688
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/21030688
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/21030688

Branch: refs/heads/master
Commit: 2103068816d024cf090797168bfd309b031e3e1c
Parents: a77435d
Author: sanjeevneelarapu <sanjeev.neelarapu@citrix.com>
Authored: Mon Oct 21 20:21:11 2013 +0530
Committer: SrikanteswaraRao Talluri <talluri@apache.org>
Committed: Fri Oct 25 14:29:19 2013 +0530

----------------------------------------------------------------------
 .../component/maint/test_multiple_ip_ranges.py  | 557 ++++++++++++-------
 1 file changed, 353 insertions(+), 204 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/21030688/test/integration/component/maint/test_multiple_ip_ranges.py
----------------------------------------------------------------------
diff --git a/test/integration/component/maint/test_multiple_ip_ranges.py b/test/integration/component/maint/test_multiple_ip_ranges.py
index 3f0035e..dc8021b 100644
--- a/test/integration/component/maint/test_multiple_ip_ranges.py
+++ b/test/integration/component/maint/test_multiple_ip_ranges.py
@@ -22,9 +22,8 @@ from marvin.cloudstackException import cloudstackAPIException
 from marvin.integration.lib.utils import *
 from marvin.integration.lib.base import *
 from marvin.integration.lib.common import *
-#from netaddr import *
+# from netaddr import *
 import netaddr
-
 from nose.plugins.attrib import attr
 
 class Services:
@@ -45,8 +44,8 @@ class Services:
                                     "name": "Tiny Instance",
                                     "displaytext": "Tiny Instance",
                                     "cpunumber": 1,
-                                    "cpuspeed": 200,    # in MHz
-                                    "memory": 256,      # In MBs
+                                    "cpuspeed": 200,  # in MHz
+                                    "memory": 256,  # In MBs
                         },
                         "disk_offering": {
                                     "displaytext": "Small Disk",
@@ -129,7 +128,7 @@ class TestMultipleIpRanges(cloudstackTestCase):
         cls.id_list = []
         for i in range(len(cls.ids)):
             cls.id_list.append(cls.ids[i][0])
-        #Check if VR is already present in the setup
+        # Check if VR is already present in the setup
         vr_list = Router.list(cls.api_client, listall='true')
         cls.debug("vr list {}".format(vr_list))
         if isinstance(vr_list, list) and len(vr_list) > 0:
@@ -143,22 +142,26 @@ class TestMultipleIpRanges(cloudstackTestCase):
             cls.dbclient.execute(
                                  "update user_ip_address set allocated=now() where id = '%s';"
% str(id)
                                  )
-        #Add IP range in the new CIDR
+        # Add IP range in the new CIDR
         cls.services["vlan_ip_range"]["zoneid"] = cls.zone.id
         cls.services["vlan_ip_range"]["podid"] = cls.pod.id
-        #create new vlan ip range
-        cls.new_vlan = PublicIpRange.create(cls.api_client, cls.services["vlan_ip_range"])
-        #Deploy vm in existing subnet if VR is not present
+        # create new vlan ip range
+        # Before creating ip range check the zone's network type
+        if cls.zone.networktype == 'Basic':
+            cls.new_vlan = PublicIpRange.create(cls.api_client, cls.services["vlan_ip_range"])
+        else:
+            raise unittest.SkipTest("These tests can be run only on basic zone. So skipping
the tests")
+        # Deploy vm in existing subnet if VR is not present
         if cls.vr_state is False :
             cls.vm_res = VirtualMachine.create(
                                             cls.api_client,
                                             cls.services["server_without_disk"],
-                                            templateid = cls.template.id,
-                                            accountid = cls.account.name,
-                                            domainid = cls.services["domainid"],
-                                            zoneid = cls.services["zoneid"],
-                                            serviceofferingid = cls.service_offering.id,
-                                            mode = cls.services["mode"],
+                                            templateid=cls.template.id,
+                                            accountid=cls.account.name,
+                                            domainid=cls.services["domainid"],
+                                            zoneid=cls.services["zoneid"],
+                                            serviceofferingid=cls.service_offering.id,
+                                            mode=cls.services["mode"],
                                             )
         cls._cleanup = [
                         cls.new_vlan,
@@ -173,7 +176,10 @@ class TestMultipleIpRanges(cloudstackTestCase):
                 cls.dbclient.execute(
                                      "update user_ip_address set allocated=default where
id = '%s';" % str(id)
                                      )
-            #Cleanup resources used
+            # Wait for expunge interval to cleanup VMs
+            wait_for_cleanup(cls.api_client, ["expunge.delay", "expunge.interval"])
+            time.sleep(30)
+            # Cleanup resources used
             cleanup_resources(cls.api_client, cls._cleanup)
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
@@ -183,18 +189,60 @@ class TestMultipleIpRanges(cloudstackTestCase):
         self.apiclient = self.testClient.getApiClient()
         self.dbclient = self.testClient.getDbConnection()
         self.cleanup = [ ]
+        # Deploy guest vm
+        try :
+            self.virtual_machine = VirtualMachine.create(
+                                            self.apiclient,
+                                            self.services["server_without_disk"],
+                                            templateid=self.template.id,
+                                            accountid=self.account.name,
+                                            domainid=self.services["domainid"],
+                                            zoneid=self.services["zoneid"],
+                                            serviceofferingid=self.service_offering.id,
+                                            mode=self.services["mode"],
+                                            )
+        except Exception as e :
+            raise Exception("Warning: Exception during vm deployment: {}".format(e))
+        self.vm_response = VirtualMachine.list(
+                                               self.apiclient,
+                                               id=self.virtual_machine.id
+                                               )
+        self.assertEqual(
+            isinstance(self.vm_response, list),
+            True,
+            "Check VM list response returned a valid list"
+            )
+        self.ip_range = list(netaddr.iter_iprange(unicode(self.services["vlan_ip_range"]["startip"]),
unicode(self.services["vlan_ip_range"]["endip"])))
+        self.nic_ip = netaddr.IPAddress(unicode(self.vm_response[0].nic[0].ipaddress))
+        self.debug("vm got {} as ip address".format(self.nic_ip))
+        self.assertIn(
+              self.nic_ip,
+              self.ip_range,
+              "VM did not get the ip address from the new ip range"
+              )
+        ip_alias = self.dbclient.execute(
+                              "select ip4_address from nic_ip_alias;"
+                              )
+        self.alias_ip = str(ip_alias[0][0])
+        self.debug("alias ip : %s" % self.alias_ip)
+        self.assertNotEqual(
+                            self.alias_ip,
+                            None,
+                            "Error in creating ip alias. Please check MS logs"
+			    )
+        self.cleanup.append(self.virtual_machine)
         return
 
     def tearDown(self):
         try:
-            #Clean up, terminate the resources created
+            # Clean up, terminate the resources created
             cleanup_resources(self.apiclient, self.cleanup)
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
 
-    def verify_vlan_range(self,vlan,services):
-        #compare vlan_list response with configured values
+    def verify_vlan_range(self, vlan, services):
+        # compare vlan_list response with configured values
         self.assertEqual(
                          isinstance(vlan, list),
                          True,
@@ -233,29 +281,6 @@ class TestMultipleIpRanges(cloudstackTestCase):
             1.Deploy guest vm
             2.Verify vm gets the ip address from new cidr
         """
-        #Deploy guest vm
-        try :
-            self.virtual_machine = VirtualMachine.create(
-                                            self.apiclient,
-                                            self.services["server_without_disk"],
-                                            templateid = self.template.id,
-                                            accountid = self.account.name,
-                                            domainid = self.services["domainid"],
-                                            zoneid = self.services["zoneid"],
-                                            serviceofferingid = self.service_offering.id,
-                                            mode = self.services["mode"],
-                                            )
-        except Exception as e :
-            raise Exception("Warning: Exception during vm deployment: {}".format(e))
-        self.vm_response = VirtualMachine.list(
-                                               self.apiclient,
-                                               id = self.virtual_machine.id
-                                               )
-        self.assertEqual(
-            isinstance(self.vm_response, list),
-            True,
-            "Check VM list response returned a valid list"
-            )
         self.ip_range = list(netaddr.iter_iprange(unicode(self.services["vlan_ip_range"]["startip"]),
unicode(self.services["vlan_ip_range"]["endip"])))
         self.nic_ip = netaddr.IPAddress(unicode(self.vm_response[0].nic[0].ipaddress))
         self.debug("vm got {} as ip address".format(self.nic_ip))
@@ -264,64 +289,14 @@ class TestMultipleIpRanges(cloudstackTestCase):
               self.ip_range,
               "VM did not get the ip address from the new ip range"
               )
-        self.virtual_machine.delete(self.apiclient)
-        expunge_del = Configurations.list(
-                                          self.apiclient,
-                                          name = 'expunge.delay'
-                                         )
-        expunge_int = Configurations.list(
-                                          self.apiclient,
-                                          name = 'expunge.interval'
-                                         )
-        wait_time = int(expunge_del[0].value) + int(expunge_int[0].value) + int(30)
-
-        self.debug("Waiting for {} seconds for the vm to expunge".format(wait_time))
-        #wait for the vm to expunge
-        time.sleep(wait_time)
         return
 
     @attr(tags=["sg"])
-    def test_02_deploy_vm_in_new_cidr(self):
-        """Deploy guest vm in new CIDR and verify
+    def test_02_dns_service_on_alias_ip(self):
+        """Deploy guest vm in new CIDR and verify dns service on alias ip
             1.Deploy guest vm in new cidr
             2.Verify dns service listens on alias ip in VR
         """
-        #Deploy guest vm
-        try :
-            self.virtual_machine = VirtualMachine.create(
-                                            self.apiclient,
-                                            self.services["server_without_disk"],
-                                            templateid = self.template.id,
-                                            accountid = self.account.name,
-                                            domainid = self.services["domainid"],
-                                            zoneid = self.services["zoneid"],
-                                            serviceofferingid = self.service_offering.id,
-                                            mode = self.services["mode"],
-                                            )
-        except Exception as e :
-            raise Exception("Warning: Exception during vm deployment: {}".format(e))
-        self.vm_response = VirtualMachine.list(
-                                               self.apiclient,
-                                               id = self.virtual_machine.id
-                                               )
-        self.assertEqual(
-            isinstance(self.vm_response, list),
-            True,
-            "Check VM list response returned a valid list"
-            )
-        self.ip_range = list(netaddr.iter_iprange(unicode(self.services["vlan_ip_range"]["startip"]),
unicode(self.services["vlan_ip_range"]["endip"])))
-        self.nic_ip = netaddr.IPAddress(unicode(self.vm_response[0].nic[0].ipaddress))
-        self.debug("vm got {} as ip address".format(self.nic_ip))
-        self.assertIn(
-              self.nic_ip,
-              self.ip_range,
-              "VM did not get the ip address from the new ip range"
-              )
-        ip_alias = self.dbclient.execute(
-                              "select ip4_address from nic_ip_alias;"
-                              )
-        alias_ip = str(ip_alias[0][0])
-        self.debug("alias ip : %s" % alias_ip)
         list_router_response = list_routers(
                                     self.apiclient,
                                     zoneid=self.zone.id,
@@ -352,7 +327,7 @@ class TestMultipleIpRanges(cloudstackTestCase):
                             'Running',
                             "Check list router response for router state"
                         )
-        proc = alias_ip+":53"
+        proc = self.alias_ip + ":53"
         result = get_process_status(
                                 host.ipaddress,
                                 self.services['host']["publicport"],
@@ -365,23 +340,9 @@ class TestMultipleIpRanges(cloudstackTestCase):
         self.debug("Dns process status on alias ip: %s" % res)
         self.assertNotEqual(
                          res.find(proc)
-                         -1,
+                         - 1,
                          "dnsmasq service is not running on alias ip"
                         )
-        self.virtual_machine.delete(self.apiclient)
-        expunge_del = Configurations.list(
-                                          self.apiclient,
-                                          name = 'expunge.delay'
-                                         )
-        expunge_int = Configurations.list(
-                                          self.apiclient,
-                                          name = 'expunge.interval'
-                                         )
-        wait_time = int(expunge_del[0].value) + int(expunge_int[0].value) + int(30)
-
-        self.debug("Waiting for {} seconds for the vm to expunge".format(wait_time))
-        #wait for the vm to expunge
-        time.sleep(wait_time)
         return
 
     @attr(tags=["sg"])
@@ -390,42 +351,6 @@ class TestMultipleIpRanges(cloudstackTestCase):
             1.Deploy guest vm in new cidr
             2.Verify password service(socat) listens on alias ip in VR
         """
-        #Deploy guest vm
-        try :
-            self.virtual_machine = VirtualMachine.create(
-                                            self.apiclient,
-                                            self.services["server_without_disk"],
-                                            templateid = self.template.id,
-                                            accountid = self.account.name,
-                                            domainid = self.services["domainid"],
-                                            zoneid = self.services["zoneid"],
-                                            serviceofferingid = self.service_offering.id,
-                                            mode = self.services["mode"],
-                                            )
-        except Exception as e :
-            raise Exception("Warning: Exception during vm deployment: {}".format(e))
-        self.vm_response = VirtualMachine.list(
-                                               self.apiclient,
-                                               id = self.virtual_machine.id
-                                               )
-        self.assertEqual(
-            isinstance(self.vm_response, list),
-            True,
-            "Check VM list response returned a valid list"
-            )
-        self.ip_range = list(netaddr.iter_iprange(unicode(self.services["vlan_ip_range"]["startip"]),
unicode(self.services["vlan_ip_range"]["endip"])))
-        self.nic_ip = netaddr.IPAddress(unicode(self.vm_response[0].nic[0].ipaddress))
-        self.debug("vm got {} as ip address".format(self.nic_ip))
-        self.assertIn(
-              self.nic_ip,
-              self.ip_range,
-              "VM did not get the ip address from the new ip range"
-              )
-        ip_alias = self.dbclient.execute(
-                              "select ip4_address from nic_ip_alias;"
-                              )
-        alias_ip = str(ip_alias[0][0])
-        self.debug("alias ip : %s" % alias_ip)
         list_router_response = list_routers(
                                     self.apiclient,
                                     zoneid=self.zone.id,
@@ -468,24 +393,10 @@ class TestMultipleIpRanges(cloudstackTestCase):
         res = str(result)
         self.debug("password process status on VR: %s" % res)
         self.assertNotEqual(
-                         res.find(alias_ip)
-                         -1,
+                         res.find(self.alias_ip)
+                         - 1,
                          "password service is not running on alias ip"
                         )
-        self.virtual_machine.delete(self.apiclient)
-        expunge_del = Configurations.list(
-                                          self.apiclient,
-                                          name = 'expunge.delay'
-                                         )
-        expunge_int = Configurations.list(
-                                          self.apiclient,
-                                          name = 'expunge.interval'
-                                         )
-        wait_time = int(expunge_del[0].value) + int(expunge_int[0].value) + int(30)
-
-        self.debug("Waiting for {} seconds for the vm to expunge".format(wait_time))
-        #wait for the vm to expunge
-        time.sleep(wait_time)
         return
 
     @attr(tags=["sg"])
@@ -494,42 +405,6 @@ class TestMultipleIpRanges(cloudstackTestCase):
             1.Deploy guest vm in new cidr
             2.Verify userdata service(apache2) listens on alias ip in VR
         """
-        #Deploy guest vm
-        try :
-            self.virtual_machine = VirtualMachine.create(
-                                            self.apiclient,
-                                            self.services["server_without_disk"],
-                                            templateid = self.template.id,
-                                            accountid = self.account.name,
-                                            domainid = self.services["domainid"],
-                                            zoneid = self.services["zoneid"],
-                                            serviceofferingid = self.service_offering.id,
-                                            mode = self.services["mode"],
-                                            )
-        except Exception as e :
-            raise Exception("Warning: Exception during vm deployment: {}".format(e))
-        self.vm_response = VirtualMachine.list(
-                                               self.apiclient,
-                                               id = self.virtual_machine.id
-                                               )
-        self.assertEqual(
-            isinstance(self.vm_response, list),
-            True,
-            "Check VM list response returned a valid list"
-            )
-        self.ip_range = list(netaddr.iter_iprange(unicode(self.services["vlan_ip_range"]["startip"]),
unicode(self.services["vlan_ip_range"]["endip"])))
-        self.nic_ip = netaddr.IPAddress(unicode(self.vm_response[0].nic[0].ipaddress))
-        self.debug("vm got {} as ip address".format(self.nic_ip))
-        self.assertIn(
-              self.nic_ip,
-              self.ip_range,
-              "VM did not get the ip address from the new ip range"
-              )
-        ip_alias = self.dbclient.execute(
-                              "select ip4_address from nic_ip_alias;"
-                              )
-        alias_ip = str(ip_alias[0][0])
-        self.debug("alias ip : %s" % alias_ip)
         list_router_response = list_routers(
                                     self.apiclient,
                                     zoneid=self.zone.id,
@@ -572,22 +447,296 @@ class TestMultipleIpRanges(cloudstackTestCase):
         res = str(result)
         self.debug("userdata process status on VR: %s" % res)
         self.assertNotEqual(
-                         res.find(alias_ip+":80 ")
-                         -1,
+                         res.find(self.alias_ip + ":80 ")
+                         - 1,
                          "password service is not running on alias ip"
                         )
+        return
+
+    @attr(tags=["sg"])
+    def test_05_del_cidr_verify_alias_removal(self):
+        """Destroy lastvm in the CIDR and verifly alias removal
+            1.Deploy guest vm in new cidr
+            2.Verify ip alias creation
+            3.Destroy vm and wait for it to expunge
+            4.Verify ip alias removal after vm expunge
+        """
+        list_router_response = list_routers(
+                                    self.apiclient,
+                                    zoneid=self.zone.id,
+                                    listall=True
+                                    )
+        self.assertEqual(
+                            isinstance(list_router_response, list),
+                            True,
+                            "Check list response returns a valid list"
+                        )
+        router = list_router_response[0]
+        hosts = list_hosts(
+                           self.apiclient,
+                           zoneid=router.zoneid,
+                           type='Routing',
+                           state='Up',
+                           id=router.hostid
+                           )
+        self.assertEqual(
+                            isinstance(hosts, list),
+                            True,
+                            "Check list host returns a valid list"
+                        )
+        host = hosts[0]
+        self.debug("Router ID: %s, state: %s" % (router.id, router.state))
+        self.assertEqual(
+                            router.state,
+                            'Running',
+                            "Check list router response for router state"
+                        )
+        proc = "ip addr show eth0"
+        result = get_process_status(
+                                host.ipaddress,
+                                self.services['host']["publicport"],
+                                self.services['host']["username"],
+                                self.services['host']["password"],
+                                router.linklocalip,
+                                proc
+                                )
+        res = str(result)
+        self.debug("ip alias configuration on VR: %s" % res)
+        self.assertNotEqual(
+                         res.find(self.alias_ip)
+                         - 1,
+                         "ip alias is not created on VR eth0"
+                        )
         self.virtual_machine.delete(self.apiclient)
         expunge_del = Configurations.list(
                                           self.apiclient,
-                                          name = 'expunge.delay'
+                                          name='expunge.delay'
                                          )
         expunge_int = Configurations.list(
                                           self.apiclient,
-                                          name = 'expunge.interval'
+                                          name='expunge.interval'
                                          )
         wait_time = int(expunge_del[0].value) + int(expunge_int[0].value) + int(30)
-
         self.debug("Waiting for {} seconds for the vm to expunge".format(wait_time))
-        #wait for the vm to expunge
+        # wait for the vm to expunge
         time.sleep(wait_time)
+        self.debug("Verify that expunging the last vm in the CIDR should delete the ip alias
from VR")
+        ip_alias2 = self.dbclient.execute(
+                              "select ip4_address from nic_ip_alias;"
+                              )
+        self.assertEqual(
+                         isinstance(ip_alias2, list),
+                         True,
+                         "Error in sql query"
+                         )
+        self.assertEqual(
+                         len(ip_alias2),
+                         0,
+                         "Failure in clearing ip alias entry from cloud db"
+			)
+        proc = "ip addr show eth0"
+        result = get_process_status(
+                                host.ipaddress,
+                                self.services['host']["publicport"],
+                                self.services['host']["username"],
+                                self.services['host']["password"],
+                                router.linklocalip,
+                                proc
+                                )
+        res = str(result)
+        self.assertEqual(
+                         res.find(self.alias_ip),
+                         - 1,
+                         "Failed to clean up ip alias from VR even after last vm expunge
in the CIDR"
+                         )
+        self.debug("IP alias got deleted from VR successfully.")
+        self.cleanup.remove(self.virtual_machine)
+        return
+
+    @attr(tags=["sg"])
+    def test_06_reboot_VR_verify_ip_alias(self):
+        """Reboot VR and verify ip alias
+            1.Deploy guest vm in new cidr
+            2.Verify ip alias creation
+            3.Reboot VR
+            4.Verify ip alias on VR
+        """
+        list_router_response = list_routers(
+                                    self.apiclient,
+                                    zoneid=self.zone.id,
+                                    listall=True
+                                    )
+        self.assertEqual(
+                            isinstance(list_router_response, list),
+                            True,
+                            "Check list response returns a valid list"
+                        )
+        router = list_router_response[0]
+        hosts = list_hosts(
+                           self.apiclient,
+                           zoneid=router.zoneid,
+                           type='Routing',
+                           state='Up',
+                           id=router.hostid
+                           )
+        self.assertEqual(
+                            isinstance(hosts, list),
+                            True,
+                            "Check list host returns a valid list"
+                        )
+        host = hosts[0]
+        self.debug("Router ID: %s, state: %s" % (router.id, router.state))
+        self.assertEqual(
+                            router.state,
+                            'Running',
+                            "Check list router response for router state"
+                        )
+        proc = "ip addr show eth0"
+        result = get_process_status(
+                                host.ipaddress,
+                                self.services['host']["publicport"],
+                                self.services['host']["username"],
+                                self.services['host']["password"],
+                                router.linklocalip,
+                                proc
+                                )
+        res = str(result)
+        self.debug("ip alias configuration on VR: %s" % res)
+        self.assertNotEqual(
+                         res.find(self.alias_ip)
+                         - 1,
+                         "ip alias is not created on VR eth0"
+                        )
+        resp = Router.reboot(
+                             self.apiclient,
+                             router.id
+                             )
+        self.debug("Reboot router api response: %s" % resp)
+        list_router_response = list_routers(
+                                            self.apiclient,
+                                            zoneid=self.zone.id,
+                                            listall=True
+                                            )
+        self.assertEqual(
+                            isinstance(list_router_response, list),
+                            True,
+                            "Check list response returns a valid list"
+                        )
+        router = list_router_response[0]
+        self.assertEqual(
+                            router.state,
+                            'Running',
+                            "Router is not in running state after reboot"
+                        )
+        result = get_process_status(
+                                host.ipaddress,
+                                self.services['host']["publicport"],
+                                self.services['host']["username"],
+                                self.services['host']["password"],
+                                router.linklocalip,
+                                proc
+                                )
+        res = str(result)
+        self.assertNotEqual(
+                         res.find(self.alias_ip),
+                         - 1,
+                         "IP alias not present on VR after VR reboot"
+                         )
+        return
+
+    @attr(tags=["sg"])
+    def test_07_stop_start_VR_verify_ip_alias(self):
+        """Reboot VR and verify ip alias
+            1.Deploy guest vm in new cidr
+            2.Verify ip alias creation
+            3.Stop and Start VR
+            4.Verify ip alias on VR
+        """
+        list_router_response = list_routers(
+                                    self.apiclient,
+                                    zoneid=self.zone.id,
+                                    listall=True
+                                    )
+        self.assertEqual(
+                            isinstance(list_router_response, list),
+                            True,
+                            "Check list response returns a valid list"
+                        )
+        router = list_router_response[0]
+        hosts = list_hosts(
+                           self.apiclient,
+                           zoneid=router.zoneid,
+                           type='Routing',
+                           state='Up',
+                           id=router.hostid
+                           )
+        self.assertEqual(
+                            isinstance(hosts, list),
+                            True,
+                            "Check list host returns a valid list"
+                        )
+        host = hosts[0]
+        self.debug("Router ID: %s, state: %s" % (router.id, router.state))
+        self.assertEqual(
+                            router.state,
+                            'Running',
+                            "Check list router response for router state"
+                        )
+        proc = "ip addr show eth0"
+        result = get_process_status(
+                                host.ipaddress,
+                                self.services['host']["publicport"],
+                                self.services['host']["username"],
+                                self.services['host']["password"],
+                                router.linklocalip,
+                                proc
+                                )
+        res = str(result)
+        self.debug("ip alias configuration on VR: %s" % res)
+        self.assertNotEqual(
+                         res.find(self.alias_ip)
+                         - 1,
+                         "ip alias is not created on VR eth0"
+                        )
+        self.debug("Stopping VR")
+        stop_res = Router.stop(
+                           self.apiclient,
+                           router.id,
+                           )
+        self.debug("Starting VR")
+        start_res = Router.start(
+                                 self.apiclient,
+                                 router.id
+                                 )
+        list_router_response = list_routers(
+                                            self.apiclient,
+                                            zoneid=self.zone.id,
+                                            listall=True
+                                            )
+        self.assertEqual(
+                            isinstance(list_router_response, list),
+                            True,
+                            "Check list response returns a valid list"
+                        )
+        router = list_router_response[0]
+        self.assertEqual(
+                            router.state,
+                            'Running',
+                            "Router is not in running state after reboot"
+                        )
+        self.debug("VR is up and Running")
+        result = get_process_status(
+                                host.ipaddress,
+                                self.services['host']["publicport"],
+                                self.services['host']["username"],
+                                self.services['host']["password"],
+                                router.linklocalip,
+                                proc
+                                )
+        res = str(result)
+        self.assertNotEqual(
+                         res.find(self.alias_ip),
+                         - 1,
+                         "IP alias not present on VR after VR stop and start"
+                         )
         return


Mime
View raw message