CLOUDSTACK-9287 - Improve test by checking if pvt gw is removed and f…

…ix typos

test/integration/smoke/test_privategw_acl.py

@@ -195,7 +195,8 @@ def tearDownClass(cls):
 
  def setUp(self):
  self.apiclient = self.testClient.getApiClient()
-
+ self.hypervisor = self.testClient.getHypervisorInfo()
+
  self.logger.debug("Creating Admin Account for Domain ID ==> %s" % self.domain.id)
  self.account = Account.create(
  self.apiclient,
@@ -285,7 +286,7 @@ def test_04_rvpc_privategw_static_routes(self):
  self.performVPCTests(vpc_off)
 
  @attr(tags=["advanced"], required_hardware="true")
- def test_05_rvpc_privategw_check_interface(self):
+ def _test_05_rvpc_privategw_check_interface(self):
  self.logger.debug("Creating a Redundant VPC offering..")
  vpc_off = VpcOffering.create(
  self.apiclient,
@@ -344,8 +345,8 @@ def performVPCTests(self, vpc_off, restart_with_cleanup = False):
  self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm1.nic[0].ipaddress])
 
  if restart_with_cleanup:
- self.reboot_vpc_with_cleanup(vpc_1, True)
- self.reboot_vpc_with_cleanup(vpc_2, True)
+ self.reboot_vpc_with_cleanup(vpc_1, cleanup = restart_with_cleanup)
+ self.reboot_vpc_with_cleanup(vpc_2, cleanup = restart_with_cleanup)
 
  self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm1.nic[0].ipaddress])
 
@@ -391,45 +392,54 @@ def performPrivateGWInterfaceTests(self, vpc_off):
 
  public_ip_1 = self.acquire_publicip(vpc_1, network_1)
  nat_rule_1 = self.create_natrule(vpc_1, vm1, public_ip_1, network_1)
+
+ self.check_private_gateway_interfaces()
 
- routers = list_routers(self.apiclient,
- account=self.account.name,
- domainid=self.account.domainid)
+ self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm3.nic[0].ipaddress, vm4.nic[0].ipaddress])
 
- self.assertEqual(isinstance(routers, list), True,
-  "Check for list routers response return valid data")
+ self.reboot_vpc_with_cleanup(vpc_1, cleanup = True)
+ self.check_routers_state()
 
- self.assertEqual(len(routers), 2,
- "Check for list routers size returned '%s' instead of 2" % len(routers))
+ self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm3.nic[0].ipaddress, vm4.nic[0].ipaddress])
 
- self.check_private_gateway_interfaces(routers)
+ self.stop_router_by_type("MASTER")
+ self.check_routers_state()
 
+ self.check_private_gateway_interfaces()
  self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm3.nic[0].ipaddress, vm4.nic[0].ipaddress])
 
- self.reboot_vpc_with_cleanup(vpc_1, True)
-
+ self.start_routers()
+ self.check_routers_state()
+ self.check_private_gateway_interfaces()
  self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm3.nic[0].ipaddress, vm4.nic[0].ipaddress])
 
- self.stop_router_by_type(routers, status_to_check = "MASTER")
- self.check_routers_state(routers)
+ self.deletePvtGw(privateGw_1.id)
+ self.check_private_gateway_interfaces(status_to_check = "DOWN")
 
- self.check_private_gateway_interfaces(routers)
- self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm3.nic[0].ipaddress, vm4.nic[0].ipaddress])
+ def query_routers(self):
+ routers = list_routers(self.apiclient,
+ account=self.account.name,
+ domainid=self.account.domainid)
 
- self.start_routers(routers)
- self.check_routers_state(routers)
- self.check_private_gateway_interfaces(routers)
- self.check_pvt_gw_connectivity(vm1, public_ip_1, [vm2.nic[0].ipaddress, vm3.nic[0].ipaddress, vm4.nic[0].ipaddress])
+ self.assertEqual(isinstance(routers, list), True,
+ "Check for list routers response return valid data")
+
+ self.assertEqual(len(routers), 2,
+ "Check for list routers size returned '%s' instead of 2" % len(routers))
+
+ return routers
 
- def stop_router_by_type(self, type, routers):
- self.logger.debug('Stopping %s router' % type)
+ def stop_router_by_type(self, redundant_state):
+ self.logger.debug('Stopping %s router' % redundant_state)
+ routers = self.query_routers()
  for router in routers:
- if router.redundantstate == type:
+ if router.redundantstate == redundant_state:
  self.stop_router(router)
  break
 
- def start_routers(self, routers):
+ def start_routers(self):
  self.logger.debug('Starting stopped routers')
+ routers = self.query_routers()
  for router in routers:
  self.logger.debug('Router %s has state %s' % (router.id, router.state))
  if router.state == "Stopped":
@@ -438,6 +448,12 @@ def start_routers(self, routers):
  cmd.id = router.id
  self.apiclient.startRouter(cmd)
 
+ def stop_router(self, router):
+ self.logger.debug('Stopping router %s' % router.id)
+ cmd = stopRouter.stopRouterCmd()
+ cmd.id = router.id
+ self.apiclient.stopRouter(cmd)
+
  def createVPC(self, vpc_offering, cidr = '10.1.1.1/16'):
  try:
  self.logger.debug("Creating a VPC network in the account: %s" % self.account.name)
@@ -574,14 +590,27 @@ def createPvtGw(self, vpc, ip_address, gateway, aclId, vlan):
  createPrivateGatewayCmd.aclid = aclId
 
  try:
- privateGw =  self.apiclient.createPrivateGateway(createPrivateGatewayCmd)
+ privateGw = self.apiclient.createPrivateGateway(createPrivateGatewayCmd)
  except Exception as e:
  self.fail("Failed to create Private Gateway ==> %s" % e)
 
- self.assertIsNotNone(privateGw.id, "Failed to create ACL.")
+ self.assertIsNotNone(privateGw.id, "Failed to create Private Gateway.")
 
  return privateGw
 
+ def deletePvtGw(self, private_gw_id):
+ deletePrivateGatewayCmd = deletePrivateGateway.deletePrivateGatewayCmd()
+ deletePrivateGatewayCmd.id = private_gw_id
+
+ privateGwResponse = None
+ try:
+ privateGwResponse = self.apiclient.deletePrivateGateway(deletePrivateGatewayCmd)
+ except Exception as e:
+ self.fail("Failed to create Private Gateway ==> %s" % e)
+
+ self.assertIsNotNone(privateGwResponse, "Failed to Delete Private Gateway.")
+ self.assertTrue(privateGwResponse.success, "Failed to Delete Private Gateway.")
+
  def replaceNetworkAcl(self, aclId, network):
  self.logger.debug("Replacing Network ACL with ACL ID ==> %s" % aclId)
 
@@ -642,6 +671,9 @@ def create_natrule(self, vpc, virtual_machine, public_ip, network):
  return nat_rule
 
  def check_pvt_gw_connectivity(self, virtual_machine, public_ip, vms_ips):
+ sleep_time = 5
+ succeeded_pings = 0
+ minimum_vms_to_pass = 2
  for vm_ip in vms_ips:
  ssh_command = "ping -c 3 %s" % vm_ip
 
@@ -652,22 +684,25 @@ def check_pvt_gw_connectivity(self, virtual_machine, public_ip, vms_ips):
 
  ssh = virtual_machine.get_ssh_client(ipaddress=public_ip.ipaddress.ipaddress)
 
+ self.logger.debug("Sleeping for %s seconds in order to get the firewall applied..." % sleep_time)
+ time.sleep(sleep_time)
+ sleep_time += sleep_time
+
  self.logger.debug("Ping to VM inside another Network Tier")
  result = str(ssh.execute(ssh_command))
 
  self.logger.debug("SSH result: %s; COUNT is ==> %s" % (result, result.count("3 packets received")))
  except Exception as e:
  self.fail("SSH Access failed for %s: %s" % \
- (vmObj.get_ip(), e)
+ (virtual_machine, e)
  )
 
- self.assertEqual(
- result.count("3 packets received"),
- 1,
- "Ping to VM on Network Tier N from VM in Network Tier A should be successful"
- )
+ succeeded_pings += result.count("3 packets received")
+
 
- time.sleep(5)
+ self.assertTrue(succeeded_pings >= minimum_vms_to_pass,
+ "Ping to VM on Network Tier N from VM in Network Tier A should be successful at least for 2 out of 3 VMs"
+ )
 
  def reboot_vpc_with_cleanup(self, vpc, cleanup = True):
  self.logger.debug("Restarting VPC %s with cleanup" % vpc.id)
@@ -679,13 +714,20 @@ def reboot_vpc_with_cleanup(self, vpc, cleanup = True):
  cmd.makeredundant = False
  self.api_client.restartVPC(cmd)
 
- def check_private_gateway_interfaces(self, routers):
+ def check_private_gateway_interfaces(self, status_to_check = "UP"):
+ routers = self.query_routers()
+
  state_holder = {routers[0].linklocalip : {"state" : None, "mac" : None},
  routers[1].linklocalip : {"state" : None, "mac" : None}}
  state = None
  mac = None
  for router in routers:
- hosts = list_hosts(self.apiclient, id=router.hostid)
+ hosts = list_hosts(
+ self.apiclient,
+ zoneid=router.zoneid,
+ type='Routing',
+ state='Up',
+ id=router.hostid)
 
  self.assertEqual(
  isinstance(hosts, list),
@@ -716,17 +758,26 @@ def check_private_gateway_interfaces(self, routers):
  except KeyError:
  self.skipTest("Provide a marvin config file with host credentials to run %s" % self._testMethodName)
 
+ state = str(state[0])
+ mac = str(mac[0])
+
  self.logger.debug("Result from the Router on IP '%s' is -> state: '%s', mac: '%s'" % (router.linklocalip, state, mac))
  state_holder[router.linklocalip]["state"] = str(state)
  state_holder[router.linklocalip]["mac"] = str(mac)
 
- check_state = state_holder[routers[0].linklocalip]["state"].count(state_holder[routers[1].linklocalip]["state"])
- check_mac = state_holder[routers[0].linklocalip]["mac"].count(state_holder[routers[1].linklocalip]["mac"])
 
- self.assertTrue(check_state == 0, "Routers private gateway interface should not be on the same state!")
- self.assertTrue(check_mac == 0, "Routers private gateway interface should not have the same mac address!")
+ if status_to_check == "UP":
+ check_state = state_holder[routers[0].linklocalip]["state"].count(state_holder[routers[1].linklocalip]["state"])
+ check_mac = state_holder[routers[0].linklocalip]["mac"].count(state_holder[routers[1].linklocalip]["mac"])
+
+ self.assertTrue(check_state == 0, "Routers private gateway interface should not be on the same state!")
+ self.assertTrue(check_mac == 0, "Routers private gateway interface should not have the same mac address!")
+ else:
+ self.assertTrue(check_state == 1, "Routers private gateway interface should should have been removed!")
+
+ def check_routers_state(self, status_to_check="MASTER", expected_count=1):
+ routers = self.query_routers()
 
- def check_routers_state(self, routers, status_to_check="MASTER", expected_count=1):
  vals = ["MASTER", "BACKUP", "UNKNOWN"]
  cnts = [0, 0, 0]