def test_delete_account(self):
"""Test for delete account"""
# Validate the Following
# 1. after account.cleanup.interval (global setting)
# time all the PF/LB rules should be deleted
# 2. verify that list(LoadBalancer/PortForwarding)Rules
# API does not return any rules for the account
# 3. The domR should have been expunged for this account
self.account.delete(self.apiclient)
interval = list_configurations(self.apiclient,
name='account.cleanup.interval')
self.assertEqual(isinstance(interval, list), True,
"Check if account.cleanup.interval config present")
# Sleep to ensure that all resources are deleted
time.sleep(int(interval[0].value))
# ListLoadBalancerRules should not list
# associated rules with deleted account
# Unable to find account testuser1 in domain 1 : Exception
try:
list_lb_rules(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
except CloudstackAPIException:
self.debug("Port Forwarding Rule is deleted")
# ListPortForwardingRules should not
# list associated rules with deleted account
try:
list_nat_rules(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
except CloudstackAPIException:
self.debug("NATRule is deleted")
# Retrieve router for the user account
try:
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(routers, None,
"Check routers are properly deleted.")
except CloudstackAPIException:
self.debug("Router is deleted")
except Exception as e:
raise Exception(
"Encountered %s raised while fetching routers for account: %s"
% (e, self.account.name))
return
def create_lb_rule(self, ipaddr, vpcid, networkid, vms):
""" Create Loadbalancer rule
:param ipaddr: IP Address uuid to create LB rule on
:param vpcid: VPC uuid where to create LB rule
:param networkid: Network uuid
:param vms: List of VM's
:return: loadbalancer rule, loadbalancer rules
"""
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(self.apiclient,
self.services["lbrule"],
ipaddr,
accountid=self.account.name,
vpcid=vpcid,
networkid=networkid)
self.cleanup.append(lb_rule)
lb_rule.assign(self.apiclient, vms)
lb_rules = list_lb_rules(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_rules, list), True,
"Check list response returns a valid list")
# verify listLoadBalancerRules lists the added load balancing rule
self.assertNotEqual(len(lb_rules), 0,
"Check Load Balancer Rule in its List")
self.assertEqual(lb_rules[0].id, lb_rule.id,
"Check List Load Balancer Rules returns valid Rule")
return lb_rule
def test_releaseIP(self):
"""Test for release public IP address"""
self.debug("Deleting Public IP : %s" % self.ip_addr.id)
self.ip_address.delete(self.apiclient)
retriesCount = 10
isIpAddressDisassociated = False
while retriesCount > 0:
listResponse = list_publicIP(
self.apiclient,
id=self.ip_addr.id
)
if listResponse is None:
isIpAddressDisassociated = True
break
retriesCount -= 1
time.sleep(60)
# End while
self.assertTrue(
isIpAddressDisassociated,
"Failed to disassociate IP address")
# ListPortForwardingRules should not list
# associated rules with Public IP address
try:
list_nat_rule = list_nat_rules(
self.apiclient,
id=self.nat_rule.id
)
self.debug("List NAT Rule response" + str(list_nat_rule))
except CloudstackAPIException:
self.debug("Port Forwarding Rule is deleted")
# listLoadBalancerRules should not list
# associated rules with Public IP address
try:
list_lb_rule = list_lb_rules(
self.apiclient,
id=self.lb_rule.id
)
self.debug("List LB Rule response" + str(list_lb_rule))
except CloudstackAPIException:
self.debug("Port Forwarding Rule is deleted")
# SSH Attempt though public IP should fail
with self.assertRaises(Exception):
SshClient(
self.ip_addr.ipaddress,
self.services["natrule"]["publicport"],
self.virtual_machine.username,
self.virtual_machine.password,
retries=2,
delay=0
)
return
def test_releaseIP(self):
"""Test for release public IP address"""
logger.debug("Deleting Public IP : %s" % self.ip_addr.id)
self.ip_address.delete(self.apiclient)
retriesCount = 10
isIpAddressDisassociated = False
while retriesCount > 0:
listResponse = list_publicIP(
self.apiclient,
id=self.ip_addr.id
)
if listResponse is None:
isIpAddressDisassociated = True
break
retriesCount -= 1
time.sleep(60)
# End while
self.assertTrue(
isIpAddressDisassociated,
"Failed to disassociate IP address")
# ListPortForwardingRules should not list
# associated rules with Public IP address
try:
list_nat_rule = list_nat_rules(
self.apiclient,
id=self.nat_rule.id
)
logger.debug("List NAT Rule response" + str(list_nat_rule))
except CloudstackAPIException:
logger.debug("Port Forwarding Rule is deleted")
# listLoadBalancerRules should not list
# associated rules with Public IP address
try:
list_lb_rule = list_lb_rules(
self.apiclient,
id=self.lb_rule.id
)
logger.debug("List LB Rule response" + str(list_lb_rule))
except CloudstackAPIException:
logger.debug("Port Forwarding Rule is deleted")
# SSH Attempt though public IP should fail
with self.assertRaises(Exception):
SshClient(
self.ip_addr.ipaddress,
self.services["natrule"]["publicport"],
self.virtual_machine.username,
self.virtual_machine.password,
retries=2,
delay=0
)
return
def test_01_RouterStopCreateLB(self):
"""Test router stop create Load balancing
"""
# validate the following
# 1. listLoadBalancerRules (publicipid=ipaddressid of source NAT)
# 2. rule should be for port 22 as applied and
# should be in state=Active
# 3. ssh access should be allowed to the userVMs over the source NAT IP
# and port 22
# Get router details associated for that account
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
self.assertNotEqual(len(routers), 0, "Check list router response")
router = routers[0]
self.debug("Stopping router with ID: %s" % router.id)
# Stop the router
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
self.apiclient.stopRouter(cmd)
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
router = routers[0]
self.assertEqual(router.state, 'Stopped',
"Check list router response for router state")
public_ips = list_publicIP(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(
isinstance(public_ips, list), True,
"Check for list public IPs response return valid data")
public_ip = public_ips[0]
# Open up firewall port for SSH
FireWallRule.create(self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["lbrule"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["lbrule"]["publicport"],
endport=self.services["lbrule"]["publicport"])
self.debug("Creating LB rule for public IP: %s" % public_ip.id)
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(self.apiclient,
self.services["lbrule"],
public_ip.id,
accountid=self.account.name)
self.debug("Assigning VM %s to LB rule: %s" %
(self.vm_1.id, lb_rule.id))
lb_rule.assign(self.apiclient, [self.vm_1])
# Start the router
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.apiclient.startRouter(cmd)
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
router = routers[0]
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
# After router start, LB RUle should be in Active state
lb_rules = list_lb_rules(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_rules, list), True,
"Check for list LB rules response return valid data")
self.assertEqual(lb_rules[0].state, 'Active',
"Check list load balancing rules")
self.assertEqual(lb_rules[0].publicport,
str(self.services["lbrule"]["publicport"]),
"Check list load balancing rules")
try:
self.debug("SSH into VM with IP: %s" % public_ip.ipaddress)
self.vm_1.ssh_port = self.services["lbrule"]["publicport"]
self.vm_1.get_ssh_client(public_ip.ipaddress)
except Exception as e:
self.fail("SSH Access failed for %s: %s" %
(self.vm_1.ipaddress, e))
return
def test_delete_account(self):
"""Test for delete account"""
# Validate the Following
# 1. after account.cleanup.interval (global setting)
# time all the PF/LB rules should be deleted
# 2. verify that list(LoadBalancer/PortForwarding)Rules
# API does not return any rules for the account
# 3. The domR should have been expunged for this account
self.account.delete(self.apiclient)
interval = list_configurations(
self.apiclient,
name='account.cleanup.interval'
)
self.assertEqual(
isinstance(interval, list),
True,
"Check if account.cleanup.interval config present"
)
# Sleep to ensure that all resources are deleted
time.sleep(int(interval[0].value))
# ListLoadBalancerRules should not list
# associated rules with deleted account
# Unable to find account testuser1 in domain 1 : Exception
try:
list_lb_rules(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
except CloudstackAPIException:
self.debug("Port Forwarding Rule is deleted")
# ListPortForwardingRules should not
# list associated rules with deleted account
try:
list_nat_rules(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
except CloudstackAPIException:
self.debug("NATRule is deleted")
# Retrieve router for the user account
try:
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
routers,
None,
"Check routers are properly deleted."
)
except CloudstackAPIException:
self.debug("Router is deleted")
except Exception as e:
raise Exception(
"Encountered %s raised while fetching routers for account: %s" %
(e, self.account.name))
return
def test_02_create_lb_rule_non_nat(self):
"""Test to create Load balancing rule with non source NAT"""
# Validate the Following:
# 1. listLoadBalancerRules should return the added rule
# 2. attempt to ssh twice on the load balanced IP
# 3. verify using the UNAME of the VM that
# round robin is indeed happening as expected
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(
self.apiclient,
self.services["lbrule"],
self.non_src_nat_ip.ipaddress.id,
accountid=self.account.name,
vpcid=self.vpc1.id,
networkid=self.network1.id
)
self.cleanup.append(lb_rule)
lb_rule.assign(self.apiclient, [self.vm_1, self.vm_2])
lb_rules = list_lb_rules(
self.apiclient,
id=lb_rule.id
)
self.assertEqual(
isinstance(lb_rules, list),
True,
"Check list response returns a valid list"
)
# verify listLoadBalancerRules lists the added load balancing rule
self.assertNotEqual(
len(lb_rules),
0,
"Check Load Balancer Rule in its List"
)
self.assertEqual(
lb_rules[0].id,
lb_rule.id,
"Check List Load Balancer Rules returns valid Rule"
)
# listLoadBalancerRuleInstances should list
# all instances associated with that LB rule
lb_instance_rules = list_lb_instances(
self.apiclient,
id=lb_rule.id
)
self.assertEqual(
isinstance(lb_instance_rules, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(lb_instance_rules),
0,
"Check Load Balancer instances Rule in its List"
)
self.assertIn(
lb_instance_rules[0].id,
[self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID"
)
self.assertIn(
lb_instance_rules[1].id,
[self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID"
)
try:
unameResults = []
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.logger.debug("UNAME: %s" % str(unameResults))
self.assertIn(
"Linux",
unameResults,
"Check if ssh succeeded for server1"
)
self.assertIn(
"Linux",
unameResults,
"Check if ssh succeeded for server2"
)
# SSH should pass till there is a last VM associated with LB rule
lb_rule.remove(self.apiclient, [self.vm_2])
self.logger.debug("SSHing into IP address: %s after removing VM (ID: %s) from LB rule" %
(
self.non_src_nat_ip.ipaddress.ipaddress,
self.vm_2.id
))
# Making host list empty
unameResults[:] = []
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.assertIn(
"Linux",
unameResults,
"Check if ssh succeeded for server1"
)
self.logger.debug("UNAME after removing VM2: %s" % str(unameResults))
except Exception as e:
self.fail("%s: SSH failed for VM with IP Address: %s" %
(e, self.non_src_nat_ip.ipaddress.ipaddress))
lb_rule.remove(self.apiclient, [self.vm_1])
with self.assertRaises(Exception):
self.logger.debug("SSHing into IP address: %s after removing VM (ID: %s) from LB rule" %
(
self.non_src_nat_ip.ipaddress.ipaddress,
self.vm_1.id
))
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
return
def test_01_create_lb_rule_src_nat(self):
"""Test to create Load balancing rule with source NAT"""
# Validate the Following:
# 1. listLoadBalancerRules should return the added rule
# 2. attempt to ssh twice on the load balanced IP
# 3. verify using the UNAME of the VM
# that round robin is indeed happening as expected
src_nat_ip_addrs = PublicIPAddress.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(src_nat_ip_addrs, list),
True,
"Check list response returns a valid list"
)
src_nat_ip_addr = src_nat_ip_addrs[0]
# Check if VM is in Running state before creating LB rule
vm_response = VirtualMachine.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(vm_response, list),
True,
"Check list VM returns a valid list"
)
self.assertNotEqual(
len(vm_response),
0,
"Check Port Forwarding Rule is created"
)
for vm in vm_response:
self.assertEqual(
vm.state,
'Running',
"VM state should be Running before creating a NAT rule."
)
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(
self.apiclient,
self.services["lbrule"],
src_nat_ip_addr.id,
accountid=self.account.name,
vpcid=self.vpc1.id,
networkid=self.network1.id
)
self.cleanup.append(lb_rule)
lb_rule.assign(self.apiclient, [self.vm_1, self.vm_2])
lb_rules = list_lb_rules(
self.apiclient,
id=lb_rule.id
)
self.assertEqual(
isinstance(lb_rules, list),
True,
"Check list response returns a valid list"
)
# verify listLoadBalancerRules lists the added load balancing rule
self.assertNotEqual(
len(lb_rules),
0,
"Check Load Balancer Rule in its List"
)
self.assertEqual(
lb_rules[0].id,
lb_rule.id,
"Check List Load Balancer Rules returns valid Rule"
)
# listLoadBalancerRuleInstances should list all
# instances associated with that LB rule
lb_instance_rules = list_lb_instances(
self.apiclient,
id=lb_rule.id
)
self.assertEqual(
isinstance(lb_instance_rules, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(lb_instance_rules),
0,
"Check Load Balancer instances Rule in its List"
)
self.logger.debug("lb_instance_rules Ids: %s, %s" % (
lb_instance_rules[0].id,
lb_instance_rules[1].id
))
self.logger.debug("VM ids: %s, %s" % (self.vm_1.id, self.vm_2.id))
self.assertIn(
lb_instance_rules[0].id,
[self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID"
)
self.assertIn(
lb_instance_rules[1].id,
[self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID"
)
unameResults = []
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.logger.debug("UNAME: %s" % str(unameResults))
self.assertIn(
"Linux",
unameResults,
"Check if ssh succeeded for server1"
)
self.assertIn(
"Linux",
unameResults,
"Check if ssh succeeded for server2"
)
# SSH should pass till there is a last VM associated with LB rule
lb_rule.remove(self.apiclient, [self.vm_2])
# making unameResultss list empty
unameResults[:] = []
try:
self.logger.debug("SSHing into IP address: %s after removing VM (ID: %s)" %
(
src_nat_ip_addr.ipaddress,
self.vm_2.id
))
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.assertIn(
"Linux",
unameResults,
"Check if ssh succeeded for server1"
)
except Exception as e:
self.fail("%s: SSH failed for VM with IP Address: %s" %
(e, src_nat_ip_addr.ipaddress))
lb_rule.remove(self.apiclient, [self.vm_1])
with self.assertRaises(Exception):
self.logger.debug("Removed all VMs, trying to SSH")
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
return
def test_01_RouterStopCreateLB(self):
"""Test router stop create Load balancing
"""
# validate the following
# 1. listLoadBalancerRules (publicipid=ipaddressid of source NAT)
# 2. rule should be for port 22 as applied and
# should be in state=Active
# 3. ssh access should be allowed to the userVMs over the source NAT IP
# and port 22
# Get router details associated for that account
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
self.assertNotEqual(
len(routers),
0,
"Check list router response"
)
router = routers[0]
self.debug("Stopping router with ID: %s" % router.id)
# Stop the router
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
self.apiclient.stopRouter(cmd)
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
router = routers[0]
self.assertEqual(
router.state,
'Stopped',
"Check list router response for router state"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(public_ips, list),
True,
"Check for list public IPs response return valid data"
)
public_ip = public_ips[0]
# Open up firewall port for SSH
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["lbrule"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["lbrule"]["publicport"],
endport=self.services["lbrule"]["publicport"]
)
self.debug("Creating LB rule for public IP: %s" % public_ip.id)
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(
self.apiclient,
self.services["lbrule"],
public_ip.id,
accountid=self.account.name
)
self.debug("Assigning VM %s to LB rule: %s" % (
self.vm_1.id,
lb_rule.id
))
lb_rule.assign(self.apiclient, [self.vm_1])
# Start the router
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.apiclient.startRouter(cmd)
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
router = routers[0]
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
# After router start, LB RUle should be in Active state
lb_rules = list_lb_rules(
self.apiclient,
id=lb_rule.id
)
self.assertEqual(
isinstance(lb_rules, list),
True,
"Check for list LB rules response return valid data"
)
self.assertEqual(
lb_rules[0].state,
'Active',
"Check list load balancing rules"
)
self.assertEqual(
lb_rules[0].publicport,
str(self.services["lbrule"]["publicport"]),
"Check list load balancing rules"
)
try:
self.debug("SSH into VM with IP: %s" % public_ip.ipaddress)
self.vm_1.ssh_port = self.services["lbrule"]["publicport"]
self.vm_1.get_ssh_client(public_ip.ipaddress)
except Exception as e:
self.fail(
"SSH Access failed for %s: %s" %
(self.vm_1.ipaddress, e)
)
return
def test_02_create_lb_rule_non_nat(self):
"""Test to create Load balancing rule with non source NAT"""
# Validate the Following:
# 1. listLoadBalancerRules should return the added rule
# 2. attempt to ssh twice on the load balanced IP
# 3. verify using the UNAME of the VM that
# round robin is indeed happening as expected
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(self.apiclient,
self.services["lbrule"],
self.non_src_nat_ip.ipaddress.id,
accountid=self.account.name,
vpcid=self.vpc1.id,
networkid=self.network1.id)
self.cleanup.append(lb_rule)
lb_rule.assign(self.apiclient, [self.vm_1, self.vm_2])
lb_rules = list_lb_rules(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_rules, list), True,
"Check list response returns a valid list")
# verify listLoadBalancerRules lists the added load balancing rule
self.assertNotEqual(len(lb_rules), 0,
"Check Load Balancer Rule in its List")
self.assertEqual(lb_rules[0].id, lb_rule.id,
"Check List Load Balancer Rules returns valid Rule")
# listLoadBalancerRuleInstances should list
# all instances associated with that LB rule
lb_instance_rules = list_lb_instances(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_instance_rules, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(lb_instance_rules), 0,
"Check Load Balancer instances Rule in its List")
self.assertIn(
lb_instance_rules[0].id, [self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID")
self.assertIn(
lb_instance_rules[1].id, [self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID")
try:
unameResults = []
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.logger.debug("UNAME: %s" % str(unameResults))
self.assertIn("Linux", unameResults,
"Check if ssh succeeded for server1")
self.assertIn("Linux", unameResults,
"Check if ssh succeeded for server2")
# SSH should pass till there is a last VM associated with LB rule
lb_rule.remove(self.apiclient, [self.vm_2])
self.logger.debug(
"SSHing into IP address: %s after removing VM (ID: %s) from LB rule"
% (self.non_src_nat_ip.ipaddress.ipaddress, self.vm_2.id))
# Making host list empty
unameResults[:] = []
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
self.assertIn("Linux", unameResults,
"Check if ssh succeeded for server1")
self.logger.debug("UNAME after removing VM2: %s" %
str(unameResults))
except Exception as e:
self.fail("%s: SSH failed for VM with IP Address: %s" %
(e, self.non_src_nat_ip.ipaddress.ipaddress))
lb_rule.remove(self.apiclient, [self.vm_1])
with self.assertRaises(Exception):
self.logger.debug(
"SSHing into IP address: %s after removing VM (ID: %s) from LB rule"
% (self.non_src_nat_ip.ipaddress.ipaddress, self.vm_1.id))
self.try_ssh(self.non_src_nat_ip.ipaddress.ipaddress, unameResults)
return
def test_01_create_lb_rule_src_nat(self):
"""Test to create Load balancing rule with source NAT"""
# Validate the Following:
# 1. listLoadBalancerRules should return the added rule
# 2. attempt to ssh twice on the load balanced IP
# 3. verify using the UNAME of the VM
# that round robin is indeed happening as expected
src_nat_ip_addrs = PublicIPAddress.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(src_nat_ip_addrs, list), True,
"Check list response returns a valid list")
src_nat_ip_addr = src_nat_ip_addrs[0]
# Check if VM is in Running state before creating LB rule
vm_response = VirtualMachine.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(vm_response, list), True,
"Check list VM returns a valid list")
self.assertNotEqual(len(vm_response), 0,
"Check Port Forwarding Rule is created")
for vm in vm_response:
self.assertEqual(
vm.state, 'Running',
"VM state should be Running before creating a NAT rule.")
# Create Load Balancer rule and assign VMs to rule
lb_rule = LoadBalancerRule.create(self.apiclient,
self.services["lbrule"],
src_nat_ip_addr.id,
accountid=self.account.name,
vpcid=self.vpc1.id,
networkid=self.network1.id)
self.cleanup.append(lb_rule)
lb_rule.assign(self.apiclient, [self.vm_1, self.vm_2])
lb_rules = list_lb_rules(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_rules, list), True,
"Check list response returns a valid list")
# verify listLoadBalancerRules lists the added load balancing rule
self.assertNotEqual(len(lb_rules), 0,
"Check Load Balancer Rule in its List")
self.assertEqual(lb_rules[0].id, lb_rule.id,
"Check List Load Balancer Rules returns valid Rule")
# listLoadBalancerRuleInstances should list all
# instances associated with that LB rule
lb_instance_rules = list_lb_instances(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_instance_rules, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(lb_instance_rules), 0,
"Check Load Balancer instances Rule in its List")
self.logger.debug("lb_instance_rules Ids: %s, %s" %
(lb_instance_rules[0].id, lb_instance_rules[1].id))
self.logger.debug("VM ids: %s, %s" % (self.vm_1.id, self.vm_2.id))
self.assertIn(
lb_instance_rules[0].id, [self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID")
self.assertIn(
lb_instance_rules[1].id, [self.vm_1.id, self.vm_2.id],
"Check List Load Balancer instances Rules returns valid VM ID")
unameResults = []
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.logger.debug("UNAME: %s" % str(unameResults))
self.assertIn("Linux", unameResults,
"Check if ssh succeeded for server1")
self.assertIn("Linux", unameResults,
"Check if ssh succeeded for server2")
# SSH should pass till there is a last VM associated with LB rule
lb_rule.remove(self.apiclient, [self.vm_2])
# making unameResultss list empty
unameResults[:] = []
try:
self.logger.debug(
"SSHing into IP address: %s after removing VM (ID: %s)" %
(src_nat_ip_addr.ipaddress, self.vm_2.id))
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
self.assertIn("Linux", unameResults,
"Check if ssh succeeded for server1")
except Exception as e:
self.fail("%s: SSH failed for VM with IP Address: %s" %
(e, src_nat_ip_addr.ipaddress))
lb_rule.remove(self.apiclient, [self.vm_1])
with self.assertRaises(Exception):
self.logger.debug("Removed all VMs, trying to SSH")
self.try_ssh(src_nat_ip_addr.ipaddress, unameResults)
return
def test_07_associate_public_ip(self):
"""Test associate public IP within the project
"""
# Validate the following
# 1. Create a project
# 2. Add some public Ips to the project
# 3. Verify public IP assigned can only used to create PF/LB rules
# inside project
networks = Network.list(self.apiclient, projectid=self.project.id, listall=True)
self.assertEqual(isinstance(networks, list), True, "Check list networks response returns a valid response")
self.assertNotEqual(len(networks), 0, "Check list networks response returns a valid network")
network = networks[0]
self.debug("Associating public IP for project: %s" % self.project.id)
public_ip = PublicIPAddress.create(
self.apiclient,
zoneid=self.virtual_machine.zoneid,
services=self.services["server"],
networkid=network.id,
projectid=self.project.id,
)
self.cleanup.append(public_ip)
# Create NAT rule
self.debug("Creating a NAT rule within project, VM ID: %s" % self.virtual_machine.id)
nat_rule = NATRule.create(
self.apiclient,
self.virtual_machine,
self.services["natrule"],
public_ip.ipaddress.id,
projectid=self.project.id,
)
self.debug("created a NAT rule with ID: %s" % nat_rule.id)
nat_rule_response = NATRule.list(self.apiclient, id=nat_rule.id)
self.assertEqual(isinstance(nat_rule_response, list), True, "Check list response returns a valid list")
self.assertNotEqual(len(nat_rule_response), 0, "Check Port Forwarding Rule is created")
self.assertEqual(nat_rule_response[0].id, nat_rule.id, "Check Correct Port forwarding Rule is returned")
# Create Load Balancer rule and assign VMs to rule
self.debug("Created LB rule for public IP: %s" % public_ip.ipaddress)
lb_rule = LoadBalancerRule.create(
self.apiclient, self.services["lbrule"], public_ip.ipaddress.id, projectid=self.project.id
)
self.debug("Assigning VM: %s to LB rule: %s" % (self.virtual_machine.name, lb_rule.id))
lb_rule.assign(self.apiclient, [self.virtual_machine])
lb_rules = list_lb_rules(self.apiclient, id=lb_rule.id)
self.assertEqual(isinstance(lb_rules, list), True, "Check list response returns a valid list")
# verify listLoadBalancerRules lists the added load balancing rule
self.assertNotEqual(len(lb_rules), 0, "Check Load Balancer Rule in its List")
self.assertEqual(lb_rules[0].id, lb_rule.id, "Check List Load Balancer Rules returns valid Rule")
# Create Firewall rule with configurations from settings file
fw_rule = FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.ipaddress.id,
protocol="TCP",
cidrlist=[self.services["fw_rule"]["cidr"]],
startport=self.services["fw_rule"]["startport"],
endport=self.services["fw_rule"]["endport"],
projectid=self.project.id,
)
self.debug("Created firewall rule: %s" % fw_rule.id)
# After Router start, FW rule should be in Active state
fw_rules = FireWallRule.list(self.apiclient, id=fw_rule.id)
self.assertEqual(isinstance(fw_rules, list), True, "Check for list FW rules response return valid data")
self.assertEqual(fw_rules[0].state, "Active", "Check list load balancing rules")
self.assertEqual(
fw_rules[0].startport, str(self.services["fw_rule"]["startport"]), "Check start port of firewall rule"
)
self.assertEqual(
fw_rules[0].endport, str(self.services["fw_rule"]["endport"]), "Check end port of firewall rule"
)
self.debug("Deploying VM for account: %s" % self.account.name)
virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["server"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.cleanup.append(virtual_machine_1)
self.debug("VM state after deploy: %s" % virtual_machine_1.state)
# Verify VM state
self.assertEqual(virtual_machine_1.state, "Running", "Check VM state is Running or not")
self.debug("Creating NAT rule for VM (ID: %s) outside project" % virtual_machine_1.id)
with self.assertRaises(Exception):
NATRule.create(self.apiclient, virtual_machine_1, self.services["natrule"], public_ip.ipaddress.id)
self.debug("Creating LB rule for public IP: %s outside project" % public_ip.ipaddress)
with self.assertRaises(Exception):
LoadBalancerRule.create(
self.apiclient, self.services["lbrule"], public_ip.ipaddress.id, accountid=self.account.name
)
return