def test_04_vpc_private_gateway_with_invalid_lswitch(self):
self.logger.debug('Adding NSX device')
self.add_nicira_device(self.nicira_master_controller)
self.logger.debug('Creating VPC offering')
self.vpc_offering = VpcOffering.create(self.api_client, self.vpc_offering_services)
self.vpc_offering.update(self.api_client, state='Enabled')
self.test_cleanup.append(self.vpc_offering)
self.logger.debug('Creating VPC tier offering')
self.vpc_tier_offering = NetworkOffering.create(self.api_client, self.vpc_tier_offering_services, conservemode=False)
self.vpc_tier_offering.update(self.api_client, state='Enabled')
self.test_cleanup.append(self.vpc_tier_offering)
self.logger.debug('Creating private network offering')
self.private_network_offering = NetworkOffering.create(self.api_client, self.private_network_offering_services)
self.private_network_offering.update(self.api_client, state='Enabled')
self.test_cleanup.append(self.private_network_offering)
allow_all_acl_id = 'bd6d44f8-fc11-11e5-8fe8-5254001daa61'
bad_lswitch = 'lswitch:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
vpc = self.create_vpc()
network = self.create_vpc_tier(vpc)
virtual_machine = self.create_virtual_machine(network)
self.logger.debug('Creating private gateway')
with self.assertRaises(CloudstackAPIException) as cm:
self.create_private_gateway(vpc, "10.0.3.99", "10.0.3.100", allow_all_acl_id, bad_lswitch)
the_exception = cm.exception
the_message_matcher = "^.*Refusing to design this network because the specified lswitch (%s) does not exist.*$" % bad_lswitch
self.assertRegexpMatches(str(the_exception), the_message_matcher)
def setUpClass(cls):
cls.testClient = super(TestNetworkMigration, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.test_data = cls.testClient.getParsedTestDataConfig()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["vmware", "kvm"]:
raise unittest.SkipTest("This feature is supported "
"only on Vmware and KVM")
# Get Domain, Zone, Template
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.test_data["ostype"])
cls.services["virtual_machine"]["template"] = cls.template.id
if cls.zone.localstorageenabled:
cls.storagetype = 'local'
cls.test_data["service_offerings"]["tiny"]["storagetype"] = 'local'
else:
cls.storagetype = 'shared'
cls.test_data["service_offerings"]["tiny"][
"storagetype"] = 'shared'
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.test_data["service_offerings"]["tiny"])
# Create Network offering without userdata
cls.network_offering_nouserdata = NetworkOffering.create(
cls.api_client, cls.test_data["network_offering"])
# Enable Network offering
cls.network_offering_nouserdata.update(cls.api_client, state='Enabled')
# Create Network Offering with all the serices
cls.network_offering_all = NetworkOffering.create(
cls.api_client, cls.test_data["isolated_network_offering"])
# Enable Network offering
cls.network_offering_all.update(cls.api_client, state='Enabled')
cls.native_vpc_network_offering = NetworkOffering.create(
cls.api_client,
cls.test_data["nw_offering_isolated_vpc"],
conservemode=False)
cls.native_vpc_network_offering.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering, cls.network_offering_nouserdata,
cls.network_offering_all, cls.native_vpc_network_offering
]
def setUpClass(cls):
testClient = super(TestNestedVirtualization, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls.logger = logging.getLogger('TestNestedVirtualization')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.domain = get_domain(cls.apiclient)
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["tiny"])
cls.account = Account.create(cls.apiclient,
services=cls.services["account"])
cls.template = get_template(cls.apiclient, cls.zone.id,
cls.services["ostype"])
cls.hypervisor = get_hypervisor_type(cls.apiclient)
cls.isolated_network_offering = NetworkOffering.create(
cls.apiclient, cls.services["isolated_network_offering"])
# Enable Isolated Network offering
cls.isolated_network_offering.update(cls.apiclient, state='Enabled')
if cls.template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services[
"ostype"]
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = cls.template.id
cls.cleanup = [cls.account]
def create_network(self, net_offerring, gateway='10.1.1.1',vpc=None):
try:
self.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(self.apiclient,
net_offerring,
conservemode=False
)
# Enable Network offering
nw_off.update(self.apiclient, state='Enabled')
self._cleanup.append(nw_off)
self.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.debug("Created network with ID: %s" % obj_network.id)
return obj_network
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def create_and_enable_network_serviceoffering(self, services):
try:
# Create offering
offering = NetworkOffering.create(self.apiclient,
services,
conservemode=False)
self.assertIsNotNone(offering, "Failed to create network offering")
self.logger.debug("Created network offering: %s" % offering.id)
if offering:
# Enable offeringq
offering.update(self.apiclient, state="Enabled")
self.assertEqual(self.get_networkoffering_state(offering),
"Enabled",
"Failed to enable network offering")
self.logger.debug("Enabled network offering: %s" % offering.id)
self.cleanup.insert(0, offering)
return offering
except Exception as e:
self.fail(
"Failed to create and enable network offering due to %s" % e)
def create_network(self, net_offerring, vpc_id, gateway='10.1.1.1'):
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s to VPC ID %s' %
(self.services["network"], vpc_id))
obj_network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc_id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
raise Exception(
'Unable to create a Network with offering=%s because of %s ' %
(net_offerring, e))
def setUpClass(cls):
testClient = super(TestDomainsNetworkOfferings, cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Create domains
cls.domain_1 = Domain.create(cls.apiclient,
cls.services["acl"]["domain1"])
cls.domain_11 = Domain.create(cls.apiclient,
cls.services["acl"]["domain11"],
parentdomainid=cls.domain_1.id)
cls.domain_2 = Domain.create(cls.apiclient,
cls.services["acl"]["domain2"])
cls.domain_3 = Domain.create(cls.apiclient,
cls.services["acl"]["domain12"])
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
domainid=cls.domain_1.id)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls._cleanup = [
cls.network_offering, cls.domain_11, cls.domain_1, cls.domain_2,
cls.domain_3
]
return
def create_network(self, net_offerring, vpc_id, gateway='10.1.1.1'):
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(
self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s to VPC ID %s' % (self.services["network"], vpc_id))
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc_id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
raise Exception('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def create_network(self, net_offerring, gateway='10.1.1.1', vpc=None, nr_vms=2, mark_net_cleanup=True):
if not nr_vms or nr_vms <= 0:
self.fail("At least 1 VM has to be created. You informed nr_vms < 1")
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(
self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def setUpClass(cls):
cls.testClient = super(TestMaxProjectNetworks, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.domain = get_domain(cls.api_client)
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=True
)
# Enable Network offering
cls.network_offering.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering,
cls.network_offering
]
return
def setUpClass(cls):
testClient = super(TestL2Networks, 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.hypervisor = testClient.getHypervisorInfo()
cls.services['mode'] = cls.zone.networktype
# Create Accounts & networks
cls.account = Account.create(cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.template = get_test_template(cls.apiclient, cls.zone.id,
cls.hypervisor)
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["tiny"])
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["l2-network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls._cleanup = [
cls.account, cls.network_offering, cls.service_offering
]
return
def setUpClass(cls):
cls.testClient = super(TestRedundantRouterNetworkCleanups, 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
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=True
)
# Enable Network offering
cls.network_offering.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering,
cls.network_offering,
]
return
def setUpClass(cls):
cls.testClient = super(TestRedundantIsolateNetworks, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services["mode"] = cls.zone.networktype
cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
# Create an account, network, VM and IP addresses
cls.account = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls.services["nw_off_persistent_RVR"]["egress_policy"] = "true"
cls.network_offering = NetworkOffering.create(
cls.api_client, cls.services["nw_off_persistent_RVR"], conservemode=True
)
cls.network_offering.update(cls.api_client, state="Enabled")
cls._cleanup = [cls.service_offering, cls.network_offering]
cls.logger = logging.getLogger("TestRedundantIsolateNetworks")
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
return
def createEnabledNetworkOffering(apiclient, networkServices):
"""Create and enable network offering according to the type
@output: List, containing [ Result,Network Offering,Reason ]
Ist Argument('Result') : FAIL : If exception or assertion error occurs
PASS : If network offering
is created and enabled successfully
IInd Argument(Net Off) : Enabled network offering
In case of exception or
assertion error, it will be None
IIIrd Argument(Reason) : Reason for failure,
default to None
"""
try:
resultSet = [FAIL, None, None]
# Create network offering
network_offering = NetworkOffering.create(apiclient, networkServices, conservemode=False)
# Update network offering state from disabled to enabled.
NetworkOffering.update(network_offering, apiclient, id=network_offering.id,
state="enabled")
except Exception as e:
resultSet[2] = e
return resultSet
return [PASS, network_offering, None]
def test_01_create_network_offering(self):
"""Test to create network offering
# Validate the following:
# 1. createNetworkOfferings should return valid info for new offering
# 2. The Cloud Database contains the valid information
"""
offering_data_domainid = "{0},{1}".format(self.domain_11.id,
self.domain_2.id)
network_offering = NetworkOffering.create(
self.apiclient,
self.services["network_offering"],
domainid=offering_data_domainid)
self.cleanup.append(network_offering)
self.debug("Created Network offering with ID: %s" %
network_offering.id)
cmd = listNetworkOfferings.listNetworkOfferingsCmd()
cmd.id = network_offering.id
list_network_response = self.apiclient.listNetworkOfferings(cmd)
self.assertEqual(isinstance(list_network_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_network_response), 0,
"Check Network offering is created")
network_response = list_network_response[0]
self.assertEqual(network_response.id, network_offering.id,
"Check server id in createNetworkOffering")
self.assertCountEqual(network_response.domainid.split(","),
offering_data_domainid.split(","),
"Check domainid in createNetworkOffering")
return
def setUpClass(cls):
testClient = super(TestIsolatedNetworkInvalidGw, 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.services['mode'] = cls.zone.networktype
# Create Accounts
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"]["networkoffering"] = cls.network_offering.id
cls._cleanup = [
cls.account,
cls.network_offering
]
return
def create_network(self, net_offerring, gateway='10.1.1.1', vpc=None, nr_vms=2, mark_net_cleanup=True):
if not nr_vms or nr_vms <= 0:
self.fail("At least 1 VM has to be created. You informed nr_vms < 1")
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(
self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def setUpClass(cls):
cls.testClient = super(TestRedundantRouterNetworkCleanups,
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
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=True)
# Enable Network offering
cls.network_offering.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering,
cls.network_offering,
]
return
def setUpClass(cls):
cls.testClient = super(TestMaxProjectNetworks, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.domain = get_domain(cls.api_client)
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=True
)
# Enable Network offering
cls.network_offering.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering,
cls.network_offering
]
return
def setUpClass(cls):
testClient = super(TestIsolatedNetworkInvalidGw,
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.services['mode'] = cls.zone.networktype
# Create Accounts
cls.account = Account.create(cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"]["networkoffering"] = cls.network_offering.id
cls._cleanup = [cls.account, cls.network_offering]
return
def create_network(self, net_offerring, gateway='10.1.1.1', vpc=None):
try:
self.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self._cleanup.append(nw_off)
self.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id)
self.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
self.fail(
'Unable to create a Network with offering=%s because of %s ' %
(net_offerring, e))
def setUpClass(cls):
cls.testClient = super(TestDeployVmWithUserDataMultiNic,
cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.test_data = cls.testClient.getParsedTestDataConfig()
# Get Domain, Zone, Template
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.test_data["ostype"])
if cls.zone.localstorageenabled:
cls.storagetype = 'local'
cls.test_data["service_offerings"]["tiny"]["storagetype"] = 'local'
else:
cls.storagetype = 'shared'
cls.test_data["service_offerings"]["tiny"][
"storagetype"] = 'shared'
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.test_data["service_offerings"]["tiny"])
# Create Network offering without userdata
cls.network_offering_nouserdata = NetworkOffering.create(
cls.api_client, cls.test_data["network_offering"])
# Enable Network offering
cls.network_offering_nouserdata.update(cls.api_client, state='Enabled')
# Create Network Offering with all the serices
cls.network_offering_all = NetworkOffering.create(
cls.api_client, cls.test_data["isolated_network_offering"])
# Enable Network offering
cls.network_offering_all.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering, cls.network_offering_nouserdata,
cls.network_offering_all
]
# Generate userdata of 2500 bytes. This is larger than the 2048 bytes limit.
# CS however allows for upto 4K bytes in the code. So this must succeed.
# Overall, the query length must not exceed 4K, for then the json decoder
# will fail this operation at the marvin client side itcls.
cls.userdata = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(2500))
def setUpClass(cls):
cls._cleanup = []
cls.testClient = super(TestNuageVsp, 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"])
# nuage vsp device brings the Nuage virtual service platform into play
cls.nuage_services = cls.services["nuage_vsp_device"]
try:
resp = listPhysicalNetworks.listPhysicalNetworksCmd()
resp.zoneid = cls.zone.id
physical_networks = cls.api_client.listPhysicalNetworks(resp)
if isinstance(physical_networks, list):
physical_network = physical_networks[0]
resp = listNetworkServiceProviders.listNetworkServiceProvidersCmd()
resp.name = 'NuageVsp'
resp.physicalnetworkid = physical_network.id
nw_service_providers = cls.api_client.listNetworkServiceProviders(
resp)
if not isinstance(nw_service_providers, list):
# create network service provider and add nuage vsp device
resp_add_nsp =\
addNetworkServiceProvider.addNetworkServiceProviderCmd()
resp_add_nsp.name = 'NuageVsp'
resp_add_nsp.physicalnetworkid = physical_network.id
cls.api_client.addNetworkServiceProvider(resp_add_nsp)
resp_add_device = addNuageVspDevice.addNuageVspDeviceCmd()
resp_add_device.physicalnetworkid = physical_network.id
resp_add_device.username = cls.nuage_services["username"]
resp_add_device.password = cls.nuage_services["password"]
resp_add_device.hostname = cls.nuage_services["hostname"]
resp_add_device.apiversion = cls.nuage_services["apiversion"]
resp_add_device.retrycount = cls.nuage_services["retrycount"]
resp_add_device.retryinterval = cls.nuage_services[
"retryinterval"]
cls.nuage = cls.api_client.addNuageVspDevice(resp_add_device)
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=True)
cls._cleanup.append(cls.network_offering)
cls.network_offering.update(cls.api_client, state='Enabled')
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._cleanup.append(cls.service_offering)
except Exception as e:
cls.tearDownClass()
raise Exception("Warning: Exception in setUpClass: %s" % e)
return
def create_network_offering(cls, network_offering_type):
network_offering = NetworkOffering.create(
cls.api_client,
cls.services[network_offering_type],
conservemode=False)
# Update network offering state from disabled to enabled.
NetworkOffering.update(network_offering,
cls.api_client,
id=network_offering.id,
state="enabled")
return network_offering
def setUpClass(cls):
cls.apiclient = super(TestASASetup,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.network_offering = NetworkOffering.create(
cls.apiclient, cls.services["network_offering"], conservemode=True)
# Enable network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls._cleanup = [
cls.network_offering,
]
return
def createIpv6NetworkOfferingInternal(self, is_redundant, egressdefaultpolicy=True):
ipv6_service = self.services["network_offering"]
if is_redundant:
ipv6_service = self.services["nw_off_isolated_RVR"]
ipv6_service["internetprotocol"] = "dualstack"
if egressdefaultpolicy:
ipv6_service["egress_policy"] = egressdefaultpolicy
network_offering = NetworkOffering.create(
self.apiclient,
ipv6_service
)
network_offering.update(self.apiclient, state='Enabled')
return network_offering
def test_04_vpc_private_gateway_with_invalid_lswitch(self):
self.logger.debug('Adding NSX device')
self.add_nicira_device(self.nicira_master_controller)
self.logger.debug('Creating VPC offering')
self.vpc_offering = VpcOffering.create(self.api_client,
self.vpc_offering_services)
self.vpc_offering.update(self.api_client, state='Enabled')
self.test_cleanup.append(self.vpc_offering)
self.logger.debug('Creating VPC tier offering')
self.vpc_tier_offering = NetworkOffering.create(
self.api_client,
self.vpc_tier_offering_services,
conservemode=False)
self.vpc_tier_offering.update(self.api_client, state='Enabled')
self.test_cleanup.append(self.vpc_tier_offering)
self.logger.debug('Creating private network offering')
self.private_network_offering = NetworkOffering.create(
self.api_client, self.private_network_offering_services)
self.private_network_offering.update(self.api_client, state='Enabled')
self.test_cleanup.append(self.private_network_offering)
allow_all_acl_id = 'bd6d44f8-fc11-11e5-8fe8-5254001daa61'
bad_lswitch = 'lswitch:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
vpc = self.create_vpc()
network = self.create_vpc_tier(vpc)
virtual_machine = self.create_virtual_machine(network)
self.logger.debug('Creating private gateway')
with self.assertRaises(CloudstackAPIException) as cm:
self.create_private_gateway(vpc, "10.0.3.99", "10.0.3.100",
allow_all_acl_id, bad_lswitch)
the_exception = cm.exception
the_message_matcher = "^.*Refusing to design this network because the specified lswitch (%s) does not exist.*$" % bad_lswitch
self.assertRegexpMatches(str(the_exception), the_message_matcher)
def create_NetworkOffering(self, net_offering, suffix=None, conserve_mode=False):
self.debug("Creating Network offering")
if suffix:
net_offering["name"] = "NET_OFF-" + str(suffix)
nw_off = NetworkOffering.create(self.api_client,
net_offering,
conservemode=conserve_mode
)
# Enable Network offering
nw_off.update(self.api_client, state="Enabled")
self.cleanup.append(nw_off)
self.debug("Created and Enabled Network offering")
return nw_off
def test_04_network_without_domain_CS19303(self):
"""
@Desc: Errors editing a network without a network domain specified
@Steps:
Step1: Create a network offering with SourceNAT,staticNAT and dhcp services
Step2: Verify the network offering creation
Step3: Create an isolated network with the offering created in step1 and without a network domain specified
Step4: Verify the network creation
Step5: Edit the network and verify that updating network should not error out
"""
self.debug(
"Creating n/w offering with SourceNat,StaticNat and DHCP services in VR & conserve mode:off"
)
self.network_offering = NetworkOffering.create(
self.api_client,
self.services["network_offering_withoutDNS"],
conservemode=False
)
self.assertIsNotNone(
self.network_offering,
"Failed to create NO with Sourcenat,staticnat and dhcp only services"
)
self.cleanup.append(self.network_offering)
self.debug("Created n/w offering with ID: %s" % self.network_offering.id)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
self.debug("Creating nw without dns service using no id: %s" % self.network_offering.id)
self.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
)
self.assertIsNotNone(
self.network,
"Failed to create network without DNS service and network domain"
)
self.debug("Created network with NO: %s" % self.network_offering.id)
try:
self.network_update = self.network.update(
self.apiclient,
name="NW without nw domain"
)
self.debug("Success:Network update has been successful without network domain")
except Exception as e:
self.fail("Error editing a network without network domain specified: %s" % e)
return
def setUpClass(cls):
cls.testClient = super(TestRedundantIsolateNetworks, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
# Create an account, network, VM and IP addresses
cls.account = Account.create(
cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.services["nw_off_persistent_RVR"]["egress_policy"] = "true"
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["nw_off_persistent_RVR"],
conservemode=True
)
cls.network_offering.update(cls.api_client, state='Enabled')
cls._cleanup = [
cls.service_offering,
cls.network_offering,
]
cls.logger = logging.getLogger('TestRedundantIsolateNetworks')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
return
def setUpClass(cls):
try:
testClient = super(TestGatewayOnSharedNetwork,
cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls._cleanup = []
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.hypervisor = testClient.getHypervisorInfo()
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
builtin_info = get_builtin_template_info(cls.apiclient,
cls.zone.id)
cls.services["template"]["url"] = builtin_info[0]
cls.services["template"]["hypervisor"] = builtin_info[1]
cls.services["template"]["format"] = builtin_info[2]
cls.template = get_template(cls.apiclient, cls.zone.id)
# # Register new template
# cls.template = Template.register(
# cls.apiclient,
# cls.services["template"],
# zoneid=cls.zone.id,
# hypervisor=cls.hypervisor
# )
# cls._cleanup.append(cls.template)
cls.services["shared_network_offering"]["specifyVlan"] = "True"
cls.services["shared_network_offering"]["specifyIpRanges"] = "True"
cls.shared_network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["shared_network_offering"],
conservemode=False)
cls._cleanup.append(cls.shared_network_offering)
NetworkOffering.update(cls.shared_network_offering,
cls.apiclient,
id=cls.shared_network_offering.id,
state="enabled")
except Exception as e:
cls.tearDownClass()
raise unittest.SkipTest("Exception in setUpClass: %s" % e)
def setUpClass(cls):
cls.testClient = super(TestDeployVmWithUserDataMultiNic, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.test_data = cls.testClient.getParsedTestDataConfig()
# Get Domain, Zone, Template
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.test_data["ostype"])
if cls.zone.localstorageenabled:
cls.storagetype = "local"
cls.test_data["service_offerings"]["tiny"]["storagetype"] = "local"
else:
cls.storagetype = "shared"
cls.test_data["service_offerings"]["tiny"]["storagetype"] = "shared"
cls.service_offering = ServiceOffering.create(cls.api_client, cls.test_data["service_offerings"]["tiny"])
# Create Network offering without userdata
cls.network_offering_nouserdata = NetworkOffering.create(cls.api_client, cls.test_data["network_offering"])
# Enable Network offering
cls.network_offering_nouserdata.update(cls.api_client, state="Enabled")
# Create Network Offering with all the serices
cls.network_offering_all = NetworkOffering.create(cls.api_client, cls.test_data["isolated_network_offering"])
# Enable Network offering
cls.network_offering_all.update(cls.api_client, state="Enabled")
cls._cleanup = [cls.service_offering, cls.network_offering_nouserdata, cls.network_offering_all]
# Generate userdata of 2500 bytes. This is larger than the 2048 bytes limit.
# CS however allows for upto 4K bytes in the code. So this must succeed.
# Overall, the query length must not exceed 4K, for then the json decoder
# will fail this operation at the marvin client side itcls.
cls.userdata = "".join(random.choice(string.ascii_uppercase + string.digits) for x in range(2500))
def test_baremetal(self):
self.debug("Test create baremetal network offering")
networkoffering = NetworkOffering.create(
self.apiclient, self.services["network_offering"])
networkoffering.update(self.apiclient, state="Enabled")
self.cleanup.append(networkoffering)
physical_network = PhysicalNetwork.list(self.apiclient,
zoneid=self.zoneid)[0]
dhcp_provider = NetworkServiceProvider.list(
self.apiclient,
name="BaremetalDhcpProvider",
physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(self.apiclient,
id=dhcp_provider.id,
state='Enabled')
pxe_provider = NetworkServiceProvider.list(
self.apiclient,
name="BaremetalPxeProvider",
physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(self.apiclient,
id=pxe_provider.id,
state='Enabled')
userdata_provider = NetworkServiceProvider.list(
self.apiclient,
name="BaremetalUserdataProvider",
physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(self.apiclient,
id=userdata_provider.id,
state='Enabled')
network = Network.create(self.apiclient,
self.services["network"],
zoneid=self.zoneid,
networkofferingid=networkoffering.id)
self.cleanup.insert(0, network)
pod = Pod.list(self.apiclient)[0]
cmd = createVlanIpRange.createVlanIpRangeCmd()
cmd.podid = pod.id
cmd.networkid = network.id
cmd.gateway = "10.1.1.1"
cmd.netmask = "255.255.255.0"
cmd.startip = "10.1.1.20"
cmd.endip = "10.1.1.40"
cmd.forVirtualNetwork = "false"
self.apiclient.createVlanIpRange(cmd)
def setUpClass(cls):
cls.apiclient = super(
TestASASetup,
cls
).getClsTestClient().getApiClient()
cls.services = Services().services
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
conservemode=True)
# Enable network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls._cleanup = [
cls.network_offering,
]
return
def setUpClass(cls):
testClient = super(TestPublicIP, 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.services['mode'] = cls.zone.networktype
# Create Accounts & networks
cls.account = Account.create(cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.user = Account.create(cls.apiclient,
cls.services["account"],
domainid=cls.domain.id)
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"]["networkoffering"] = cls.network_offering.id
cls.account_network = Network.create(cls.apiclient,
cls.services["network"],
cls.account.name,
cls.account.domainid)
cls.user_network = Network.create(cls.apiclient,
cls.services["network"],
cls.user.name, cls.user.domainid)
# Create Source NAT IP addresses
PublicIPAddress.create(cls.apiclient, cls.account.name, cls.zone.id,
cls.account.domainid)
PublicIPAddress.create(cls.apiclient, cls.user.name, cls.zone.id,
cls.user.domainid)
cls._cleanup = [
cls.account_network, cls.user_network, cls.account, cls.user,
cls.network_offering
]
return
def setUpClass(cls):
cls.testClient = super(TestAdapterTypeForNic, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.testdata = cls.testClient.getParsedTestDataConfig()
cls.hypervisor = get_hypervisor_type(cls.api_client)
# 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.testdata["ostype"])
# Create Accounts & networks
cls.testdata["isolated_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(
cls.api_client,
cls.testdata["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.userapiclient = cls.testClient.getUserApiClient(
UserName=cls.account.name,
DomainName=cls.account.domain
)
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.testdata["service_offering"])
cls._cleanup.append(cls.service_offering)
# Create Shared Network Offering
cls.isolated_network_offering = NetworkOffering.create(
cls.api_client,
cls.testdata["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
# Enable Isolated Network offering
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
return
def setUpClass(cls):
cls.testClient = super(TestDirectDownloadTemplates,
cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.dbclient = cls.testClient.getDbConnection()
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.pod = get_pod(cls.apiclient, cls.zone.id)
cls.services = cls.testClient.getParsedTestDataConfig()
cls._cleanup = []
cls.hypervisorNotSupported = False
if cls.hypervisor.lower() not in ['kvm', 'lxc']:
cls.hypervisorNotSupported = True
if not cls.hypervisorNotSupported:
cls.services["test_templates"]["kvm"]["directdownload"] = "true"
cls.template = Template.register(
cls.apiclient,
cls.services["test_templates"]["kvm"],
zoneid=cls.zone.id,
hypervisor=cls.hypervisor)
cls._cleanup.append(cls.template)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.services["virtual_machine"]["hypervisor"] = cls.hypervisor
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["tiny"])
cls._cleanup.append(cls.service_offering)
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["l2-network_offering"],
)
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"][
"networkoffering"] = cls.network_offering.id
cls.l2_network = Network.create(
cls.apiclient,
cls.services["l2-network"],
zoneid=cls.zone.id,
networkofferingid=cls.network_offering.id)
cls._cleanup.append(cls.l2_network)
cls._cleanup.append(cls.network_offering)
return
def test_01_create_ipv6_network_offering(self):
"""Test to create network offering
# Validate the following:
# 1. createNetworkOffering should return valid info for new offering
# 2. The Cloud Database contains the valid information
"""
Configurations.update(self.apiclient,
ipv6_offering_config_name,
"true")
ipv6_service = self.services["network_offering"]
ipv6_service["internetprotocol"] = "dualstack"
network_offering = NetworkOffering.create(
self.apiclient,
ipv6_service
)
self.cleanup.append(network_offering)
self.debug("Created Network offering with ID: %s" % network_offering.id)
list_network_off_response = NetworkOffering.list(self.apiclient,
id=network_offering.id)
self.assertEqual(
isinstance(list_network_off_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_network_off_response),
0,
"Check Network offering is created"
)
network_off_response = list_network_off_response[0]
self.assertEqual(
network_off_response.id,
network_offering.id,
"Check server id in listNetworkOfferings"
)
self.assertEqual(
network_off_response.internetprotocol.lower(),
ipv6_service["internetprotocol"].lower(),
"Check internetprotocol in listNetworkOfferings"
)
return
def create_network_offering(self, egress_policy=True, RR=False):
if egress_policy:
self.services["network_offering"]["egress_policy"] = "true"
else:
self.services["network_offering"]["egress_policy"] = "false"
if RR:
self.debug("Redundant Router Enabled")
self.services["network_offering"]["serviceCapabilityList"]["SourceNat"]["RedundantRouter"] = "true"
self.network_offering = NetworkOffering.create(self.apiclient,
self.services["network_offering"],
conservemode=True)
# Cleanup
self.cleanup.append(self.network_offering)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
def setUpClass(cls):
testClient = super(TestL2Networks, 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.hypervisor = testClient.getHypervisorInfo()
cls.services['mode'] = cls.zone.networktype
# Create Accounts & networks
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.template = get_test_template(
cls.apiclient,
cls.zone.id,
cls.hypervisor
)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["l2-network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls._cleanup = [
cls.account,
cls.network_offering,
cls.service_offering
]
return
def create_network_offering(self, egress_policy=True, RR=False):
if egress_policy:
self.services["network_offering"]["egress_policy"] = "true"
else:
self.services["network_offering"]["egress_policy"] = "false"
if RR:
self.debug("Redundant Router Enabled")
self.services["network_offering"]["serviceCapabilityList"][
"SourceNat"]["RedundantRouter"] = "true"
self.network_offering = NetworkOffering.create(
self.apiclient,
self.services["network_offering"],
conservemode=True)
# Cleanup
self.cleanup.append(self.network_offering)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
def test_02_create_ipv6_network_offering_fail(self):
"""Test to create network offering
# Validate the following:
# 1. createNetworkOffering should fail
"""
Configurations.update(self.apiclient,
ipv6_offering_config_name,
"false")
ipv6_service = self.services["network_offering"]
ipv6_service["internetprotocol"] = "dualstack"
try:
network_offering = NetworkOffering.create(
self.apiclient,
ipv6_service
)
self.cleanup.append(network_offering)
self.fail("Network offering created despite global setting - %s set to false" % ipv6_offering_config_name)
except CloudstackAPIException as e:
self.debug("Network offering creation failed as expected %s " % e)
return
def test_baremetal(self):
self.debug("Test create baremetal network offering")
networkoffering = NetworkOffering.create(self.apiclient, self.services["network_offering"])
networkoffering.update(self.apiclient, state="Enabled")
self.cleanup.append(networkoffering)
physical_network = PhysicalNetwork.list(self.apiclient, zoneid=self.zoneid)[0];
dhcp_provider = NetworkServiceProvider.list(self.apiclient, name="BaremetalDhcpProvider", physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(
self.apiclient,
id=dhcp_provider.id,
state='Enabled'
)
pxe_provider = NetworkServiceProvider.list(self.apiclient, name="BaremetalPxeProvider", physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(
self.apiclient,
id=pxe_provider.id,
state='Enabled'
)
userdata_provider = NetworkServiceProvider.list(self.apiclient, name="BaremetalUserdataProvider", physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(
self.apiclient,
id=userdata_provider.id,
state='Enabled'
)
network = Network.create(self.apiclient, self.services["network"], zoneid=self.zoneid, networkofferingid=networkoffering.id)
self.cleanup.insert(0, network)
pod = Pod.list(self.apiclient)[0]
cmd = createVlanIpRange.createVlanIpRangeCmd()
cmd.podid = pod.id
cmd.networkid = network.id
cmd.gateway = "10.1.1.1"
cmd.netmask = "255.255.255.0"
cmd.startip = "10.1.1.20"
cmd.endip = "10.1.1.40"
cmd.forVirtualNetwork="false"
self.apiclient.createVlanIpRange(cmd)
def create_and_enable_network_serviceoffering(self, services):
try:
# Create offering
offering = NetworkOffering.create(
self.apiclient, services, conservemode=False)
self.assertIsNotNone(offering, "Failed to create network offering")
self.logger.debug("Created network offering: %s" % offering.id)
if offering:
# Enable offeringq
offering.update(self.apiclient, state="Enabled")
self.assertEqual(self.get_networkoffering_state(
offering), "Enabled", "Failed to enable network offering")
self.logger.debug("Enabled network offering: %s" % offering.id)
return offering
except Exception as e:
self.fail("Failed to create and enable network offering: %s because of %s" % (
offering_name, e))
def setUpClass(cls):
testClient = super(TestNestedVirtualization, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls.logger = logging.getLogger('TestNestedVirtualization')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.hypervisor = get_hypervisor_type(cls.apiclient)
cls.services['mode'] = cls.zone.networktype
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.domain = get_domain(cls.apiclient)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls.account = Account.create(cls.apiclient, services=cls.services["account"])
cls.template = get_test_template(
cls.apiclient,
cls.zone.id,
cls.hypervisor
)
cls.isolated_network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["isolated_network_offering"])
# Enable Isolated Network offering
cls.isolated_network_offering.update(cls.apiclient, state='Enabled')
if cls.template == FAILED:
assert False, "get_test_template() failed to return template"
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = cls.template.id
cls.cleanup = [cls.account]
def setUpClass(cls):
cls.testClient = super(TestAdapterTypeForNic, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.testdata = cls.testClient.getParsedTestDataConfig()
cls.hypervisor = get_hypervisor_type(cls.api_client)
# 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_test_template(cls.api_client, cls.zone.id,
cls.hypervisor)
# Create Accounts & networks
cls.testdata["isolated_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(cls.api_client,
cls.testdata["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.userapiclient = cls.testClient.getUserApiClient(
UserName=cls.account.name, DomainName=cls.account.domain)
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.testdata["service_offering"])
cls._cleanup.append(cls.service_offering)
# Create Shared Network Offering
cls.isolated_network_offering = NetworkOffering.create(
cls.api_client, cls.testdata["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
# Enable Isolated Network offering
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
return
def setUpClass(cls):
testClient = super(TestUnmanageVM, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls.hypervisor = testClient.getHypervisorInfo()
cls._cleanup = []
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.template = get_suitable_test_template(cls.apiclient, cls.zone.id,
cls.services["ostype"],
cls.hypervisor)
if cls.template == FAILED:
assert False, "get_suitable_test_template() failed to return template with description %s" % cls.services[
"ostype"]
cls.hypervisorNotSupported = cls.hypervisor.lower() != "vmware"
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = cls.template.id
cls.account = Account.create(cls.apiclient,
cls.services["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.small_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["small"])
cls._cleanup.append(cls.small_offering)
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["l2-network_offering"],
)
cls._cleanup.append(cls.network_offering)
cls.network_offering.update(cls.apiclient, state='Enabled')
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):
testClient = super(TestPublicIP, 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.services['mode'] = cls.zone.networktype
# Create Accounts & networks
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.user = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"]["networkoffering"] = cls.network_offering.id
cls.account_network = Network.create(
cls.apiclient,
cls.services["network"],
cls.account.name,
cls.account.domainid
)
cls.user_network = Network.create(
cls.apiclient,
cls.services["network"],
cls.user.name,
cls.user.domainid
)
# Create Source NAT IP addresses
PublicIPAddress.create(
cls.apiclient,
cls.account.name,
cls.zone.id,
cls.account.domainid
)
PublicIPAddress.create(
cls.apiclient,
cls.user.name,
cls.zone.id,
cls.user.domainid
)
cls._cleanup = [
cls.account_network,
cls.user_network,
cls.account,
cls.user,
cls.network_offering
]
return
def setUp(self):
self.cleanup = []
self.logger = logging.getLogger('TestNIC')
self.stream_handler = logging.StreamHandler()
self.logger.setLevel(logging.DEBUG)
self.logger.addHandler(self.stream_handler)
def signal_handler(signal, frame):
self.tearDown()
sys.exit(0)
# assign the signal handler immediately
signal.signal(signal.SIGINT, signal_handler)
self.hypervisor = self.testClient.getHypervisorInfo()
if self.hypervisor.lower() == "hyperv":
self.skipTest("Not supported on Hyper-V")
try:
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.services = self.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
domain = get_domain(self.apiclient)
self.zone = get_zone(
self.apiclient,
self.testClient.getZoneForTests()
)
# if local storage is enabled, alter the offerings to use
# localstorage
# this step is needed for devcloud
if self.zone.localstorageenabled:
self.services["service_offerings"][
"tiny"]["storagetype"] = 'local'
template = get_template(
self.apiclient,
self.zone.id,
self.services["ostype"]
)
# Set Zones and disk offerings
self.services["small"]["zoneid"] = self.zone.id
self.services["small"]["template"] = template.id
self.services["iso1"]["zoneid"] = self.zone.id
self.services["network"]["zoneid"] = self.zone.id
# Create Account, VMs, NAT Rules etc
self.account = Account.create(
self.apiclient,
self.services["account"],
domainid=domain.id
)
self.cleanup.insert(0, self.account)
self.service_offering = ServiceOffering.create(
self.apiclient,
self.services["service_offerings"]["tiny"]
)
self.cleanup.insert(0, self.service_offering)
####################
# Network offering
self.network_offering = NetworkOffering.create(
self.apiclient,
self.services["network_offering"],
)
self.cleanup.insert(0, self.network_offering)
self.network_offering.update(
self.apiclient,
state='Enabled') # Enable Network offering
self.services["network"][
"networkoffering"] = self.network_offering.id
self.network_offering_shared = NetworkOffering.create(
self.apiclient,
self.services["network_offering_shared"],
)
self.cleanup.insert(0, self.network_offering_shared)
self.network_offering_shared.update(
self.apiclient,
state='Enabled') # Enable Network offering
self.services["network2"][
"networkoffering"] = self.network_offering_shared.id
################
# Test Network
self.test_network = Network.create(
self.apiclient,
self.services["network"],
self.account.name,
self.account.domainid,
)
self.cleanup.insert(0, self.test_network)
self.test_network2 = Network.create(
self.apiclient,
self.services["network2"],
self.account.name,
self.account.domainid,
zoneid=self.services["network"]["zoneid"]
)
self.cleanup.insert(0, self.test_network2)
except Exception as ex:
self.debug("Exception during NIC test SETUP!: " + str(ex))
def test_03_nic_multiple_vmware(self):
"""Test to adding multiple nics to a VMware VM and restarting VM
Refer to CLOUDSTACK-10107 for details, in this test we add 8 nics to
a VM and stop, start it to show that VMware VMs are not limited to
having up to 7 nics.
"""
if self.hypervisor.lower() != "vmware":
self.skipTest("Skipping test applicable for VMware")
network_offering = NetworkOffering.create(
self.apiclient,
self.services["nw_off_isolated_persistent"]
)
self.cleanup.insert(0, network_offering)
network_offering.update(self.apiclient, state='Enabled')
offering = dict(self.services["network"])
offering["networkoffering"] = network_offering.id
networks = []
def createNetwork(idx):
offering["name"] = "Test Network%s" % idx
network = Network.create(
self.apiclient,
offering,
self.account.name,
self.account.domainid,
zoneid=self.services["network"]["zoneid"]
)
networks.append(network)
self.cleanup.insert(0, network)
class NetworkMaker(threading.Thread):
def __init__(self, queue=None, createNetwork=None):
threading.Thread.__init__(self)
self.queue = queue
self.createNetwork = createNetwork
def run(self):
while True:
idx = self.queue.get()
if idx is not None:
self.createNetwork(idx)
self.queue.task_done()
# Start multiple networks
tsize = 8
queue = Queue.Queue()
for _ in range(tsize):
worker = NetworkMaker(queue, createNetwork)
worker.setDaemon(True)
worker.start()
for idx in range(tsize):
queue.put(idx)
queue.join()
# Deploy a VM
vm = VirtualMachine.create(
self.apiclient,
self.services["small"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[networks[0].id],
mode=self.zone.networktype
)
self.cleanup.insert(0, vm)
# Add nics to networks
for network in networks[1:]:
response = vm.add_nic(self.apiclient, network.id)
found = False
for nic in response.nic:
if nic.networkid == network.id:
found = True
break
self.assertTrue(found, "Nic not successfully added for the specific network")
# Stop VM
vm.stop(self.apiclient, forced=True)
vms = VirtualMachine.list(
self.apiclient,
id=vm.id
)
self.assertEqual(
validateList(vms)[0],
PASS,
"vms list validation failed")
vm_response = vms[0]
self.assertEqual(
vm_response.state,
"Stopped",
"Verify the VM is stopped"
)
# Start VM
vm.start(self.apiclient)
vms = VirtualMachine.list(
self.apiclient,
id=vm.id
)
self.assertEqual(
validateList(vms)[0],
PASS,
"vms list validation failed")
vm_response = vms[0]
self.assertEqual(
vm_response.state,
"Running",
"Verify the VM is running"
)
self.assertTrue(len(vm_response.nic) == len(networks), "Number of nics on VM not 8")
# Validate nics exist on each of the network
for network in networks:
found = False
for nic in vm_response.nic:
if nic.networkid == network.id:
found = True
break
self.assertTrue(found, "Nic not found for the specific network")
def test_02_isolate_network_FW_PF_default_routes_egress_false(self):
""" Test redundant router internals """
self.logger.debug("Starting test_02_isolate_network_FW_PF_default_routes_egress_false...")
self.logger.debug("Creating Network Offering with default egress FALSE")
network_offering_egress_false = NetworkOffering.create(self.apiclient,
self.services["network_offering_egress_false"],
conservemode=True)
network_offering_egress_false.update(self.apiclient, state='Enabled')
self.logger.debug("Creating Network with Network Offering ID %s" % network_offering_egress_false.id)
network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering_egress_false.id,
zoneid=self.zone.id)
self.logger.debug("Deploying Virtual Machine on Network %s" % network.id)
virtual_machine = VirtualMachine.create(self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.domain.id,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)])
self.logger.debug("Deployed VM in network: %s" % network.id)
self.cleanup.insert(0, network_offering_egress_false)
self.cleanup.insert(0, network)
self.cleanup.insert(0, virtual_machine)
self.logger.debug("Starting test_isolate_network_FW_PF_default_routes...")
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
self.assertNotEqual(
len(routers),
0,
"Check list router response"
)
router = routers[0]
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
self.assertEqual(
isinstance(public_ips, list),
True,
"Check for list public IPs response return valid data"
)
public_ip = public_ips[0]
self.logger.debug("Creating Firewall rule for VM ID: %s" % virtual_machine.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule"]["publicport"],
endport=self.services["natrule"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % virtual_machine.id)
# Create NAT rule
nat_rule = NATRule.create(
self.apiclient,
virtual_machine,
self.services["natrule"],
public_ip.id
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule.id
)
self.assertEqual(
isinstance(nat_rules, list),
True,
"Check for list NAT rules response return valid data"
)
self.assertEqual(
nat_rules[0].state,
'Active',
"Check list port forwarding rules"
)
expected = 0
ssh_command = "ping -c 3 8.8.8.8"
check_string = " 0% packet loss"
result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self)
self.assertEqual(
result,
expected,
"Ping to outside world from VM should NOT be successful"
)
expected = 0
ssh_command = "wget -t 1 -T 1 www.google.com"
check_string = "HTTP request sent, awaiting response... 200 OK"
result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self)
self.assertEqual(
result,
expected,
"Attempt to retrieve google.com index page should NOT be successful"
)
EgressFireWallRule.create(
self.apiclient,
networkid=network.id,
protocol=self.services["egress_80"]["protocol"],
startport=self.services["egress_80"]["startport"],
endport=self.services["egress_80"]["endport"],
cidrlist=self.services["egress_80"]["cidrlist"]
)
expected = 1
ssh_command = "wget -t 1 -T 5 www.google.com"
check_string = "HTTP request sent, awaiting response... 200 OK"
result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self)
self.assertEqual(
result,
expected,
"Attempt to retrieve google.com index page should be successful once rule is added!"
)
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 test_03_RVR_Network_check_router_state(self):
""" Test redundant router internals """
self.logger.debug("Starting test_03_RVR_Network_check_router_state...")
hypervisor = self.testClient.getHypervisorInfo()
self.logger.debug("Creating Network Offering with default egress FALSE")
network_offering_egress_false = NetworkOffering.create(
self.apiclient,
self.services["nw_off_persistent_RVR_egress_false"],
conservemode=True
)
network_offering_egress_false.update(self.apiclient, state='Enabled')
self.logger.debug("Creating network with network offering: %s" % network_offering_egress_false.id)
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering_egress_false.id,
zoneid=self.zone.id
)
self.logger.debug("Created network with ID: %s" % network.id)
networks = Network.list(
self.apiclient,
id=network.id,
listall=True
)
self.assertEqual(
isinstance(networks, list),
True,
"List networks should return a valid response for created network"
)
nw_response = networks[0]
self.logger.debug("Deploying VM in account: %s" % self.account.name)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)]
)
self.logger.debug("Deployed VM in network: %s" % network.id)
self.cleanup.insert(0, network_offering_egress_false)
self.cleanup.insert(0, network)
self.cleanup.insert(0, virtual_machine)
vms = VirtualMachine.list(
self.apiclient,
id=virtual_machine.id,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List Vms should return a valid list"
)
vm = vms[0]
self.assertEqual(
vm.state,
"Running",
"VM should be in running state after deployment"
)
self.logger.debug("Listing routers for network: %s" % network.name)
routers = Router.list(
self.apiclient,
networkid=network.id,
listall=True
)
self.assertEqual(
isinstance(routers, list),
True,
"list router should return Master and backup routers"
)
self.assertEqual(
len(routers),
2,
"Length of the list router should be 2 (Backup & master)"
)
vals = ["MASTER", "BACKUP", "UNKNOWN"]
cnts = [0, 0, 0]
result = "UNKNOWN"
for router in routers:
if router.state == "Running":
hosts = list_hosts(
self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list host returns a valid list"
)
host = hosts[0]
if hypervisor.lower() in ('vmware', 'hyperv'):
result = str(get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
router.linklocalip,
"sh /opt/cloud/bin/checkrouter.sh ",
hypervisor=hypervisor
))
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = str(get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
router.linklocalip,
"sh /opt/cloud/bin/checkrouter.sh "
))
except KeyError:
self.skipTest(
"Marvin configuration has no host credentials to\
check router services")
if result.count(vals[0]) == 1:
cnts[vals.index(vals[0])] += 1
if cnts[vals.index('MASTER')] != 1:
self.fail("No Master or too many master routers found %s" % cnts[vals.index('MASTER')])
return
def setUpClass(cls):
cls.logger = logging.getLogger('TestRouterDHCPHosts')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.testClient = super(TestRouterDHCPHosts, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.hostConfig = cls.config.__dict__["zones"][0].__dict__["pods"][0].__dict__["clusters"][0].__dict__["hosts"][0].__dict__
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.logger.debug("Creating Admin Account for domain %s on zone %s" % (cls.domain.id, cls.zone.id))
# Create an account, network, VM and IP addresses
cls.account = Account.create(
cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.logger.debug("Creating Service Offering on zone %s" % (cls.zone.id))
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.services["isolated_network_offering"]["egress_policy"] = "true"
cls.logger.debug("Creating Network Offering on zone %s" % (cls.zone.id))
cls.network_offering = NetworkOffering.create(cls.api_client,
cls.services["isolated_network_offering"],
conservemode=True)
cls.network_offering.update(cls.api_client, state='Enabled')
cls.logger.debug("Creating Network for Account %s using offering %s" % (cls.account.name, cls.network_offering.id))
cls.network = Network.create(cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.network_offering.id,
zoneid=cls.zone.id)
cls.logger.debug("Creating VM1 for Account %s using offering %s with IP 10.1.1.50" % (cls.account.name, cls.service_offering.id))
cls.vm_1 = VirtualMachine.create(cls.api_client,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.domain.id,
serviceofferingid=cls.service_offering.id,
networkids=[str(cls.network.id)],
ipaddress="10.1.1.50")
cls.logger.debug("Creating VM2 for Account %s using offering %s with IP 10.1.1.51" % (cls.account.name, cls.service_offering.id))
cls.vm_2 = VirtualMachine.create(cls.api_client,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.domain.id,
serviceofferingid=cls.service_offering.id,
networkids=[str(cls.network.id)],
ipaddress="10.1.1.51")
cls.services["natrule1"] = {
"privateport": 22,
"publicport": 222,
"protocol": "TCP"
}
cls.services["natrule2"] = {
"privateport": 22,
"publicport": 223,
"protocol": "TCP"
}
cls.services["configurableData"] = {
"host": {
"port": 22
},
"input": "INPUT",
"forward": "FORWARD"
}
cls._cleanup = [
cls.vm_2,
cls.network,
cls.network_offering,
cls.service_offering,
cls.account
]
return
def setUpClass(cls):
test_case = super(TestNiciraContoller, cls)
test_client = test_case.getClsTestClient()
cls.config = test_case.getClsConfig()
cls.api_client = test_client.getApiClient()
cls.physical_networks = cls.config.zones[0].physical_networks
cls.nicira_hosts = cls.config.niciraNvp.hosts
cls.physical_network_id = cls.get_nicira_enabled_physical_network_id(cls.physical_networks)
cls.network_offerring_services = {
'name': 'NiciraEnabledNetwork',
'displaytext': 'NiciraEnabledNetwork',
'guestiptype': 'Isolated',
'supportedservices': 'SourceNat,Firewall,PortForwarding,Connectivity',
'traffictype': 'GUEST',
'availability': 'Optional',
'serviceProviderList': {
'SourceNat': 'VirtualRouter',
'Firewall': 'VirtualRouter',
'PortForwarding': 'VirtualRouter',
'Connectivity': 'NiciraNvp'
}
}
cls.network_offering = NetworkOffering.create(cls.api_client, cls.network_offerring_services)
cls.network_offering.update(cls.api_client, state='Enabled')
cls.nicira_credentials = {
'username': '******',
'password': '******'
}
cls.nicira_master_controller = cls.determine_master_controller(
cls.nicira_hosts,
cls.nicira_credentials
)
cls.transport_zone_uuid = cls.get_transport_zone_from_controller(
cls.nicira_master_controller,
cls.nicira_credentials
)
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, test_client.getZoneForTests())
template = get_template(
cls.api_client,
cls.zone.id
)
if template == FAILED:
raise Exception("get_template() failed to return template with description %s" % cls.services['ostype'])
cls.vm_services = {
'mode': cls.zone.networktype,
'small': {
'zoneid': cls.zone.id,
'template': template.id,
'displayname': 'testserver',
'username': cls.config.zones[0].pods[0].clusters[0].hosts[0].username,
'password': cls.config.zones[0].pods[0].clusters[0].hosts[0].password,
'ssh_port': 22,
'hypervisor': cls.config.zones[0].pods[0].clusters[0].hypervisor,
'privateport': 22,
'publicport': 22,
'protocol': 'TCP',
},
'service_offerings': {
'tiny': {
'name': 'Tiny Instance',
'displaytext': 'Tiny Instance',
'cpunumber': 1,
'cpuspeed': 100,
'memory': 64,
}
}
}
if cls.zone.localstorageenabled == True:
cls.vm_services['service_offerings']['tiny']['storagetype'] = 'local'
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.vm_services['service_offerings']['tiny']
)
cls.cleanup = [
cls.network_offering,
cls.service_offering
]
def setUpClass(cls):
cls.logger = logging.getLogger('TestRouterDns')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.testClient = super(TestRouterDns, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.logger.debug("Creating Admin Account for domain %s on zone %s" % (cls.domain.id, cls.zone.id))
cls.account = Account.create(
cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.logger.debug("Creating Service Offering on zone %s" % (cls.zone.id))
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.logger.debug("Creating Network Offering on zone %s" % (cls.zone.id))
cls.services["isolated_network_offering"]["egress_policy"] = "true"
cls.network_offering = NetworkOffering.create(cls.api_client,
cls.services["isolated_network_offering"],
conservemode=True)
cls.network_offering.update(cls.api_client, state='Enabled')
cls.logger.debug("Creating Network for Account %s using offering %s" % (cls.account.name, cls.network_offering.id))
cls.network = Network.create(cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.network_offering.id,
zoneid=cls.zone.id)
cls.logger.debug("Creating guest VM for Account %s using offering %s" % (cls.account.name, cls.service_offering.id))
cls.vm = VirtualMachine.create(cls.api_client,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.domain.id,
serviceofferingid=cls.service_offering.id,
networkids=[str(cls.network.id)])
cls.vm.password = "******"
cls.services["natrule1"] = {
"privateport": 22,
"publicport": 22,
"protocol": "TCP"
}
cls.services["configurableData"] = {
"host": {
"password": "******",
"username": "******",
"port": 22
},
"input": "INPUT",
"forward": "FORWARD"
}
cls._cleanup = [
cls.vm,
cls.network,
cls.network_offering,
cls.service_offering,
cls.account
]
def test_02_RVR_Network_FW_PF_SSH_default_routes_egress_false(self):
""" Test redundant router internals """
self.logger.debug("Starting test_02_RVR_Network_FW_PF_SSH_default_routes_egress_false...")
self.logger.debug("Creating Network Offering with default egress FALSE")
network_offering_egress_false = NetworkOffering.create(
self.apiclient,
self.services["nw_off_persistent_RVR_egress_false"],
conservemode=True
)
network_offering_egress_false.update(self.api_client, state='Enabled')
self.logger.debug("Creating network with network offering: %s" % network_offering_egress_false.id)
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering_egress_false.id,
zoneid=self.zone.id
)
self.logger.debug("Created network with ID: %s" % network.id)
networks = Network.list(
self.apiclient,
id=network.id,
listall=True
)
self.assertEqual(
isinstance(networks, list),
True,
"List networks should return a valid response for created network"
)
nw_response = networks[0]
self.logger.debug("Deploying VM in account: %s" % self.account.name)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)]
)
self.logger.debug("Deployed VM in network: %s" % network.id)
self.cleanup.insert(0, network_offering_egress_false)
self.cleanup.insert(0, network)
self.cleanup.insert(0, virtual_machine)
vms = VirtualMachine.list(
self.apiclient,
id=virtual_machine.id,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List Vms should return a valid list"
)
vm = vms[0]
self.assertEqual(
vm.state,
"Running",
"VM should be in running state after deployment"
)
self.logger.debug("Listing routers for network: %s" % network.name)
routers = Router.list(
self.apiclient,
networkid=network.id,
listall=True
)
self.assertEqual(
isinstance(routers, list),
True,
"list router should return Master and backup routers"
)
self.assertEqual(
len(routers),
2,
"Length of the list router should be 2 (Backup & master)"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
self.assertEqual(
isinstance(public_ips, list),
True,
"Check for list public IPs response return valid data"
)
public_ip = public_ips[0]
self.logger.debug("Creating Firewall rule for VM ID: %s" % virtual_machine.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule"]["publicport"],
endport=self.services["natrule"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % virtual_machine.id)
nat_rule = NATRule.create(
self.apiclient,
virtual_machine,
self.services["natrule"],
public_ip.id
)
expected = 0
ssh_command = "ping -c 3 8.8.8.8"
check_string = " 0% packet loss"
result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self)
self.assertEqual(
result,
expected,
"Ping to outside world from VM should NOT be successful"
)
expected = 0
ssh_command = "wget -t 1 -T 1 www.google.com"
check_string = "HTTP request sent, awaiting response... 200 OK"
result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self)
self.assertEqual(
result,
expected,
"Attempt to retrieve google.com index page should NOT be successful"
)
EgressFireWallRule.create(
self.apiclient,
networkid=network.id,
protocol=self.services["egress_80"]["protocol"],
startport=self.services["egress_80"]["startport"],
endport=self.services["egress_80"]["endport"],
cidrlist=self.services["egress_80"]["cidrlist"]
)
EgressFireWallRule.create(
self.apiclient,
networkid=network.id,
protocol=self.services["egress_53"]["protocol"],
startport=self.services["egress_53"]["startport"],
endport=self.services["egress_53"]["endport"],
cidrlist=self.services["egress_53"]["cidrlist"]
)
expected = 1
ssh_command = "wget -t 1 -T 5 www.google.com"
check_string = "HTTP request sent, awaiting response... 200 OK"
result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self)
self.assertEqual(
result,
expected,
"Attempt to retrieve google.com index page should be successful once rule is added!"
)
return