def create_Vpc(self,
vpc_offering,
cidr='10.1.0.0/16',
testdata=None,
account=None,
networkDomain=None,
cleanup=True):
if not account:
account = self.account
self.debug("Creating a VPC in the account - %s" % account.name)
if not testdata:
testdata = self.test_data["vpc"]
testdata["name"] = "TestVPC-" + cidr + "-" + str(vpc_offering.name)
testdata["displaytext"] = "Test VPC"
testdata["cidr"] = cidr
vpc = VPC.create(self.api_client,
testdata,
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=account.name,
domainid=account.domainid,
networkDomain=networkDomain)
self.debug("Created VPC with ID - %s" % vpc.id)
if cleanup:
self.cleanup.append(vpc)
return vpc
def create_vpc(self, name, cidr):
print name, cidr
try:
vpcOffering = VpcOffering.list(self.apiclient, isdefault=True)
self.assert_(vpcOffering is not None and len(vpcOffering) > 0,
"No VPC offerings found")
self.services["vpc"] = {}
self.services["vpc"]["name"] = name
self.services["vpc"]["displaytext"] = name
self.services["vpc"]["cidr"] = cidr
vpc = VPC.create(apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.internallb",
vpcofferingid=vpcOffering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id)
self.assertIsNotNone(vpc, "VPC creation failed")
self.logger.debug("Created VPC %s" % vpc.id)
return vpc
except Exception as e:
self.fail("Failed to create VPC: %s due to %s" % (name, e))
def test_02_create_vpc_wait_gc(self):
""" Test VPC when host is in maintenance mode and wait till nw gc
"""
# Validate the following
# 1. Put the host in maintenance mode.
# 2. Attempt to Create a VPC with cidr - 10.1.1.1/16
# 3. Wait for the VPC GC thread to run.
# 3. VPC will be created but will be in "Disabled" state and should
# get deleted
self.debug("creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
start=False)
self.validate_vpc_network(vpc, state='inactive')
interval = list_configurations(self.apiclient,
name='network.gc.interval')
wait = list_configurations(self.apiclient, name='network.gc.wait')
self.debug("Sleep till network gc thread runs..")
# Sleep to ensure that all resources are deleted
time.sleep(int(interval[0].value) + int(wait[0].value))
vpcs = VPC.list(self.apiclient, id=vpc.id, listall=True)
self.assertEqual(
vpcs, None, "List VPC should not return anything after network gc")
return
def test_vpcnetwork_nuage(self):
"""Test network VPC for Nuage"""
# 1) Create VPC with Nuage VPC offering
vpcOffering = VpcOffering.list(self.apiclient,
name="Nuage VSP VPC offering")
self.assert_(vpcOffering is not None and len(vpcOffering) > 0,
"Nuage VPC offering not found")
vpc = VPC.create(apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.networkacl",
vpcofferingid=vpcOffering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.assert_(vpc is not None, "VPC creation failed")
# 2) Create ACL
aclgroup = NetworkACLList.create(apiclient=self.apiclient,
services={},
name="acl",
description="acl",
vpcid=vpc.id)
self.assertIsNotNone(aclgroup, "Failed to create NetworkACL list")
self.debug("Created a network ACL list %s" % aclgroup.name)
# 3) Create ACL Item
aclitem = NetworkACL.create(apiclient=self.apiclient,
services={},
protocol="TCP",
number="10",
action="Deny",
aclid=aclgroup.id,
cidrlist=["0.0.0.0/0"])
self.assertIsNotNone(aclitem, "Network failed to aclItem")
self.debug("Added a network ACL %s to ACL list %s" %
(aclitem.id, aclgroup.name))
# 4) Create network with ACL
nwNuage = Network.create(self.apiclient,
self.services["vpcnetwork"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
vpcid=vpc.id,
aclid=aclgroup.id,
gateway='10.1.0.1')
self.debug("Network %s created in VPC %s" % (nwNuage.id, vpc.id))
# 5) Deploy a vm
vm = VirtualMachine.create(self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(nwNuage.id)])
self.assert_(vm is not None, "VM failed to deploy")
self.assert_(vm.state == 'Running', "VM is not running")
self.debug("VM %s deployed in VPC %s" % (vm.id, vpc.id))
def setUp(self):
self.routers = []
self.networks = []
self.ips = []
self.apiclient = self.testClient.getApiClient()
self.account = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
self.vpc_off = get_default_vpc_offering(self.apiclient)
self.logger.debug("Creating a VPC network in the account: %s" % self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup = [self.vpc, self.account]
return
def test_02_create_vpc_from_offering_with_regionlevelvpc_service_capability(
self):
""" Test create VPC offering
"""
# Steps for validation
# 1. Create VPC Offering by specifying all supported Services
# 2. VPC offering should be created successfully.
if not self.isOvsPluginEnabled:
self.skipTest("OVS plugin should be enabled to run this test case")
self.debug("Creating inter VPC offering")
vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
vpc_off.update(self.apiclient, state='Enabled')
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
networkDomain=self.account.domainid)
self.assertEqual(
vpc.distributedvpcrouter, True,
"VPC created should have 'distributedvpcrouter' set to True")
try:
vpc.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete VPC network - %s" % e)
return
def setUp(self):
self.routers = []
self.networks = []
self.ips = []
self.apiclient = self.testClient.getApiClient()
self.hypervisor = self.testClient.getHypervisorInfo()
self.account = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
self.vpc_off = get_default_redundant_vpc_offering(self.apiclient)
self.logger.debug("Creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
self.vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup = [self.account]
return
def create_vpc(self, name, cidr):
print name, cidr
try:
vpcOffering = VpcOffering.list(self.apiclient, isdefault=True)
self.assert_(vpcOffering is not None and len(
vpcOffering) > 0, "No VPC offerings found")
self.services["vpc"] = {}
self.services["vpc"]["name"] = name
self.services["vpc"]["displaytext"] = name
self.services["vpc"]["cidr"] = cidr
vpc = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.internallb",
vpcofferingid=vpcOffering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id
)
self.assertIsNotNone(vpc, "VPC creation failed")
self.logger.debug("Created VPC %s" % vpc.id)
return vpc
except Exception as e:
self.fail("Failed to create VPC: %s due to %s" % (name, e))
def setUp(self):
self.routers = []
self.networks = []
self.ips = []
self.apiclient = self.testClient.getApiClient()
self.hypervisor = self.testClient.getHypervisorInfo()
self.account = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
self.logger.debug("Creating a VPC offering..")
self.vpc_off = VpcOffering.create(
self.apiclient,
self.services["vpc_offering"])
self.logger.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state='Enabled')
self.logger.debug("Creating a VPC network in the account: %s" % self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup = [self.vpc, self.vpc_off, self.account]
return
def test_02_create_vpc_from_offering_with_regionlevelvpc_service_capability(self):
""" Test create VPC offering
"""
# Steps for validation
# 1. Create VPC Offering by specifying all supported Services
# 2. VPC offering should be created successfully.
if not self.isOvsPluginEnabled:
self.skipTest("OVS plugin should be enabled to run this test case")
self.debug("Creating inter VPC offering")
vpc_off = VpcOffering.create(
self.apiclient,
self.services["vpc_offering"]
)
vpc_off.update(self.apiclient, state='Enabled')
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
networkDomain=self.account.domainid
)
self.assertEqual(vpc.distributedvpcrouter, True, "VPC created should have 'distributedvpcrouter' set to True")
try:
vpc.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete VPC network - %s" % e)
return
def setUp(self):
self.routers = []
self.networks = []
self.ips = []
self.apiclient = self.testClient.getApiClient()
self.account = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
self.cleanup = [self.account]
self.debug("Creating a VPC offering..")
self.vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
self.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
self.vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
return
def setUpClass(cls):
cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger()
# We want to fail quicker if it's failure
socket.setdefaulttimeout(60)
cls.testClient = super(TestRouterIpTablesPolicies, cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.template = get_template(
cls.apiclient,
cls.zone.id
)
cls.services["vpc"]["cidr"] = '10.1.1.1/16'
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.vpc_offering = get_default_vpc_offering(cls.apiclient)
cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name)
cls.network_offering = get_default_network_offering(cls.apiclient)
cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name)
cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow')
cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name)
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.vpc1 = VPC.create(cls.apiclient,
cls.services['vpcs']['vpc1'],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
account=cls.account.name)
cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr)
cls.network1 = Network.create(cls.apiclient,
cls.services['networks']['network1'],
networkofferingid=cls.network_offering.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc1.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway)
cls.service_offering = get_default_virtual_machine_offering(cls.apiclient)
cls.entity_manager = EntityManager(cls.apiclient, cls.services, cls.service_offering, cls.account, cls.zone, cls.network1, cls.logger)
cls._cleanup = [cls.account]
return
def setUpClass(cls):
cls.testClient = super(TestVPCRoutersBasic, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.vpcSupported = True
cls._cleanup = []
if cls.hypervisor.lower() == 'hyperv':
cls.vpcSupported = False
return
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.vpc_off = VpcOffering.create(
cls.api_client,
cls.services["vpc_offering"]
)
cls.vpc_off.update(cls.api_client, state='Enabled')
cls.account = Account.create(
cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls._cleanup = [cls.account]
cls._cleanup.append(cls.vpc_off)
#cls.debug("Enabling the VPC offering created")
cls.vpc_off.update(cls.api_client, state='Enabled')
# cls.debug("creating a VPC network in the account: %s" %
# cls.account.name)
cls.services["vpc"]["cidr"] = '10.1.1.1/16'
cls.vpc = VPC.create(
cls.api_client,
cls.services["vpc"],
vpcofferingid=cls.vpc_off.id,
zoneid=cls.zone.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls._cleanup.append(cls.service_offering)
return
def test_vpcnetwork_nuage(self):
"""Test network VPC for Nuage"""
# 1) Create VPC with Nuage VPC offering
vpcOffering = VpcOffering.list(self.apiclient,name="Nuage VSP VPC offering")
self.assert_(vpcOffering is not None and len(vpcOffering)>0, "Nuage VPC offering not found")
vpc = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.networkacl",
vpcofferingid=vpcOffering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assert_(vpc is not None, "VPC creation failed")
# 2) Create ACL
aclgroup = NetworkACLList.create(apiclient=self.apiclient, services={}, name="acl", description="acl", vpcid=vpc.id)
self.assertIsNotNone(aclgroup, "Failed to create NetworkACL list")
self.debug("Created a network ACL list %s" % aclgroup.name)
# 3) Create ACL Item
aclitem = NetworkACL.create(apiclient=self.apiclient, services={},
protocol="TCP", number="10", action="Deny", aclid=aclgroup.id, cidrlist=["0.0.0.0/0"])
self.assertIsNotNone(aclitem, "Network failed to aclItem")
self.debug("Added a network ACL %s to ACL list %s" % (aclitem.id, aclgroup.name))
# 4) Create network with ACL
nwNuage = Network.create(
self.apiclient,
self.services["vpcnetwork"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
vpcid=vpc.id,
aclid=aclgroup.id,
gateway='10.1.0.1'
)
self.debug("Network %s created in VPC %s" %(nwNuage.id, vpc.id))
# 5) Deploy a vm
vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(nwNuage.id)]
)
self.assert_(vm is not None, "VM failed to deploy")
self.assert_(vm.state == 'Running', "VM is not running")
self.debug("VM %s deployed in VPC %s" %(vm.id, vpc.id))
def setUp(self):
self.vpc_off = get_default_vpc_offering(self.apiclient)
self.vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup = [self.vpc]
self.entity_manager.set_cleanup(self.cleanup)
return
def create_Vpc(self, vpc_offering, cidr='10.1.1.1/16', cleanup=True):
self.debug("Creating a VPC network in the account: %s" %
self.account.name)
self.test_data["vpc"]["cidr"] = cidr
vpc = VPC.create(self.api_client,
self.test_data["vpc"],
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.debug("Created VPC with ID: %s" % vpc.id)
if cleanup:
self.cleanup.append(vpc)
return vpc
def setUp(self):
self.vpc_off = get_default_vpc_offering(self.apiclient)
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup = [self.vpc]
self.entity_manager.set_cleanup(self.cleanup)
return
def create_Vpc(self, vpc_offering, cidr='10.1.1.1/16', cleanup=True):
self.debug("Creating a VPC network in the account: %s" % self.account.name)
self.test_data["vpc"]["cidr"] = cidr
vpc = VPC.create(
self.api_client,
self.test_data["vpc"],
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Created VPC with ID: %s" % vpc.id)
if cleanup:
self.cleanup.append(vpc)
return vpc
def createVPC(self, vpc_offering, cidr='10.1.1.1/16'):
try:
self.logger.debug("Creating a VPC in the account: %s" % self.account.name)
self.services["vpc"]["cidr"] = cidr
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.logger.debug("Created VPC with ID: %s" % vpc.id)
except Exception, e:
self.fail('Unable to create VPC due to %s ' % e)
def create_Vpc(self, vpc_offering, cidr="10.1.1.1/16", cleanup=True):
self.debug("Creating a VPC in the account - %s" % self.account.name)
self.test_data["vpc"]["name"] = "TestVPC"
self.test_data["vpc"]["displaytext"] = "TestVPC"
self.test_data["vpc"]["cidr"] = cidr
vpc = VPC.create(self.api_client,
self.test_data["vpc"],
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Created VPC with ID - %s" % vpc.id)
if cleanup:
self.cleanup.append(vpc)
return vpc
def createVPC(self, vpc_offering, cidr='10.1.1.1/16'):
try:
self.logger.debug("Creating a VPC in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = cidr
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.logger.debug("Created VPC with ID: %s" % vpc.id)
except Exception, e:
self.fail('Unable to create VPC due to %s ' % e)
def deploy_vpc(self, vpc_data, account):
self.logger.debug('>>> VPC => Creating "%s"...', vpc_data['name'])
vpc = VPC.create(api_client=self.api_client,
data=vpc_data,
zone=self.zone,
account=account,
randomizeID=self.randomizeNames)
self.dynamic_names['vpcs'][vpc_data['name']] = vpc.name
self.logger.debug(
'>>> VPC => ID: %s => Name: %s => CIDR: %s => State: %s => Offering: %s '
'=> Account: %s => Domain: %s', vpc.id, vpc.name, vpc.cidr,
vpc.state, vpc.vpcofferingid, vpc.account, vpc.domainid)
self.deploy_acls(vpc_data['acls'], vpc)
self.deploy_networks(vpc_data['networks'], vpc)
def test_02_create_vpc_wait_gc(self):
""" Test VPC when host is in maintenance mode and wait till nw gc
"""
# Validate the following
# 1. Put the host in maintenance mode.
# 2. Attempt to Create a VPC with cidr - 10.1.1.1/16
# 3. Wait for the VPC GC thread to run.
# 3. VPC will be created but will be in "Disabled" state and should
# get deleted
self.debug("creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
start=False
)
self.validate_vpc_network(vpc, state='inactive')
interval = list_configurations(
self.apiclient,
name='network.gc.interval'
)
wait = list_configurations(
self.apiclient,
name='network.gc.wait'
)
self.debug("Sleep till network gc thread runs..")
# Sleep to ensure that all resources are deleted
time.sleep(int(interval[0].value) + int(wait[0].value))
vpcs = VPC.list(
self.apiclient,
id=vpc.id,
listall=True
)
self.assertEqual(
vpcs,
None,
"List VPC should not return anything after network gc"
)
return
def deploy_vpc(self, vpc_data, account):
self.logger.debug('>>> VPC => Creating "%s"...', vpc_data['name'])
vpc = VPC.create(
api_client=self.api_client,
data=vpc_data,
zone=self.zone,
account=account,
randomizeID=self.randomizeNames
)
self.dynamic_names['vpcs'][vpc_data['name']] = vpc.name
self.logger.debug('>>> VPC => ID: %s => Name: %s => CIDR: %s => State: %s => Offering: %s '
'=> Account: %s => Domain: %s', vpc.id, vpc.name, vpc.cidr, vpc.state, vpc.vpcofferingid,
vpc.account, vpc.domainid)
self.deploy_acls(vpc_data['acls'], vpc)
self.deploy_networks(vpc_data['networks'], vpc)
def setUpClass(cls):
cls.testClient = super(TestVPCRoutersBasic, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.vpcSupported = True
cls._cleanup = []
if cls.hypervisor.lower() == 'hyperv':
cls.vpcSupported = False
return
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.vpc_off = VpcOffering.create(cls.api_client,
cls.services["vpc_offering"])
cls.vpc_off.update(cls.api_client, state='Enabled')
cls.account = Account.create(cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls._cleanup = [cls.account]
cls._cleanup.append(cls.vpc_off)
#cls.debug("Enabling the VPC offering created")
cls.vpc_off.update(cls.api_client, state='Enabled')
# cls.debug("creating a VPC network in the account: %s" %
# cls.account.name)
cls.services["vpc"]["cidr"] = '10.1.1.1/16'
cls.vpc = VPC.create(cls.api_client,
cls.services["vpc"],
vpcofferingid=cls.vpc_off.id,
zoneid=cls.zone.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls._cleanup.append(cls.service_offering)
return
def setUp(self):
self.logger.debug("Creating a VPC offering.")
self.vpc_off = VpcOffering.create(self.apiclient, self.services["vpc_offering"])
self.logger.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state="Enabled")
self.logger.debug("Creating a VPC network in the account: %s" % self.account.name)
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
return
def create_vpc(self, vpc_offering):
self.logger.debug("Creating VPC using offering ==> ID %s / Name %s" %
(vpc_offering.id, vpc_offering.name))
try:
vpc = VPC.create(apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.internallb",
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id)
self.assertIsNotNone(vpc, "VPC creation failed")
self.logger.debug("Created VPC %s" % vpc.id)
self.cleanup.append(vpc)
return vpc
except Exception as e:
self.fail("Failed to create VPC due to %s" % e)
def create_Vpc(cls, vpc_offering, cidr='10.1.0.0/16', testdata=None,
account=None, networkDomain=None):
if not account:
account = cls.account
cls.debug("Creating a VPC in the account - %s" % account.name)
if not testdata:
testdata = cls.test_data["vpc"]
testdata["name"] = "TestVPC-" + cidr + "-" + str(vpc_offering.name)
testdata["displaytext"] = "Test VPC"
testdata["cidr"] = cidr
vpc = VPC.create(cls.api_client,
testdata,
vpcofferingid=vpc_offering.id,
zoneid=cls.zone.id,
account=account.name,
domainid=account.domainid,
networkDomain=networkDomain
)
cls.debug("Created VPC with ID - %s" % vpc.id)
return vpc
def setUp(self):
self.logger.debug("Creating a VPC offering.")
self.vpc_off = VpcOffering.create(
self.apiclient,
self.services["vpc_offering"])
self.logger.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state='Enabled')
self.logger.debug("Creating a VPC network in the account: %s" % self.account.name)
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
return
def test_01_create_vpc_host_maintenance(self):
""" Test VPC when host is in maintenance mode
"""
# Validate the following
# 1. Put the host in maintenance mode.
# 2. Attempt to Create a VPC with cidr - 10.1.1.1/16
# 3. VPC will be created but will be in "Disabled" state
self.debug("creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
start=False)
self.validate_vpc_network(vpc, state='enabled')
return
def create_VPC(self, cidr='10.1.2.1/16'):
self.debug("Creating a VPC offering..")
self.services["vpc_offering"][
"name"] = self.services["vpc_offering"]["name"] + str(cidr)
vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
self.cleanup.append(vpc_off)
self.debug("Enabling the VPC offering created")
vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = cidr
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup.append(vpc)
return vpc
def create_vpc(self, vpc_offering):
self.logger.debug("Creating VPC using offering ==> ID %s / Name %s" % (vpc_offering.id, vpc_offering.name))
try:
vpc = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.internallb",
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id
)
self.assertIsNotNone(vpc, "VPC creation failed")
self.logger.debug("Created VPC %s" % vpc.id)
self.cleanup.insert(0, vpc)
return vpc
except Exception as e:
self.fail("Failed to create VPC due to %s" % e)
def create_vpc_for_account(self, apiclient, domain, account, project):
self.services["vpc"]["name"] = "Test VPC - " + random_gen()
self.services["vpc"]["cidr"] = "10.1.0.0/20"
domain_id = None
account_name = None
if domain:
domain_id = domain.id
if account:
account_name = account.name
project_id = None
if project:
project_id = project.id
vpc = VPC.create(apiclient,
self.services["vpc"],
domainid=domain_id,
accountid=account_name,
projectid=project_id,
vpcofferingid=self.vpc_offering.id,
zoneid=self.zone.id,
start=False)
return vpc
def create_Vpc(self, vpc_offering, cidr='10.1.0.0/16', testdata=None, account=None, networkDomain=None,
cleanup=True):
if not account:
account = self.account
self.debug("Creating a VPC in the account - %s" % account.name)
if not testdata:
testdata = self.test_data["vpc"]
testdata["name"] = "TestVPC-" + cidr + "-" + str(vpc_offering.name)
testdata["displaytext"] = "Test VPC"
testdata["cidr"] = cidr
vpc = VPC.create(self.api_client,
testdata,
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=account.name,
domainid=account.domainid,
networkDomain=networkDomain
)
self.debug("Created VPC with ID - %s" % vpc.id)
if cleanup:
self.cleanup.append(vpc)
return vpc
def setUp(self):
self.hypervisor = self.testClient.getHypervisorInfo()
self.logger.debug("Creating a VPC offering.")
self.vpc_off = VpcOffering.create(self.apiclient, self.services["vpc_offering"])
self.logger.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state="Enabled")
self.logger.debug("Creating a VPC network in the account: %s" % self.account.name)
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
self.cleanup = [self.vpc, self.vpc_off]
self.entity_manager.set_cleanup(self.cleanup)
return
def setUp(self):
self.hypervisor = self.testClient.getHypervisorInfo()
self.logger.debug("Creating a VPC offering.")
self.vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
self.logger.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state='Enabled')
self.logger.debug("Creating a VPC network in the account: %s" %
self.account.name)
self.vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup = [self.vpc, self.vpc_off]
self.entity_manager.set_cleanup(self.cleanup)
return
def create_vpc(self, cidr='10.1.1.1/16', account='admin'):
vpc_services = {
'name': 'nicira_enabled_vpc',
'displaytext': 'nicira_enabled_vpc',
'zoneid': self.zone.id,
'networkoffering': self.vpc_offering,
'cidr': cidr
}
try:
self.logger.debug("Creating a VPC network in the account: %s" %
account)
vpc = VPC.create(self.api_client,
vpc_services,
vpcofferingid=self.vpc_offering.id,
zoneid=self.zone.id,
account=account,
domainid=self.domain.id)
self.logger.debug("Created VPC with ID: %s" % vpc.id)
self.test_cleanup.append(vpc)
except Exception, e:
self.fail('Unable to create VPC due to %s ' % e)
def test_01_create_vpc_host_maintenance(self):
""" Test VPC when host is in maintenance mode
"""
# Validate the following
# 1. Put the host in maintenance mode.
# 2. Attempt to Create a VPC with cidr - 10.1.1.1/16
# 3. VPC will be created but will be in "Disabled" state
self.debug("creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
start=False
)
self.validate_vpc_network(vpc, state='inactive')
return
def create_vpc(self, cidr='10.1.2.1/16'):
self.debug("Creating a VPC offering..")
self.services["vpc_offering"]["name"] = self.services["vpc_offering"]["name"] + str(cidr)
vpc_off = VpcOffering.create(
self.apiclient,
self.services["vpc_offering"]
)
self._cleanup.append(vpc_off)
self.debug("Enabling the VPC offering created")
vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC network in the account: %s" % self.account.name)
self.services["vpc"]["cidr"] = cidr
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
return vpc
def create_vpc(self, cidr='10.1.1.1/16', account='admin'):
vpc_services = {
'name' : 'nicira_enabled_vpc',
'displaytext' : 'nicira_enabled_vpc',
'zoneid' : self.zone.id,
'networkoffering' : self.vpc_offering,
'cidr' : cidr
}
try:
self.logger.debug("Creating a VPC network in the account: %s" % account)
vpc = VPC.create(
self.api_client,
vpc_services,
vpcofferingid=self.vpc_offering.id,
zoneid=self.zone.id,
account=account,
domainid=self.domain.id)
self.logger.debug("Created VPC with ID: %s" % vpc.id)
self.test_cleanup.append(vpc)
except Exception, e:
self.fail('Unable to create VPC due to %s ' % e)
def setUpClass(cls):
cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger()
# We want to fail quicker if it's failure
socket.setdefaulttimeout(60)
cls.testClient = super(TestRouterIpTablesPolicies,
cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.template = get_template(cls.apiclient, cls.zone.id)
cls.services["vpc"]["cidr"] = '10.1.1.1/16'
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.vpc_offering = get_default_vpc_offering(cls.apiclient)
cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name)
cls.network_offering = get_default_network_offering(cls.apiclient)
cls.logger.debug("Network Offering '%s' selected",
cls.network_offering.name)
cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow')
cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name)
cls.account = Account.create(cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.vpc1 = VPC.create(cls.apiclient,
cls.services['vpcs']['vpc1'],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
account=cls.account.name)
cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name,
cls.vpc1.cidr)
cls.network1 = Network.create(
cls.apiclient,
cls.services['networks']['network1'],
networkofferingid=cls.network_offering.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc1.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s",
cls.network1.name, cls.network1.cidr,
cls.network1.gateway)
cls.service_offering = get_default_virtual_machine_offering(
cls.apiclient)
cls.entity_manager = EntityManager(cls.apiclient, cls.services,
cls.service_offering, cls.account,
cls.zone, cls.network1, cls.logger)
cls._cleanup = [cls.account]
return
def test_03_deploy_vms_in_vpc_with_regionlevelvpc(self):
"""Test deploy virtual machines in VPC networks"""
# 1. Create VPC Offering by specifying all supported Services
# (Vpn,dhcpdns,UserData, SourceNat,Static NAT and PF,LB,NetworkAcl)
# 2. Create a VPC using the above VPC offering
# 3. Create a network as part of this VPC.
# 4. Deploy few Vms.
# 5. Create a LB rule for this VM.
# 6. Create a PF rule for this VM.
# 7. Create a Static Nat rule for this VM.
# 8. Create Ingress rules on the network to open the above created
# LB PF and Static Nat rule
# 9. Create Egress Network ACL for this network to access google.com.
# 10. Enable VPN services
if not self.isOvsPluginEnabled:
self.skipTest("OVS plugin should be enabled to run this test case")
self.debug("Creating a VPC offering..")
vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
vpc_off.update(self.apiclient, state='Enabled')
self.debug("creating a VPC network in the account: %s" %
self.account.name)
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
networkDomain=self.account.domainid)
self.validate_vpc_network(vpc)
self.network_offering = NetworkOffering.create(
self.apiclient,
self.services["network_offering"],
conservemode=False)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
gateway = vpc.cidr.split('/')[0]
# Split the cidr to retrieve gateway
# for eg. cidr = 10.0.0.1/24
# Gateway = 10.0.0.1
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" %
self.network_offering.id)
network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id)
self.debug("Created network with ID: %s" % network.id)
# Spawn an instance in that network
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)])
self.debug("Deployed VM in network: %s" % network.id)
self.debug("Associating public IP for network: %s" % network.name)
public_ip = PublicIPAddress.create(self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id,
vpcid=vpc.id)
self.debug("Associated %s with network %s" %
(public_ip.ipaddress.ipaddress, network.id))
self.debug("Creating LB rule for IP address: %s" %
public_ip.ipaddress.ipaddress)
LoadBalancerRule.create(self.apiclient,
self.services["lbrule"],
ipaddressid=public_ip.ipaddress.id,
accountid=self.account.name,
networkid=network.id,
vpcid=vpc.id,
domainid=self.account.domainid)
self.debug("Associating public IP for network: %s" % vpc.name)
public_ip_2 = PublicIPAddress.create(self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id,
vpcid=vpc.id)
self.debug("Associated %s with network %s" %
(public_ip_2.ipaddress.ipaddress, network.id))
NATRule.create(self.apiclient,
virtual_machine,
self.services["natrule"],
ipaddressid=public_ip_2.ipaddress.id,
openfirewall=False,
networkid=network.id,
vpcid=vpc.id)
self.debug("Adding NetwrokACl rules to make PF and LB accessible")
NetworkACL.create(self.apiclient,
networkid=network.id,
services=self.services["natrule"],
traffictype='Ingress')
NetworkACL.create(self.apiclient,
networkid=network.id,
services=self.services["lbrule"],
traffictype='Ingress')
self.debug("Checking if we can SSH into VM?")
try:
virtual_machine.get_ssh_client(
ipaddress=public_ip_2.ipaddress.ipaddress, )
self.debug("SSH into VM is successfully")
except Exception as e:
self.fail("Failed to SSH into VM - %s, %s" %
(public_ip_2.ipaddress.ipaddress, e))
self.debug("Associating public IP for network: %s" % network.name)
public_ip_3 = PublicIPAddress.create(self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id,
vpcid=vpc.id)
self.debug("Associated %s with network %s" %
(public_ip_3.ipaddress.ipaddress, network.id))
self.debug("Enabling static NAT for IP: %s" %
public_ip_3.ipaddress.ipaddress)
try:
StaticNATRule.enable(self.apiclient,
ipaddressid=public_ip_3.ipaddress.id,
virtualmachineid=virtual_machine.id,
networkid=network.id)
self.debug("Static NAT enabled for IP: %s" %
public_ip_3.ipaddress.ipaddress)
except Exception as e:
self.fail("Failed to enable static NAT on IP: %s - %s" %
(public_ip_3.ipaddress.ipaddress, e))
public_ips = PublicIPAddress.list(self.apiclient,
networkid=network.id,
listall=True,
isstaticnat=True,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(public_ips, list), True,
"List public Ip for network should list the Ip addr")
self.assertEqual(public_ips[0].ipaddress,
public_ip_3.ipaddress.ipaddress,
"List public Ip for network should list the Ip addr")
# TODO: Remote Access VPN is not yet supported in VPC
return
def test_02_native_to_native_vpc_migration(self):
"""
Verify Migration for a vpc network nativeOnly
1. create native vpc with 2 tier networks
2. migrate to native vpc, check VR state
3. deploy VM in vpc tier network
4. acquire ip and enable staticnat
5. migrate to native vpc network
"""
self.debug("Creating Native VSP VPC offering with Static NAT service "
"provider as VPCVR...")
native_vpc_off = VpcOffering.create(
self.apiclient,
self.test_data["vpc_offering_reduced"])
self.debug("Enabling the VPC offering created")
native_vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=native_vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Creating native VPC Network Tier offering "
"with Static NAT service provider as VPCVR")
native_tiernet_off = \
NetworkOffering.create(self.apiclient,
self.test_data
["nw_offering_reduced_vpc"],
conservemode=False)
native_tiernet_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=native_tiernet_off.id,
zoneid=self.zone.id,
gateway='10.1.1.1',
vpcid=vpc.id if vpc else self.vpc.id
)
self.debug("Created network with ID: %s" % vpc_tier.id)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.native_vpc_network_offering.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": native_tiernet_off.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
self.debug('Creating VM in network=%s' % native_tiernet_off.name)
vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(vpc_tier.id)],
templateid=self.template.id,
zoneid=self.zone.id
)
self.debug('Created VM=%s in network=%s' %
(vm.id, native_tiernet_off.name))
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.native_vpc_network_offering.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": native_tiernet_off.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
def test_02_native_to_native_vpc_migration(self):
"""
Verify Migration for a vpc network nativeOnly
1. create native vpc with 2 tier networks
2. migrate to native vpc, check VR state
3. deploy VM in vpc tier network
4. acquire ip and enable staticnat
5. migrate to native vpc network
"""
self.debug("Creating Native VSP VPC offering with Static NAT service "
"provider as VPCVR...")
native_vpc_off = VpcOffering.create(
self.apiclient,
self.test_data["vpc_offering_reduced"])
self.debug("Enabling the VPC offering created")
native_vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=native_vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Creating native VPC Network Tier offering "
"with Static NAT service provider as VPCVR")
native_tiernet_off = \
NetworkOffering.create(self.apiclient,
self.test_data
["nw_offering_reduced_vpc"],
conservemode=False)
native_tiernet_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=native_tiernet_off.id,
zoneid=self.zone.id,
gateway='10.1.1.1',
vpcid=vpc.id if vpc else self.vpc.id
)
self.debug("Created network with ID: %s" % vpc_tier.id)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.native_vpc_network_offering.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": native_tiernet_off.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
self.debug('Creating VM in network=%s' % native_tiernet_off.name)
vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(vpc_tier.id)],
templateid=self.template.id,
zoneid=self.zone.id
)
self.debug('Created VM=%s in network=%s' %
(vm.id, native_tiernet_off.name))
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.native_vpc_network_offering.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": native_tiernet_off.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map, resume=False)
def test_01_vpc_remote_access_vpn(self):
"""Test Remote Access VPN in VPC"""
# 1) Create VPC
vpc_offering = VpcOffering.list(self.apiclient, isdefault=True)
self.assertTrue(vpc_offering is not None and len(vpc_offering) > 0,
"No VPC offerings found")
vpc = VPC.create(apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.vpn",
vpcofferingid=vpc_offering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id)
self.assertIsNotNone(vpc, "VPC creation failed")
self.logger.debug("VPC %s created" % (vpc.id))
self.cleanup.append(vpc)
# 2) Create network in VPC
ntwk = Network.create(apiclient=self.apiclient,
services=self.services["network_1"],
accountid=self.account.name,
domainid=self.domain.id,
networkofferingid=self.network_offerings[0].id,
zoneid=self.zone.id,
vpcid=vpc.id)
self.assertIsNotNone(ntwk, "Network failed to create")
self.logger.debug("Network %s created in VPC %s" % (ntwk.id, vpc.id))
self.cleanup.append(ntwk)
# 3) Deploy a vm
vm = VirtualMachine.create(self.apiclient,
services=self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.domain.id,
serviceofferingid=self.compute_offering.id,
networkids=ntwk.id,
hypervisor=self.hypervisor)
self.assertIsNotNone(vm, "VM failed to deploy")
self.assertEquals(vm.state, 'Running', "VM is not running")
self.debug("VM %s deployed in VPC %s" % (vm.id, vpc.id))
self.logger.debug("Deployed virtual machine: OK")
self.cleanup.append(vm)
# 4) Enable VPN for VPC
src_nat_list = PublicIPAddress.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True,
issourcenat=True,
vpcid=vpc.id)
ip = src_nat_list[0]
self.logger.debug("Acquired public ip address: OK")
vpn = Vpn.create(self.apiclient,
publicipid=ip.id,
account=self.account.name,
domainid=self.account.domainid,
iprange=self.services["vpn"]["iprange"],
fordisplay=self.services["vpn"]["fordisplay"])
self.assertIsNotNone(vpn, "Failed to create Remote Access VPN")
self.logger.debug("Created Remote Access VPN: OK")
vpn_user = None
# 5) Add VPN user for VPC
vpn_user = VpnUser.create(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
username=self.services["vpn"]["vpn_user"],
password=self.services["vpn"]["vpn_pass"])
self.assertIsNotNone(vpn_user,
"Failed to create Remote Access VPN User")
self.logger.debug("Created VPN User: OK")
# TODO: Add an actual remote vpn connection test from a remote vpc
# 9) Disable VPN for VPC
vpn.delete(self.apiclient)
self.logger.debug("Deleted the Remote Access VPN: OK")
def setUpClass(cls):
"""
Create the following domain tree and accounts that are required for
executing Nuage VSP SDN plugin test cases for shared networks:
Under ROOT - create domain D1
Under domain D1 - Create two subdomains D11 and D12
Under each of the domains - create one admin user and couple of
regular users.
Create shared network with the following scope:
1. Network with scope="all"
2. Network with scope="domain" with no subdomain access
3. Network with scope="domain" with subdomain access
4. Network with scope="account"
"""
super(TestNuageSharedNetworkVpcVmMonitor, cls).setUpClass()
cls.sharednetworkdata = cls.test_data["acl"]
cls.nuagenetworkdata = cls.test_data["nuagevsp"]
cls.domain_1 = None
cls.domain_2 = None
try:
# backup default apikey and secretkey
cls.default_apikey = cls.api_client.connection.apiKey
cls.default_secretkey = cls.api_client.connection.securityKey
# Create domains
cls.domain_1 = Domain.create(cls.api_client,
cls.sharednetworkdata["domain1"])
cls.domain_11 = Domain.create(cls.api_client,
cls.sharednetworkdata["domain11"],
parentdomainid=cls.domain_1.id)
cls.domain_12 = Domain.create(cls.api_client,
cls.sharednetworkdata["domain12"],
parentdomainid=cls.domain_1.id)
# Create 1 admin account and 2 user accounts for doamin_1
cls.account_d1 = Account.create(cls.api_client,
cls.sharednetworkdata["accountD1"],
admin=True,
domainid=cls.domain_1.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d1)
cls.user_d1_apikey = user.apikey
cls.user_d1_secretkey = user.secretkey
cls.account_d1a = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD1A"],
admin=False,
domainid=cls.domain_1.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d1a)
cls.user_d1a_apikey = user.apikey
cls.user_d1a_secretkey = user.secretkey
cls.account_d1b = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD1B"],
admin=False,
domainid=cls.domain_1.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d1b)
cls.user_d1b_apikey = user.apikey
cls.user_d1b_secretkey = user.secretkey
# Create 1 admin and 2 user accounts for doamin_11
cls.account_d11 = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD11"],
admin=True,
domainid=cls.domain_11.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d11)
cls.user_d11_apikey = user.apikey
cls.user_d11_secretkey = user.secretkey
cls.account_d11a = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD11A"],
admin=False,
domainid=cls.domain_11.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d11a)
cls.user_d11a_apikey = user.apikey
cls.user_d11a_secretkey = user.secretkey
cls.account_d11b = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD11B"],
admin=False,
domainid=cls.domain_11.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d11b)
cls.user_d11b_apikey = user.apikey
cls.user_d11b_secretkey = user.secretkey
# Create 2 user accounts for doamin_12
cls.account_d12a = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD12A"],
admin=False,
domainid=cls.domain_12.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d12a)
cls.user_d12a_apikey = user.apikey
cls.user_d12a_secretkey = user.secretkey
cls.account_d12b = Account.create(
cls.api_client,
cls.sharednetworkdata["accountD12B"],
admin=False,
domainid=cls.domain_12.id)
user = cls.generateKeysForUser(cls.api_client, cls.account_d12b)
cls.user_d12b_apikey = user.apikey
cls.user_d12b_secretkey = user.secretkey
# Create 1 user account and admin account in "ROOT" domain
cls.account_roota = Account.create(
cls.api_client,
cls.sharednetworkdata["accountROOTA"],
admin=False,
)
user = cls.generateKeysForUser(cls.api_client, cls.account_roota)
cls.user_roota_apikey = user.apikey
cls.user_roota_secretkey = user.secretkey
cls.account_root = Account.create(
cls.api_client,
cls.sharednetworkdata["accountROOTA"],
admin=True,
)
user = cls.generateKeysForUser(cls.api_client, cls.account_root)
cls.user_root_apikey = user.apikey
cls.user_root_secretkey = user.secretkey
# service offering is already created in Nuagetestcase
cls.sharednetworkdata['mode'] = cls.zone.networktype
# As admin user , create shared network with scope "all", "domain"
# with subdomain access , "domain" without subdomain access and
# "account"
cls.api_client.connection.apiKey = cls.default_apikey
cls.api_client.connection.securityKey = cls.default_secretkey
cls.shared_network_offering = NetworkOffering.create(
cls.api_client,
cls.test_data["nuagevsp"]["shared_nuage_network_offering"],
conservemode=False)
# Enable Network offering
cls.shared_network_offering.update(cls.api_client, state='Enabled')
cls.shared_network_offering_id = cls.shared_network_offering.id
cls.shared_network_all = Network.create(
cls.api_client,
cls.test_data["nuagevsp"]["network_all"],
networkofferingid=cls.shared_network_offering_id,
zoneid=cls.zone.id)
cls.shared_network_domain_d11 = Network.create(
cls.api_client,
cls.test_data["nuagevsp"]
["network_domain_with_no_subdomain_access"],
networkofferingid=cls.shared_network_offering_id,
zoneid=cls.zone.id,
domainid=cls.domain_11.id,
subdomainaccess=False)
cls.shared_network_domain_with_subdomain_d11 = Network.create(
cls.api_client,
cls.test_data["nuagevsp"]
["network_domain_with_subdomain_access"],
networkofferingid=cls.shared_network_offering_id,
zoneid=cls.zone.id,
domainid=cls.domain_11.id,
subdomainaccess=True)
cls.shared_network_account_d111a = Network.create(
cls.api_client,
cls.test_data["nuagevsp"]["network_account"],
networkofferingid=cls.shared_network_offering_id,
zoneid=cls.zone.id,
domainid=cls.domain_11.id,
accountid=cls.account_d11a.user[0].username)
cls.debug("Creating Nuage VSP VPC offering...")
cls.vpc_offering = VpcOffering.create(
cls.api_client, cls.test_data["nuagevsp"]["vpc_offering"])
cls.vpc_offering.update(cls.api_client, state="Enabled")
# Creating a VPC
cls.debug("Creating a VPC with Nuage VSP VPC offering...")
cls.test_data["vpc"]["cidr"] = '10.1.0.0/16'
cls.vpcd11 = VPC.create(cls.api_client,
cls.test_data["vpc"],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
account=cls.account_d11a.name,
domainid=cls.account_d11a.domainid)
# Creating a network offering
cls.debug("Creating Nuage Vsp VPC Network offering...")
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.test_data["nuagevsp"]["vpc_network_offering"],
conservemode=False)
cls.network_offering.update(cls.api_client, state="Enabled")
# Creating two VPC network in the VPC
cls.debug("Creating a VPC network with Nuage Vsp VPC Network "
"offering...")
cls.test_data["network"]["netmask"] = "255.255.255.0"
cls.vpc_network1 = Network.create(
cls.api_client,
cls.test_data["network"],
accountid=cls.account_d11a.name,
domainid=cls.account_d11a.domainid,
networkofferingid=cls.network_offering.id,
zoneid=cls.zone.id,
gateway="10.1.1.1",
vpcid=cls.vpcd11.id)
cls.debug(
"Creating a VPC Tier2 network with Nuage Vsp VPC Network "
"offering...")
cls.test_data["network"]["name"] = "Tier2"
cls.vpc_network2 = Network.create(
cls.api_client,
cls.test_data["network"],
accountid=cls.account_d11a.name,
domainid=cls.account_d11a.domainid,
networkofferingid=cls.network_offering.id,
zoneid=cls.zone.id,
gateway="10.1.2.1",
vpcid=cls.vpcd11.id)
cls.vmdata = {"name": "vmvpc1", "displayname": "vmvpc1"}
# Deploying a VM in the VPC network
cls.vmvpc1 = VirtualMachine.create(
cls.api_client,
cls.vmdata,
zoneid=cls.zone.id,
serviceofferingid=cls.service_offering.id,
templateid=cls.template.id,
networkids=cls.vpc_network1.id,
accountid=cls.account_d11a.name,
domainid=cls.account_d11a.domainid)
cls.vmdata = {"name": "vmvpc2", "displayname": "vmvpc2"}
cls.vmvpc2 = VirtualMachine.create(
cls.api_client,
cls.vmdata,
zoneid=cls.zone.id,
serviceofferingid=cls.service_offering.id,
templateid=cls.template.id,
networkids=cls.vpc_network2.id,
accountid=cls.account_d11a.name,
domainid=cls.account_d11a.domainid)
cls._cleanup = [
cls.account_root,
cls.account_roota,
cls.shared_network_all,
cls.shared_network_offering,
cls.network_offering,
cls.vpc_offering,
cls.service_offering,
]
except Exception as e:
cls.domain_1.delete(cls.api_client, cleanup="true")
cleanup_resources(cls.api_client, cls._cleanup)
raise Exception(
"Failed to create the setup required to execute the test "
"cases: %s" % e)
return
def test_01_redundant_vpc_site2site_vpn(self):
"""Test Site 2 Site VPN Across redundant VPCs"""
self.logger.debug("Starting test: test_02_redundant_vpc_site2site_vpn")
# 0) Get the default network offering for VPC
networkOffering = NetworkOffering.list(
self.apiclient, name="DefaultIsolatedNetworkOfferingForVpcNetworks")
self.assert_(networkOffering is not None and len(
networkOffering) > 0, "No VPC based network offering")
# Create and enable redundant VPC offering
redundant_vpc_offering = self._create_vpc_offering(
'redundant_vpc_offering')
self.assert_(redundant_vpc_offering is not None,
"Failed to create redundant VPC Offering")
redundant_vpc_offering.update(self.apiclient, state='Enabled')
# Create VPC 1
vpc1 = None
try:
vpc1 = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc1.vpn",
vpcofferingid=redundant_vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id
)
except Exception as e:
self.fail(e)
finally:
self.assert_(vpc1 is not None, "VPC1 creation failed")
self.logger.debug("VPC1 %s created" % vpc1.id)
# Create VPC 2
vpc2 = None
try:
vpc2 = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc2"],
networkDomain="vpc2.vpn",
vpcofferingid=redundant_vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
except Exception as e:
self.fail(e)
finally:
self.assert_(vpc2 is not None, "VPC2 creation failed")
self.logger.debug("VPC2 %s created" % vpc2.id)
default_acl = NetworkACLList.list(
self.apiclient, name="default_allow")[0]
# Create network in VPC 1
ntwk1 = None
try:
ntwk1 = Network.create(
apiclient=self.apiclient,
services=self.services["network_1"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=networkOffering[0].id,
zoneid=self.zone.id,
vpcid=vpc1.id,
aclid=default_acl.id
)
except Exception as e:
self.fail(e)
finally:
self.assertIsNotNone(ntwk1, "Network failed to create")
self.logger.debug("Network %s created in VPC %s" % (ntwk1.id, vpc1.id))
# Create network in VPC 2
ntwk2 = None
try:
ntwk2 = Network.create(
apiclient=self.apiclient,
services=self.services["network_2"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=networkOffering[0].id,
zoneid=self.zone.id,
vpcid=vpc2.id,
aclid=default_acl.id
)
except Exception as e:
self.fail(e)
finally:
self.assertIsNotNone(ntwk2, "Network failed to create")
self.logger.debug("Network %s created in VPC %s" % (ntwk2.id, vpc2.id))
# Deploy a vm in network 2
vm1 = None
try:
vm1 = VirtualMachine.create(self.apiclient, services=self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.compute_offering.id,
networkids=ntwk1.id,
hypervisor=self.hypervisor
)
except Exception as e:
self.fail(e)
finally:
self.assert_(vm1 is not None, "VM failed to deploy")
self.assert_(vm1.state == 'Running', "VM is not running")
self.logger.debug("VM %s deployed in VPC %s" % (vm1.id, vpc1.id))
# Deploy a vm in network 2
vm2 = None
try:
vm2 = VirtualMachine.create(self.apiclient, services=self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.compute_offering.id,
networkids=ntwk2.id,
hypervisor=self.hypervisor
)
except Exception as e:
self.fail(e)
finally:
self.assert_(vm2 is not None, "VM failed to deploy")
self.assert_(vm2.state == 'Running', "VM is not running")
self.debug("VM %s deployed in VPC %s" % (vm2.id, vpc2.id))
# 4) Enable Site-to-Site VPN for VPC
vpn1_response = Vpn.createVpnGateway(self.apiclient, vpc1.id)
self.assert_(
vpn1_response is not None, "Failed to enable VPN Gateway 1")
self.logger.debug("VPN gateway for VPC %s enabled" % vpc1.id)
vpn2_response = Vpn.createVpnGateway(self.apiclient, vpc2.id)
self.assert_(
vpn2_response is not None, "Failed to enable VPN Gateway 2")
self.logger.debug("VPN gateway for VPC %s enabled" % vpc2.id)
# 5) Add VPN Customer gateway info
src_nat_list = PublicIPAddress.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True,
issourcenat=True,
vpcid=vpc1.id
)
ip1 = src_nat_list[0]
src_nat_list = PublicIPAddress.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True,
issourcenat=True,
vpcid=vpc2.id
)
ip2 = src_nat_list[0]
services = self.services["vpncustomergateway"]
customer1_response = VpnCustomerGateway.create(
self.apiclient, services, "Peer VPC1", ip1.ipaddress, vpc1.cidr, self.account.name, self.domain.id)
self.debug("VPN customer gateway added for VPC %s enabled" % vpc1.id)
self.logger.debug(vars(customer1_response))
customer2_response = VpnCustomerGateway.create(
self.apiclient, services, "Peer VPC2", ip2.ipaddress, vpc2.cidr, self.account.name, self.domain.id)
self.debug("VPN customer gateway added for VPC %s enabled" % vpc2.id)
self.logger.debug(vars(customer2_response))
# 6) Connect two VPCs
vpnconn1_response = Vpn.createVpnConnection(
self.apiclient, customer1_response.id, vpn2_response['id'], True)
self.debug("VPN passive connection created for VPC %s" % vpc2.id)
vpnconn2_response = Vpn.createVpnConnection(
self.apiclient, customer2_response.id, vpn1_response['id'])
self.debug("VPN connection created for VPC %s" % vpc1.id)
self.assertEqual(
vpnconn2_response['state'], "Connected", "Failed to connect between VPCs!")
# acquire an extra ip address to use to ssh into vm2
try:
vm2.public_ip = PublicIPAddress.create(
apiclient=self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
services=self.services,
networkid=ntwk2.id,
vpcid=vpc2.id)
except Exception as e:
self.fail(e)
finally:
self.assert_(
vm2.public_ip is not None, "Failed to aqcuire public ip for vm2")
# Create port forward to be able to ssh into vm2
natrule = None
try:
natrule = self._create_natrule(
vpc2, vm2, 22, 22, vm2.public_ip, ntwk2)
except Exception as e:
self.fail(e)
finally:
self.assert_(
natrule is not None, "Failed to create portforward for vm2")
time.sleep(20)
# setup ssh connection to vm2
ssh_client = self._get_ssh_client(vm2, self.services, 10)
if ssh_client:
# run ping test
packet_loss = ssh_client.execute(
"/bin/ping -c 3 -t 10 " + vm1.nic[0].ipaddress + " |grep packet|cut -d ' ' -f 7| cut -f1 -d'%'")[0]
self.assert_(int(packet_loss) == 0, "Ping did not succeed")
else:
self.fail("Failed to setup ssh connection to %s" % vm2.public_ip)
def setUpClass(cls):
cls.testClient = super(TestVMLifeCycleHostmaintenance, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
clusterWithSufficientHosts = None
clusters = Cluster.list(cls.api_client, zoneid=cls.zone.id)
for cluster in clusters:
cls.hosts = Host.list(cls.api_client, clusterid=cluster.id)
if len(cls.hosts) >= 2:
clusterWithSufficientHosts = cluster
if clusterWithSufficientHosts is None:
raise unittest.SkipTest("No Cluster with 2 hosts found")
Host.update(cls.api_client, id=cls.hosts[0].id, hosttags="hosttag1")
Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="hosttag2")
cls.service_offering_1 = ServiceOffering.create(cls.api_client, cls.services["service_offering_1"])
cls.service_offering_2 = ServiceOffering.create(cls.api_client, cls.services["service_offering_2"])
cls.vpc_off = VpcOffering.create(cls.api_client, cls.services["vpc_offering"])
cls.vpc_off.update(cls.api_client, state="Enabled")
cls.account = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id)
cls.vpc_off = VpcOffering.create(cls.api_client, cls.services["vpc_offering"])
cls.vpc_off.update(cls.api_client, state="Enabled")
cls.services["vpc"]["cidr"] = "10.1.1.1/16"
cls.vpc = VPC.create(
cls.api_client,
cls.services["vpc"],
vpcofferingid=cls.vpc_off.id,
zoneid=cls.zone.id,
account=cls.account.name,
domainid=cls.account.domainid,
)
cls.nw_off = NetworkOffering.create(cls.api_client, cls.services["network_offering"], conservemode=False)
# Enable Network offering
cls.nw_off.update(cls.api_client, state="Enabled")
# Creating network using the network offering created
cls.network_1 = Network.create(
cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.nw_off.id,
zoneid=cls.zone.id,
gateway="10.1.1.1",
vpcid=cls.vpc.id,
)
cls.nw_off_no_lb = NetworkOffering.create(
cls.api_client, cls.services["network_offering_no_lb"], conservemode=False
)
# Enable Network offering
cls.nw_off_no_lb.update(cls.api_client, state="Enabled")
# Creating network using the network offering created
cls.network_2 = Network.create(
cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.nw_off_no_lb.id,
zoneid=cls.zone.id,
gateway="10.1.2.1",
vpcid=cls.vpc.id,
)
# Spawn an instance in that network
cls.vm_1 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_1.id,
networkids=[str(cls.network_1.id)],
)
# Spawn an instance in that network
cls.vm_2 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_1.id,
networkids=[str(cls.network_1.id)],
)
cls.vm_3 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_2.id,
networkids=[str(cls.network_2.id)],
)
routers = Router.list(cls.api_client, account=cls.account.name, domainid=cls.account.domainid, listall=True)
if isinstance(routers, list):
cls.vpcvr = routers[0]
cls._cleanup = [cls.service_offering_1, cls.service_offering_2, cls.nw_off, cls.nw_off_no_lb]
return
def setUpClass(cls):
cls.testClient = super(TestVMLifeCycleHostmaintenance, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
clusterWithSufficientHosts = None
clusters = Cluster.list(cls.api_client, zoneid=cls.zone.id)
for cluster in clusters:
cls.hosts = Host.list(cls.api_client, clusterid=cluster.id)
if len(cls.hosts) >= 2:
clusterWithSufficientHosts = cluster
break
if clusterWithSufficientHosts is None:
raise unittest.SkipTest("No Cluster with 2 hosts found")
Host.update(cls.api_client, id=cls.hosts[0].id, hosttags="hosttag1")
Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="hosttag2")
cls.service_offering_1 = ServiceOffering.create(
cls.api_client,
cls.services["service_offering_1"]
)
cls.service_offering_2 = ServiceOffering.create(
cls.api_client,
cls.services["service_offering_2"]
)
cls.vpc_off = VpcOffering.create(
cls.api_client,
cls.services["vpc_offering"]
)
cls.vpc_off.update(cls.api_client, state='Enabled')
cls.account = Account.create(
cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.vpc_off = VpcOffering.create(
cls.api_client,
cls.services["vpc_offering"]
)
cls.vpc_off.update(cls.api_client, state='Enabled')
cls.services["vpc"]["cidr"] = '10.1.1.1/16'
cls.vpc = VPC.create(
cls.api_client,
cls.services["vpc"],
vpcofferingid=cls.vpc_off.id,
zoneid=cls.zone.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls.nw_off = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=False
)
# Enable Network offering
cls.nw_off.update(cls.api_client, state='Enabled')
# Creating network using the network offering created
cls.network_1 = Network.create(
cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.nw_off.id,
zoneid=cls.zone.id,
gateway='10.1.1.1',
vpcid=cls.vpc.id
)
cls.nw_off_no_lb = NetworkOffering.create(
cls.api_client,
cls.services["network_offering_no_lb"],
conservemode=False
)
# Enable Network offering
cls.nw_off_no_lb.update(cls.api_client, state='Enabled')
# Creating network using the network offering created
cls.network_2 = Network.create(
cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.nw_off_no_lb.id,
zoneid=cls.zone.id,
gateway='10.1.2.1',
vpcid=cls.vpc.id
)
# Spawn an instance in that network
cls.vm_1 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_1.id,
networkids=[str(cls.network_1.id)]
)
# Spawn an instance in that network
cls.vm_2 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_1.id,
networkids=[str(cls.network_1.id)]
)
cls.vm_3 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_2.id,
networkids=[str(cls.network_2.id)]
)
routers = Router.list(
cls.api_client,
account=cls.account.name,
domainid=cls.account.domainid,
listall=True
)
if isinstance(routers, list):
cls.vpcvr = routers[0]
cls._cleanup = [
cls.service_offering_1,
cls.service_offering_2,
cls.nw_off,
cls.nw_off_no_lb,
]
return
def test_01_vpc_remote_access_vpn(self):
"""Test Remote Access VPN in VPC"""
self.logger.debug("Starting test: test_01_vpc_remote_access_vpn")
# 0) Get the default network offering for VPC
self.logger.debug("Retrieving default VPC offering")
networkOffering = NetworkOffering.list(
self.apiclient, name="DefaultIsolatedNetworkOfferingForVpcNetworks")
self.assert_(networkOffering is not None and len(
networkOffering) > 0, "No VPC based network offering")
# 1) Create VPC
vpcOffering = VpcOffering.list(self.apiclient, name="Default VPC offering")
self.assert_(vpcOffering is not None and len(
vpcOffering) > 0, "No VPC offerings found")
vpc = None
try:
vpc = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.vpn",
vpcofferingid=vpcOffering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id
)
except Exception as e:
self.fail(e)
finally:
self.assert_(vpc is not None, "VPC creation failed")
self.logger.debug("VPC %s created" % (vpc.id))
try:
# 2) Create network in VPC
ntwk = Network.create(
apiclient=self.apiclient,
services=self.services["network_1"],
accountid=self.account.name,
domainid=self.domain.id,
networkofferingid=networkOffering[0].id,
zoneid=self.zone.id,
vpcid=vpc.id
)
except Exception as e:
self.fail(e)
finally:
self.assertIsNotNone(ntwk, "Network failed to create")
self.logger.debug(
"Network %s created in VPC %s" % (ntwk.id, vpc.id))
try:
# 3) Deploy a vm
vm = VirtualMachine.create(self.apiclient, services=self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.domain.id,
serviceofferingid=self.compute_offering.id,
networkids=ntwk.id,
hypervisor=self.hypervisor
)
self.assert_(vm is not None, "VM failed to deploy")
self.assert_(vm.state == 'Running', "VM is not running")
self.debug("VM %s deployed in VPC %s" % (vm.id, vpc.id))
except Exception as e:
self.fail(e)
finally:
self.logger.debug("Deployed virtual machine: OK")
try:
# 4) Enable VPN for VPC
src_nat_list = PublicIPAddress.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True,
issourcenat=True,
vpcid=vpc.id
)
ip = src_nat_list[0]
except Exception as e:
self.fail(e)
finally:
self.logger.debug("Acquired public ip address: OK")
try:
vpn = Vpn.create(self.apiclient,
publicipid=ip.id,
account=self.account.name,
domainid=self.account.domainid,
iprange=self.services["vpn"]["iprange"],
fordisplay=self.services["vpn"]["fordisplay"]
)
except Exception as e:
self.fail(e)
finally:
self.assertIsNotNone(vpn, "Failed to create Remote Access VPN")
self.logger.debug("Created Remote Access VPN: OK")
vpnUser = None
# 5) Add VPN user for VPC
try:
vpnUser = VpnUser.create(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
username=self.services["vpn"]["vpn_user"],
password=self.services["vpn"]["vpn_pass"]
)
except Exception as e:
self.fail(e)
finally:
self.assertIsNotNone(
vpnUser, "Failed to create Remote Access VPN User")
self.logger.debug("Created VPN User: OK")
# TODO: Add an actual remote vpn connection test from a remote vpc
try:
# 9) Disable VPN for VPC
vpn.delete(self.apiclient)
except Exception as e:
self.fail(e)
finally:
self.logger.debug("Deleted the Remote Access VPN: OK")
def setup_infra(cls, redundant=False):
if len(cls.class_cleanup) > 0:
cleanup_resources(cls.api_client, cls.class_cleanup, cls.logger)
cls.class_cleanup = []
cls.zone = get_zone(cls.api_client, cls.test_client.getZoneForTests())
cls.logger.debug("Zone '%s' selected" % cls.zone.name)
cls.domain = get_domain(cls.api_client)
cls.logger.debug("Domain '%s' selected" % cls.domain.name)
cls.template = get_template(cls.api_client, cls.zone.id)
cls.logger.debug("Template '%s' selected" % cls.template.name)
cls.account = Account.create(cls.api_client,
cls.attributes['account'],
admin=True,
domainid=cls.domain.id)
cls.class_cleanup += [cls.account]
cls.logger.debug("Account '%s' created", cls.account.name)
cls.vpc_offering = get_default_redundant_vpc_offering(
cls.api_client) if redundant else get_default_vpc_offering(
cls.api_client)
cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name)
cls.network_offering = get_default_network_offering(cls.api_client)
cls.logger.debug("Network Offering '%s' selected",
cls.network_offering.name)
cls.virtual_machine_offering = get_default_virtual_machine_offering(
cls.api_client)
cls.logger.debug("Virtual Machine Offering '%s' selected",
cls.virtual_machine_offering.name)
cls.default_allow_acl = get_network_acl(cls.api_client,
'default_allow')
cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name)
cls.default_deny_acl = get_network_acl(cls.api_client, 'default_deny')
cls.logger.debug("ACL '%s' selected", cls.default_deny_acl.name)
cls.vpc1 = VPC.create(cls.api_client,
cls.attributes['vpcs']['vpc1'],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
account=cls.account.name)
cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name,
cls.vpc1.cidr)
cls.network1 = Network.create(
cls.api_client,
cls.attributes['networks']['network1'],
networkofferingid=cls.network_offering.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc1.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s",
cls.network1.name, cls.network1.cidr,
cls.network1.gateway)
cls.vm1 = VirtualMachine.create(
cls.api_client,
cls.attributes['vms']['vm1'],
templateid=cls.template.id,
serviceofferingid=cls.virtual_machine_offering.id,
networkids=[cls.network1.id],
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("VM '%s' created, Network: %s, IP %s", cls.vm1.name,
cls.network1.name, cls.vm1.nic[0].ipaddress)
cls.public_ip1 = PublicIPAddress.create(cls.api_client,
zoneid=cls.zone.id,
domainid=cls.account.domainid,
accountid=cls.account.name,
vpcid=cls.vpc1.id,
networkid=cls.network1.id)
cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s",
cls.public_ip1.ipaddress.ipaddress, cls.vpc1.name,
cls.network1.name)
cls.nat_rule1 = NATRule.create(cls.api_client,
cls.vm1,
cls.attributes['nat_rule'],
vpcid=cls.vpc1.id,
networkid=cls.network1.id,
ipaddressid=cls.public_ip1.ipaddress.id)
cls.logger.debug("Port Forwarding Rule '%s (%s) %s => %s' created",
cls.nat_rule1.ipaddress, cls.nat_rule1.protocol,
cls.nat_rule1.publicport, cls.nat_rule1.privateport)
def setUp(self):
self.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger()
self.apiclient = self.testClient.getApiClient()
self.services = self.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
self.domain = get_domain(self.apiclient)
self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests())
template = get_template(
self.apiclient,
self.zone.id
)
self.services["virtual_machine"]["zoneid"] = self.zone.id
# Create an account, network, VM and IP addresses
self.account = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id
)
self.vpc_offering = get_default_vpc_offering(self.apiclient)
self.logger.debug("VPC Offering '%s' selected", self.vpc_offering.name)
self.network_offering = get_default_network_offering(self.apiclient)
self.logger.debug("Network Offering '%s' selected", self.network_offering.name)
self.virtual_machine_offering = get_default_virtual_machine_offering(self.apiclient)
self.logger.debug("Virtual Machine Offering '%s' selected", self.virtual_machine_offering.name)
self.default_allow_acl = get_network_acl(self.apiclient, 'default_allow')
self.logger.debug("ACL '%s' selected", self.default_allow_acl.name)
self.template = get_template(self.apiclient, self.zone.id)
self.logger.debug("Template '%s' selected" % self.template.name)
self.vpc1 = VPC.create(self.apiclient,
self.services['vpcs']['vpc1'],
vpcofferingid=self.vpc_offering.id,
zoneid=self.zone.id,
domainid=self.domain.id,
account=self.account.name)
self.logger.debug("VPC '%s' created, CIDR: %s", self.vpc1.name, self.vpc1.cidr)
self.network1 = Network.create(self.apiclient,
self.services['networks']['network1'],
networkofferingid=self.network_offering.id,
aclid=self.default_allow_acl.id,
vpcid=self.vpc1.id,
zoneid=self.zone.id,
domainid=self.domain.id,
accountid=self.account.name)
self.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", self.network1.name, self.network1.cidr, self.network1.gateway)
self.vm1 = VirtualMachine.create(self.apiclient,
self.services['vms']['vm1'],
templateid=self.template.id,
serviceofferingid=self.virtual_machine_offering.id,
networkids=[self.network1.id],
zoneid=self.zone.id,
domainid=self.domain.id,
accountid=self.account.name)
self.logger.debug("VM '%s' created, Network: %s, IP %s", self.vm1.name, self.network1.name, self.vm1.nic[0].ipaddress)
src_nat_ip_addrs = list_public_ip(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
try:
src_nat_ip_addr = src_nat_ip_addrs[0]
except Exception as e:
self.fail("SSH failed for VM with IP: %s %s" %
(src_nat_ip_addr.ipaddress, e))
self.lb_rule = LoadBalancerRule.create(
self.apiclient,
self.services["lbrule"],
src_nat_ip_addr.id,
self.account.name,
self.network1.id,
self.vpc1.id
)
self.lb_rule.assign(self.apiclient, [self.vm1])
self.nat_rule = NATRule.create(
self.apiclient,
self.vm1,
self.services["natrule"],
src_nat_ip_addr.id
)
self.cleanup = []
return
def test_01_create_tier_Vmxnet3(self):
"""
Test to create vpc tier with nic type as Vmxnet3
#1.Set global setting parameter "vmware.systemvm.nic.device.type"
to "Vmxnet3"
#2.Create VPC
#3.Create one tier
#4.Deploy one guest vm in the tier created in step3
"""
if self.hypervisor.lower() not in ['vmware']:
self.skipTest("This test can only run on vmware setup")
nic_types = Configurations.list(
self.apiclient,
name="vmware.systemvm.nic.device.type"
)
self.assertEqual(validateList(nic_types)[0], PASS, "Invalid list config")
nic_type = nic_types[0].value
reset = False
if nic_type.lower() != "vmxnet3":
self.updateConfigurAndRestart("vmware.systemvm.nic.device.type", "Vmxnet3")
reset = True
self.services["vpc"]["cidr"] = "10.1.1.1/16"
self.debug("creating a VPC network in the account: %s" %
self.account.name)
try:
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
vpc_res = VPC.list(self.apiclient, id=vpc.id)
self.assertEqual(validateList(vpc_res)[0], PASS, "Invalid response from listvpc")
self.network_offering = NetworkOffering.create(
self.apiclient,
self.services["network_offering"],
conservemode=False
)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
self.cleanup.append(self.network_offering)
gateway = vpc.cidr.split('/')[0]
# Split the cidr to retrieve gateway
# for eg. cidr = 10.0.0.1/24
# Gateway = 10.0.0.1
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" %
self.network_offering.id)
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id
)
self.debug("Created network with ID: %s" % network.id)
vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)]
)
self.assertIsNotNone(vm, "VM creation failed")
self.debug("Deployed VM in network: %s" % network.id)
vm_res = VirtualMachine.list(self.apiclient, id=vm.id)
self.assertEqual(
validateList(vm_res)[0],
PASS,
"list vm returned invalid response"
)
vr_res = Router.list(
self.apiclient,
vpcid=vpc.id,
listall="true"
)
self.assertEqual(validateList(vr_res)[0], PASS, "list vrs failed for vpc")
vr_linklocal_ip = vr_res[0].linklocalip
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
vr_linklocal_ip,
'lspci | grep "Ethernet controller"',
hypervisor=self.hypervisor
)
self.assertEqual(
validateList(result)[0],
PASS,
"We didn't find NICS with adapter type VMXNET3"
)
reg = re.compile("VMware VMXNET3")
count = 0
for line in result:
if reg.search(line):
count += 1
self.assertEqual(
count,
3,
"Not all NICs on VR are of type VMXNET3"
)
except Exception as e:
self.fail("NIC creation failed for vpc tier with systemvm nic \
adapter type as Vmxnet3: %s" % e)
finally:
if reset:
self.updateConfigurAndRestart("vmware.systemvm.nic.device.type", nic_type)
return
def setUpClass(cls):
cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger()
testClient = super(TestLoadBalance, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.template = get_template(
cls.apiclient,
cls.zone.id
)
if cls.template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services["ostype"]
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
# Create an account, network, VM and IP addresses
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.service_offering = get_default_virtual_machine_offering(cls.apiclient)
cls.network_offering = get_default_network_offering(cls.apiclient)
cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name)
cls.vpc_offering = get_default_vpc_offering(cls.apiclient)
cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name)
cls.vpc1 = VPC.create(cls.apiclient,
cls.services['vpcs']['vpc1'],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
account=cls.account.name)
cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr)
cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow')
cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name)
cls.network1 = Network.create(cls.apiclient,
cls.services['networks']['network1'],
networkofferingid=cls.network_offering.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc1.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway)
cls.vm_1 = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
networkids=[cls.network1.id]
)
cls.vm_2 = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
networkids=[cls.network1.id]
)
cls.vm_3 = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
networkids=[cls.network1.id]
)
cls.non_src_nat_ip = PublicIPAddress.create(cls.apiclient,
zoneid=cls.zone.id,
domainid=cls.account.domainid,
accountid=cls.account.name,
vpcid=cls.vpc1.id,
networkid=cls.network1.id)
cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.non_src_nat_ip.ipaddress.ipaddress, cls.vpc1.name, cls.network1.name)
command = replaceNetworkACLList.replaceNetworkACLListCmd()
command.aclid = cls.default_allow_acl.id
command.publicipid = cls.non_src_nat_ip.ipaddress.id
cls.apiclient.replaceNetworkACLList(command)
cls._cleanup = [
cls.account
]
def test_03_deploy_vms_in_vpc_with_regionlevelvpc(self):
"""Test deploy virtual machines in VPC networks"""
# 1. Create VPC Offering by specifying all supported Services
# (Vpn,dhcpdns,UserData, SourceNat,Static NAT and PF,LB,NetworkAcl)
# 2. Create a VPC using the above VPC offering
# 3. Create a network as part of this VPC.
# 4. Deploy few Vms.
# 5. Create a LB rule for this VM.
# 6. Create a PF rule for this VM.
# 7. Create a Static Nat rule for this VM.
# 8. Create Ingress rules on the network to open the above created
# LB PF and Static Nat rule
# 9. Create Egress Network ACL for this network to access google.com.
# 10. Enable VPN services
if not self.isOvsPluginEnabled:
self.skipTest("OVS plugin should be enabled to run this test case")
self.debug("Creating a VPC offering..")
vpc_off = VpcOffering.create(
self.apiclient,
self.services["vpc_offering"]
)
vpc_off.update(self.apiclient, state='Enabled')
self.debug("creating a VPC network in the account: %s" %
self.account.name)
vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
networkDomain=self.account.domainid
)
self.validate_vpc_network(vpc)
self.network_offering = NetworkOffering.create(
self.apiclient,
self.services["network_offering"],
conservemode=False
)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
gateway = vpc.cidr.split('/')[0]
# Split the cidr to retrieve gateway
# for eg. cidr = 10.0.0.1/24
# Gateway = 10.0.0.1
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" %
self.network_offering.id)
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id
)
self.debug("Created network with ID: %s" % network.id)
# Spawn an instance in that network
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)]
)
self.debug("Deployed VM in network: %s" % network.id)
self.debug("Associating public IP for network: %s" % network.name)
public_ip = PublicIPAddress.create(
self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id,
vpcid=vpc.id
)
self.debug("Associated %s with network %s" % (
public_ip.ipaddress.ipaddress,
network.id
))
self.debug("Creating LB rule for IP address: %s" %
public_ip.ipaddress.ipaddress)
LoadBalancerRule.create(
self.apiclient,
self.services["lbrule"],
ipaddressid=public_ip.ipaddress.id,
accountid=self.account.name,
networkid=network.id,
vpcid=vpc.id,
domainid=self.account.domainid
)
self.debug("Associating public IP for network: %s" % vpc.name)
public_ip_2 = PublicIPAddress.create(
self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id,
vpcid=vpc.id
)
self.debug("Associated %s with network %s" % (
public_ip_2.ipaddress.ipaddress,
network.id
))
NATRule.create(
self.apiclient,
virtual_machine,
self.services["natrule"],
ipaddressid=public_ip_2.ipaddress.id,
openfirewall=False,
networkid=network.id,
vpcid=vpc.id
)
self.debug("Adding NetwrokACl rules to make PF and LB accessible")
NetworkACL.create(
self.apiclient,
networkid=network.id,
services=self.services["natrule"],
traffictype='Ingress'
)
NetworkACL.create(
self.apiclient,
networkid=network.id,
services=self.services["lbrule"],
traffictype='Ingress'
)
self.debug("Checking if we can SSH into VM?")
try:
virtual_machine.get_ssh_client(
ipaddress=public_ip_2.ipaddress.ipaddress,
)
self.debug("SSH into VM is successfully")
except Exception as e:
self.fail("Failed to SSH into VM - %s, %s" %
(public_ip_2.ipaddress.ipaddress, e))
self.debug("Associating public IP for network: %s" % network.name)
public_ip_3 = PublicIPAddress.create(
self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id,
vpcid=vpc.id
)
self.debug("Associated %s with network %s" % (
public_ip_3.ipaddress.ipaddress,
network.id
))
self.debug("Enabling static NAT for IP: %s" %
public_ip_3.ipaddress.ipaddress)
try:
StaticNATRule.enable(
self.apiclient,
ipaddressid=public_ip_3.ipaddress.id,
virtualmachineid=virtual_machine.id,
networkid=network.id
)
self.debug("Static NAT enabled for IP: %s" %
public_ip_3.ipaddress.ipaddress)
except Exception as e:
self.fail("Failed to enable static NAT on IP: %s - %s" % (
public_ip_3.ipaddress.ipaddress, e))
public_ips = PublicIPAddress.list(
self.apiclient,
networkid=network.id,
listall=True,
isstaticnat=True,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(public_ips, list),
True,
"List public Ip for network should list the Ip addr"
)
self.assertEqual(
public_ips[0].ipaddress,
public_ip_3.ipaddress.ipaddress,
"List public Ip for network should list the Ip addr"
)
# TODO: Remote Access VPN is not yet supported in VPC
return
def CreateNetwork(self, networktype):
"""Create a network of given type (isolated/shared/isolated in VPC)"""
network = None
if networktype == ISOLATED_NETWORK:
try:
network = Network.create(
self.apiclient, self.testdata["isolated_network"],
networkofferingid=self.isolated_network_offering.id,
accountid=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id)
self.cleanup.append(network)
except Exception as e:
self.fail("Isolated network creation failed because: %s" % e)
elif networktype == SHARED_NETWORK:
physical_network, vlan = get_free_vlan(self.apiclient, self.zone.id)
# create network using the shared network offering created
self.testdata["shared_network"]["acltype"] = "domain"
self.testdata["shared_network"]["vlan"] = vlan
self.testdata["shared_network"]["networkofferingid"] = \
self.shared_network_offering.id
self.testdata["shared_network"]["physicalnetworkid"] = \
physical_network.id
self.testdata["shared_network"] = \
setSharedNetworkParams(self.testdata["shared_network"])
try:
network = Network.create(
self.apiclient,
self.testdata["shared_network"],
networkofferingid=self.shared_network_offering.id,
zoneid=self.zone.id)
self.cleanup.append(network)
except Exception as e:
self.fail("Shared Network creation failed because: %s" % e)
elif networktype == VPC_NETWORK:
self.testdata["vpc"]["cidr"] = "10.1.1.1/16"
self.debug("creating a VPC network in the account: %s" %
self.account.name)
vpc = VPC.create(self.apiclient,
self.testdata["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.cleanup.append(vpc)
self.vpcid = vpc.id
vpcs = VPC.list(self.apiclient, id=vpc.id)
self.assertEqual(
validateList(vpcs)[0], PASS,
"VPC list validation failed, vpc list is %s" % vpcs
)
network = Network.create(
self.apiclient,
self.testdata["isolated_network"],
networkofferingid=self.isolated_network_offering_vpc.id,
accountid=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id,
vpcid=vpc.id,
gateway="10.1.1.1",
netmask="255.255.255.0")
self.cleanup.append(network)
return network
def setup_infra(cls, redundant=False):
if len(cls.class_cleanup) > 0:
cleanup_resources(cls.api_client, cls.class_cleanup, cls.logger)
cls.class_cleanup = []
cls.zone = get_zone(cls.api_client, cls.test_client.getZoneForTests())
cls.logger.debug("Zone '%s' selected" % cls.zone.name)
cls.domain = get_domain(cls.api_client)
cls.logger.debug("Domain '%s' selected" % cls.domain.name)
cls.template = get_template(
cls.api_client,
cls.zone.id)
cls.logger.debug("Template '%s' selected" % cls.template.name)
cls.account = Account.create(
cls.api_client,
cls.attributes['account'],
admin=True,
domainid=cls.domain.id)
cls.class_cleanup += [cls.account]
cls.logger.debug("Account '%s' created", cls.account.name)
cls.vpc_offering = get_default_redundant_vpc_offering(cls.api_client) if redundant else get_default_vpc_offering(cls.api_client)
cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name)
cls.network_offering = get_default_network_offering(cls.api_client)
cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name)
cls.virtual_machine_offering = get_default_virtual_machine_offering(cls.api_client)
cls.logger.debug("Virtual Machine Offering '%s' selected", cls.virtual_machine_offering.name)
cls.private_network_offering = get_default_private_network_offering(cls.api_client)
cls.logger.debug("Private Network Offering '%s' selected", cls.private_network_offering.name)
cls.default_allow_acl = get_network_acl(cls.api_client, 'default_allow')
cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name)
cls.vpc1 = VPC.create(cls.api_client,
cls.attributes['vpcs']['vpc1'],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
account=cls.account.name)
cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr)
cls.network1 = Network.create(cls.api_client,
cls.attributes['networks']['network1'],
networkofferingid=cls.network_offering.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc1.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway)
cls.vm1 = VirtualMachine.create(cls.api_client,
cls.attributes['vms']['vm1'],
templateid=cls.template.id,
serviceofferingid=cls.virtual_machine_offering.id,
networkids=[cls.network1.id],
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("VM '%s' created, Network: %s, IP %s", cls.vm1.name, cls.network1.name, cls.vm1.nic[0].ipaddress)
cls.public_ip1 = PublicIPAddress.create(cls.api_client,
zoneid=cls.zone.id,
domainid=cls.account.domainid,
accountid=cls.account.name,
vpcid=cls.vpc1.id,
networkid=cls.network1.id)
cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.public_ip1.ipaddress.ipaddress, cls.vpc1.name, cls.network1.name)
cls.nat_rule1 = NATRule.create(cls.api_client,
cls.vm1,
cls.attributes['nat_rule'],
vpcid=cls.vpc1.id,
networkid=cls.network1.id,
ipaddressid=cls.public_ip1.ipaddress.id)
cls.logger.debug("Port Forwarding Rule '%s (%s) %s => %s' created",
cls.nat_rule1.ipaddress,
cls.nat_rule1.protocol,
cls.nat_rule1.publicport,
cls.nat_rule1.privateport)
cls.vpc2 = VPC.create(cls.api_client,
cls.attributes['vpcs']['vpc2'],
vpcofferingid=cls.vpc_offering.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
account=cls.account.name)
cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc2.name, cls.vpc2.cidr)
cls.network2 = Network.create(cls.api_client,
cls.attributes['networks']['network3'],
networkofferingid=cls.network_offering.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc2.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network2.name, cls.network2.cidr, cls.network2.gateway)
cls.vm2 = VirtualMachine.create(cls.api_client,
cls.attributes['vms']['vm2'],
templateid=cls.template.id,
serviceofferingid=cls.virtual_machine_offering.id,
networkids=[cls.network2.id],
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("VM '%s' created, Network: %s, IP: %s", cls.vm2.name, cls.network2.name, cls.vm2.nic[0].ipaddress)
cls.public_ip2 = PublicIPAddress.create(cls.api_client,
zoneid=cls.zone.id,
domainid=cls.account.domainid,
accountid=cls.account.name,
vpcid=cls.vpc2.id,
networkid=cls.network2.id)
cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.public_ip2.ipaddress.ipaddress, cls.vpc2.name, cls.network2.name)
cls.nat_rule2 = NATRule.create(cls.api_client,
cls.vm2,
cls.attributes['nat_rule'],
vpcid=cls.vpc2.id,
networkid=cls.network2.id,
ipaddressid=cls.public_ip2.ipaddress.id)
cls.logger.debug("Port Forwarding Rule '%s (%s) %s => %s' created",
cls.nat_rule2.ipaddress,
cls.nat_rule2.protocol,
cls.nat_rule2.publicport,
cls.nat_rule2.privateport)
cls.private_gateways_network = Network.create(cls.api_client,
cls.attributes['networks']['private_gateways_network'],
networkofferingid=cls.private_network_offering.id,
aclid=cls.default_allow_acl.id,
zoneid=cls.zone.id,
domainid=cls.domain.id,
accountid=cls.account.name)
cls.logger.debug("Network '%s' created, CIDR: %s", cls.private_gateways_network.name, cls.private_gateways_network.cidr)
cls.private_gateway1 = PrivateGateway.create(cls.api_client,
ipaddress=cls.attributes['private_gateways']['private_gateway1'],
networkid=cls.private_gateways_network.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc1.id)
cls.logger.debug("Private Gateway '%s' created, Network: %s, VPC: %s", cls.private_gateway1.ipaddress, cls.private_gateways_network.name, cls.vpc1.name)
cls.static_route1 = StaticRoute.create(cls.api_client,
cls.attributes['static_routes']['static_route1'],
vpcid=cls.vpc1.id)
cls.logger.debug("Static Route '%s => %s' created, VPC: %s", cls.static_route1.cidr, cls.static_route1.nexthop, cls.vpc1.name)
cls.private_gateway2 = PrivateGateway.create(cls.api_client,
ipaddress=cls.attributes['private_gateways']['private_gateway2'],
networkid=cls.private_gateways_network.id,
aclid=cls.default_allow_acl.id,
vpcid=cls.vpc2.id)
cls.logger.debug("Private Gateway '%s' created, Network: %s, VPC: %s", cls.private_gateway2.ipaddress, cls.private_gateways_network.name, cls.vpc2.name)
cls.static_route2 = StaticRoute.create(cls.api_client,
cls.attributes['static_routes']['static_route2'],
vpcid=cls.vpc2.id)
cls.logger.debug("Static Route '%s => %s' created, VPC: %s", cls.static_route2.cidr, cls.static_route2.nexthop, cls.vpc2.name)
def test_01_ip_resouce_count_vpc_network(self):
""" Test IP count in VPC networks
"""
self.debug("Creating a VPC offering..")
vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
self.validate_vpc_offering(vpc_off)
self.debug("Enabling the VPC offering created")
vpc_off.update(self.apiclient, state='Enabled')
self.debug("creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
self.validate_vpc_network(vpc)
nw_off = NetworkOffering.create(self.apiclient,
self.services["network_offering"],
conservemode=False)
# Enable Network offering
nw_off.update(self.apiclient, state='Enabled')
self._cleanup.append(nw_off)
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" % nw_off.id)
network_1 = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway='10.1.1.1',
vpcid=vpc.id)
self.debug("Created network with ID: %s" % network_1.id)
account_list = Account.list(self.apiclient, id=self.account.id)
totalip_1 = account_list[0].iptotal
self.debug("Total IP: %s" % totalip_1)
public_ip_1 = self.acquire_publicip(network_1, vpc)
public_ip_2 = self.acquire_publicip(network_1, vpc)
public_ip_3 = self.acquire_publicip(network_1, vpc)
account_list = Account.list(self.apiclient, id=self.account.id)
totalip = account_list[0].iptotal
self.debug("Total IP: %s" % totalip)
self.assertTrue(totalip - totalip_1 == 3, "publicip count is 3")
self.updateIPCount()
account_list = Account.list(self.apiclient, id=self.account.id)
totalip = account_list[0].iptotal
self.assertTrue(totalip - totalip_1 == 3, "publicip count is 3")
def _test_vpc_site2site_vpn(self, vpc_offering, num_VPCs=3):
# Number of VPNs (to test) is number_of_VPCs - 1
# By default test setting up 2 VPNs from VPC0, requiring total of 3 VPCs
maxnumVM = num_VPCs - 1
# Create VPC i
vpc_list = []
for i in range(num_VPCs):
# Generate VPC (mostly subnet) info
vpcservice_n = copy.deepcopy(self.services["vpcN"])
for key in vpcservice_n.keys():
vpcservice_n[key] = vpcservice_n[key].format(N=` i `)
vpc_n = VPC.create(apiclient=self.apiclient,
services=vpcservice_n,
networkDomain="vpc%d.vpn" % i,
vpcofferingid=vpc_offering.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id)
self.assertIsNotNone(vpc_n, "VPC%d creation failed" % i)
vpc_list.append(vpc_n)
self.cleanup.append(vpc_n)
self.logger.debug("VPC%d %s created" % (i, vpc_list[i].id))
default_acl = NetworkACLList.list(self.apiclient,
name="default_allow")[0]
# Create network in VPC i
ntwk_list = []
for i in range(num_VPCs):
# Generate network (mostly subnet) info
ntwk_info_n = copy.deepcopy(self.services["network_N"])
for key in ntwk_info_n.keys():
ntwk_info_n[key] = ntwk_info_n[key].format(N=` i `)
ntwk_n = Network.create(
apiclient=self.apiclient,
services=ntwk_info_n,
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offerings[0].id,
zoneid=self.zone.id,
vpcid=vpc_list[i].id,
aclid=default_acl.id)
self.assertIsNotNone(ntwk_n, "Network%d failed to create" % i)
self.cleanup.append(ntwk_n)
ntwk_list.append(ntwk_n)
self.logger.debug("Network%d %s created in VPC %s" %
(i, ntwk_list[i].id, vpc_list[i].id))
# Deploy a vm in network i
vm_list = []
vm_n = None
for i in range(num_VPCs):
vm_n = VirtualMachine.create(
self.apiclient,
services=self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.compute_offering.id,
networkids=[ntwk_list[i].id],
hypervisor=self.hypervisor,
mode='advanced' if (i == 0) or (i == maxnumVM) else 'default')
self.assertIsNotNone(vm_n, "VM%d failed to deploy" % i)
self.cleanup.append(vm_n)
vm_list.append(vm_n)
self.logger.debug("VM%d %s deployed in VPC %s" %
(i, vm_list[i].id, vpc_list[i].id))
self.assertEquals(vm_n.state, 'Running', "VM%d is not running" % i)
# 4) Enable Site-to-Site VPN for VPC
vpn_response_list = []
for i in range(num_VPCs):
vpn_response = Vpn.createVpnGateway(self.apiclient, vpc_list[i].id)
self.assertIsNotNone(vpn_response,
"Failed to enable VPN Gateway %d" % i)
vpn_response_list.append(vpn_response)
self.logger.debug("VPN gateway for VPC%d %s enabled" %
(i, vpc_list[i].id))
# 5) Add VPN Customer gateway info
vpn_cust_gw_list = []
services = self.services["vpncustomergateway"]
for i in range(num_VPCs):
src_nat_list = PublicIPAddress.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True,
issourcenat=True,
vpcid=vpc_list[i].id)
ip = src_nat_list[0]
customer_response = VpnCustomerGateway.create(
self.apiclient, services, "Peer VPC" + ` i `, ip.ipaddress,
vpc_list[i].cidr, self.account.name, self.domain.id)
self.cleanup.insert(
0, customer_response
) # this has to be cleaned up after the VPCs have been destroyed (due to client connectionsonections)
vpn_cust_gw_list.append(customer_response)
self.logger.debug(
"VPN customer gateway added for VPC%d %s enabled" %
(i, vpc_list[i].id))
# Before the next step ensure the last VPC is up and running
# Routers in the right state?
self.assertEqual(
self.routers_in_right_state(vpcid=vpc_list[maxnumVM].id), True,
"Check whether the routers are in the right state.")
# 6) Connect VPCi with VPC0
for i in range(num_VPCs)[1:]:
Vpn.createVpnConnection(self.apiclient, vpn_cust_gw_list[0].id,
vpn_response_list[i]['id'], True)
self.logger.debug("VPN passive connection created for VPC%d %s" %
(i, vpc_list[i].id))
vpnconn2_response = Vpn.createVpnConnection(
self.apiclient, vpn_cust_gw_list[i].id,
vpn_response_list[0]['id'])
self.logger.debug("VPN connection created for VPC%d %s" %
(0, vpc_list[0].id))
self.assertEqual(vpnconn2_response['state'], "Connected",
"Failed to connect between VPCs 0 and %d!" % i)
self.logger.debug("VPN connected between VPC0 and VPC%d" % i)
# First the last VM
# setup ssh connection to vm maxnumVM
self.logger.debug(
"Setup SSH connection to last VM created (%d) to ensure availability for ping tests"
% maxnumVM)
ssh_max_client = vm_list[maxnumVM].get_ssh_client(retries=20)
self.assertIsNotNone(
ssh_max_client,
"Failed to setup SSH to last VM created (%d)" % maxnumVM)
self.logger.debug(
"Setup SSH connection to first VM created (0) to ensure availability for ping tests"
)
ssh_client = vm_list[0].get_ssh_client(retries=10)
self.assertIsNotNone(ssh_client, "Failed to setup SSH to VM0")
if ssh_client:
# run ping test
for i in range(num_VPCs)[1:]:
packet_loss = ssh_client.execute(
"/bin/ping -c 3 -t 10 " + vm_list[i].nic[0].ipaddress +
" |grep packet|cut -d ' ' -f 7| cut -f1 -d'%'")[0]
self.assertEquals(
int(packet_loss), 0,
"Ping towards vm" + ` i ` + "did not succeed")
self.logger.debug("Ping from vm0 to vm%d did succeed" % i)
else:
self.fail("Failed to setup ssh connection to %s" %
vm_list[0].public_ip)
return