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